iconography, flashdown, weak randomness

README.md

@@ -58,15 +58,15 @@ sdk.dir=/opt/homebrew/share/android-commandlinetools/
 * Achieving greatness:
 
 ```shell
-desktop/build/libs/desktop-1.1.jar
+desktop/build/libs/desktop-x.y.jar
 ```
 
 * Which you can run:
 
 ```shell
-java -jar desktop/build/libs/desktop-1.1.jar
+java -jar desktop/build/libs/desktop-x.y.jar
 # or, on a Mac
-java -XstartOnFirstThread -jar desktop/build/libs/desktop-1.1.jar
+java -XstartOnFirstThread -jar desktop/build/libs/desktop-x.y.jar
 ```
 
 ### Packaging for a Mac
@@ -80,15 +80,15 @@ export JAVA_HOME=/path/to/java/17
 jpackage \
   --input desktop/build/libs/ \
   --name Tertis \
-  --app-version 1.1 \
-  --main-jar desktop-1.1.jar \
+  --app-version x.y \
+  --main-jar desktop-x.y.jar \
   --main-class org.merlin.tertis.DesktopLauncher \
   --type dmg \
   --java-options '-XstartOnFirstThread' \
   --icon mac/Tertis.icns
 ```
 
-Yielding: `Tertis-1.1.dmg`.
+Yielding: `Tertis-x.y.dmg`.
 
 ## Building for Android
 

build.gradle

@@ -21,7 +21,7 @@ buildscript {
 allprojects {
     apply plugin: "eclipse"
 
-    version = '1.1'
+    version = '1.2'
     ext {
         appName = "run"
         gdxVersion = '1.11.0'

core/src/org/merlin/tertis/Prefs.scala

@@ -48,4 +48,5 @@ object Prefs {
   final val HighContrast = new Pref("highContrast")
   final val TiltSpeed = new Pref("tiltSpeed")
   final val StuffHappens = new Pref("stuffHappens")
+  final val WeakRandomness = new Pref("weakRandomness")
 }

core/src/org/merlin/tertis/game/Block.scala

@@ -4,6 +4,9 @@ package game
 import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.math.MathUtils
 
+import scala.collection.mutable
+import scala.util.Random
+
 trait Test extends ((Int, Int) => Boolean)
 
 /** The symmetric flag causes ---- and _|- to alternate between two positions
@@ -89,6 +92,9 @@ object Block {
 
   def random: Block = blocks(randomNumber(blocks.length))
 
+  def bag: Iterator[Block] =
+    Random.shuffle(blocks).iterator
+
   // I question the randomness of MathUtils.random for 7
   private def randomNumber(n: Int): Int = {
     if (n == 7) {

core/src/org/merlin/tertis/game/Board.scala

@@ -4,7 +4,6 @@ package game
 import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.g2d.PolygonSpriteBatch
 import org.merlin.tertis.Geometry._
-import org.merlin.tertis.home.Icon.White
 import org.merlin.tertis.{Prefs, Tertis}
 
 import scala.collection.mutable
@@ -102,14 +101,15 @@ class Board(game: Game) {
         val region = board(j * Columns + i)
         if (region ne null) {
           Red.a = 1f - redAlpha // fade through red to invisible
-          val color =
-            if (ending || region.dead)
-              region.color.cpy.lerp(Red, redAlpha * redAlpha)
-            else if (flash.contains(region.identifier) && flashdown > 0)
+          val baseColor =
+            (flash.contains(region.identifier) && flashdown > 0).fold(
               region.color.cpy
-                .lerp(Color.WHITE, flashdown)
-            else
+                .lerp(Color.WHITE, flashdown),
               region.color
+            )
+          val color =
+            (ending || region.dead)
+              .fold(baseColor.cpy.lerp(Red, redAlpha * redAlpha), baseColor)
           BlockRenderer.render(
             batch,
             color,
@@ -211,5 +211,5 @@ object Board {
   private val Red = new Color(1, 0, 0, 1f) // nb: mutates
   val RedFadeSeconds = .5f
   val RedShiftAccelerationSeconds = .5f
-  val FlashdownSeconds = 0.3f
+  val FlashdownSeconds = 0.5f
 }

core/src/org/merlin/tertis/game/Game.scala

@@ -12,10 +12,11 @@ class Game extends Scene {
   var state: State = PlayingState
 
   val zenMode: Boolean = Prefs.ZenMode.isTrue
-  var stuffHappens: Boolean = Prefs.StuffHappens.isTrue
+  val stuffHappens: Boolean = Prefs.StuffHappens.isTrue
+  val weakRandomness: Boolean = Prefs.WeakRandomness.isTrue
 
   val board: Board = new Board(this)
-  val nextUp: NextUp = new NextUp
+  val nextUp: NextUp = new NextUp(this)
   var player: Player = new Player(this)
   val score: Score = new Score
   var fast: Boolean = false

core/src/org/merlin/tertis/game/NextUp.scala

@@ -4,28 +4,40 @@ package game
 import com.badlogic.gdx.graphics.g2d.PolygonSpriteBatch
 import org.merlin.tertis.Geometry._
 
-class NextUp {
-  var previous: Block = Block.random
+class NextUp(game: Game) {
+  private var previous = Option.empty[Block]
   private var previousAlpha = 0f
 
-  private var next: Block = Block.random
+  private var bag = Iterator.empty[Block]
+  private var next: Block = nextBlock
   private var nextAlpha = 0f
 
   def shift(): Block = {
-    previous = next
+    val current = next
+    previous = Some(next)
     previousAlpha = nextAlpha
-    next = Block.random
+    next = nextBlock
     nextAlpha = 0f
-    previous
+    current
   }
 
+  private def nextBlock: Block =
+    if (!game.weakRandomness) {
+      Block.random
+    } else {
+      if (!bag.hasNext) bag = Block.bag
+      bag.next()
+    }
+
   def update(delta: Float): Unit = {
     previousAlpha = (previousAlpha - delta / FadeOutSeconds) max 0f
     nextAlpha = (nextAlpha + delta / FadeInSeconds) min 1f
   }
 
   def render(batch: PolygonSpriteBatch): Unit = {
-    draw(batch, previous, previousAlpha, -.5f)
+    previous foreach { prev =>
+      draw(batch, prev, previousAlpha, -.5f)
+    }
     draw(batch, next, nextAlpha, 1f)
   }
 

core/src/org/merlin/tertis/home/Help.scala

@@ -69,10 +69,9 @@ class Help(home: Home, game: Option[Game] = None) extends Scene {
     Frame.render(batch)
   }
 
-  private val DesktopIconLeft = Dimension * 3
-  private val DesktopIconInterval = IconSize * 2
-  private val DesktopIconsTop =
-    ((Geometry.ScreenHeight + (DesktopIconInterval * 4 + IconSize)) / 2).floor
+  private val DesktopIconLeft = IconSize * 2
+  private val DesktopIconInterval = IconSize * 3
+  private val DesktopIconsTop = Geometry.ScreenHeight - IconSize * 5
 
   val desktopIcons: List[Icon] = List(
     new KeyIcon(
@@ -81,39 +80,44 @@ class Help(home: Home, game: Option[Game] = None) extends Scene {
       IconSize,
       Tertis.arrowKey,
       0f,
-      "Right"
+      "Right",
+      "Right arrow key"
     ),
     new KeyIcon(
       DesktopIconLeft,
       DesktopIconsTop - DesktopIconInterval,
       IconSize,
       Tertis.arrowKey,
       180f,
-      "Left"
+      "Left",
+      "Left arrow key"
     ),
     new KeyIcon(
       DesktopIconLeft,
       DesktopIconsTop - DesktopIconInterval * 2,
       IconSize,
       Tertis.arrowKey,
       90f,
-      "Rotate"
+      "Rotate",
+      "Up arrow key"
     ),
     new KeyIcon(
       DesktopIconLeft,
       DesktopIconsTop - DesktopIconInterval * 3,
       IconSize,
       Tertis.arrowKey,
       270f,
-      "Drop"
+      "Drop",
+      "Down arrow key"
     ),
     new KeyIcon(
       DesktopIconLeft,
       DesktopIconsTop - DesktopIconInterval * 4,
       IconSize,
       Tertis.metaKey,
       0f,
-      "Velocitator"
+      "Velocitator",
+      "Shift/control/alt/option key"
     )
   )
 

core/src/org/merlin/tertis/home/Icon.scala

@@ -5,7 +5,7 @@ import com.badlogic.gdx.Gdx
 import com.badlogic.gdx.graphics.Color
 import com.badlogic.gdx.graphics.g2d.PolygonSpriteBatch
 import org.merlin.tertis.Geometry.Dimension
-import org.merlin.tertis.home.Icon.White
+import org.merlin.tertis.home.Icon._
 import org.merlin.tertis.util.TextureWrapper
 
 trait Icon {
@@ -132,11 +132,13 @@ class KeyIcon(
     val size: Float,
     icon: TextureWrapper,
     rotation: Float,
-    label: String
+    label: String,
+    description: String
 ) extends BaseIcon {
 
   override def draw(batch: PolygonSpriteBatch, alpha: Float): Unit = {
-    batch.setColor(White ⍺ alpha)
+    val color = White ⍺ alpha
+    batch.setColor(color)
     batch.draw(
       icon,
       x - size / 2,
@@ -155,9 +157,18 @@ class KeyIcon(
       false,
       false
     )
-    Text.smallFont.setColor(White ⍺ alpha)
-    val textY = y + Text.smallFont.getAscent
+    Text.smallFont.setColor(color)
+    val textY =
+      y + (Text.smallFont.getLineHeight + Text.tinyFont.getAscent - Text.tinyFont.getDescent) / 2
     Text.smallFont.draw(batch, label, x + size * 1.25f, textY)
+    val grey = Grey ⍺ alpha
+    Text.tinyFont.setColor(grey)
+    Text.tinyFont.draw(
+      batch,
+      description,
+      x + size * 1.25f,
+      textY - Text.smallFont.getLineHeight
+    )
   }
 
   override def clicked(): Unit = ()

core/src/org/merlin/tertis/home/Settings.scala

@@ -61,6 +61,14 @@ class Settings(home: Home) extends Scene {
       "High contrast",
       "More vivid colours."
     ),
+    new CheckIcon(
+      IconSize * 2,
+      IconTop - IconSpacing * 3,
+      IconSize,
+      Prefs.WeakRandomness,
+      "Weak randomness",
+      "Bind the hands of fate."
+    ),
   )
 
   override def init(): SettingsControl =