Making translating enemy table to code.

Platform/Apple/tools/PackPartitions/src/org/demo/PackPartitions.groovy

@@ -719,7 +719,7 @@ class PackPartitions
                 case "f" : flagByte = 0x20; break
                 case "fb": flagByte = 0x40; break
                 case "r" : flagByte = 0x80; break
-                default  : throw "Unrecognized animation flags '$animFlags'"
+                default  : throw new Exception("Unrecognized animation flags '$animFlags'")
             }
             def newBuf = ByteBuffer.allocate(50000) // plenty of room
             buf.flip()  // crazy stuff to append one buffer to another
@@ -1456,12 +1456,27 @@ class PackPartitions
         return buf.toString()
     }
     
+    def parseDice(str)
+    {
+        // Handle single value
+        if (str =~ /^\d+$/)
+            return str
+            
+        // Otherwise parse things like "2d6+1"
+        def m = (str =~ /^(\d+)[dD](\d+)([-+]\d+)?$/)
+        if (!m) throw new Exception("Cannot parse dice string '$str'")
+        def nDice = m[0][1].toInteger()
+        def dieSize = m[0][2].toInteger()
+        def add = m[0][4] ? m[0][3].toInteger() : 0
+        return "encodeDice($nDice,$dieSize,$add)"
+    }
+    
     void genEnemy(out, columns, data)
     {
         assert columns[0] == "Name"
         def name = data[0]
         
-        out.print("def new_enemy_${humanNameToSymbol(name, false)}\n")
+        out.print("def new_enemy_${humanNameToSymbol(name, false)}()\n")
         
         assert columns[1] == "Image1"
         def image1 = data[1]
@@ -1505,6 +1520,21 @@ class PackPartitions
         assert columns[14].toLowerCase() =~ /gold loot/
         def goldLoot = data[14]
         
+        out.println("  word p; p = mmgr(HEAP_ALLOC, TYPE_ENEMY)")
+        out.println("  p=>s_name = mmgr(HEAP_INTERN, \"$name\")")
+        out.println("  p=>w_health = rollDice(${parseDice(hitPoints)}) // $hitPoints")
+        out.println("  p->ba_images[0] = PORTRAIT_${humanNameToSymbol(image1, true)}")
+        def attackTypeCode = attackType.toLowerCase() == "melee" ? 1 :
+                             attackType.toLowerCase() == "projectile" ? 2 :
+                             0
+        if (!attackTypeCode) throw new Exception("Can't parse attack type '$attackType'")
+        out.println("  p->b_attackType = $attackTypeCode // $attackType")
+        out.println("  p=>s_attackText = mmgr(HEAP_INTERN, \"$attackText\")")
+        out.println("  p->b_enemyAttackRange = ${range.replace("'", "").toInteger()}")
+        out.println("  p->b_chanceToHit = ${chanceToHit.toInteger()}")
+        out.println("  p=>r_enemyDmg = ${parseDice(damage)} // $damage")
+        out.println("  p=>r_groupSize = ${parseDice(groupSize)} // $groupSize")
+        out.println("  return p")
         out.println("end\n")
     }
     
@@ -1537,15 +1567,36 @@ class PackPartitions
         }
         
         // Translate enemies to code
-        new File("src/plasma/gen_enemies.pla").withWriter { out ->
-            def columns
-            new File("data/world/enemies.tsv").eachLine { line ->
-                if (columns)
-                    genEnemy(out, columns, line.split("\t"))
-                else
-                    columns = line.split("\t")
+        def enemyLines = new File("data/world/enemies.tsv").readLines()
+        new File("src/plasma/gen_enemies.plh").withWriter { out ->
+            out.println("// Generated code - DO NOT MODIFY BY HAND\n")
+            enemyLines[1..-1].eachWithIndex { line, index ->
+                out.println("const new_enemy_${humanNameToSymbol(line.split("\t")[0], false)} = ${index*2}")
             }
         }
+        new File("src/plasma/gen_enemies.pla").withWriter { out ->
+            out.println("// Generated code - DO NOT MODIFY BY HAND")
+            out.println()
+            out.println("include \"gamelib.plh\"")
+            out.println("include \"playtype.plh\"")
+            out.println("include \"gen_images.plh\"")
+            out.println()
+
+            def columns = enemyLines[0].split("\t")
+            enemyLines[1..-1].each { line ->
+                out.println("predef new_enemy_${humanNameToSymbol(line.split("\t")[0], false)}")
+            }
+            enemyLines[1..-1].eachWithIndex { line, index ->
+                out.print((index == 0) ? "\nword[] funcTbl = " : "word = ")
+                out.println("@new_enemy_${humanNameToSymbol(line.split("\t")[0], false)}")
+            }
+            out.println()
+            enemyLines[1..-1].each { line ->
+                genEnemy(out, columns, line.split("\t"))
+            }
+            out.println("return @funcTbl")
+            out.println("done")
+        }
         
         // Produce a list of assembly and PLASMA code segments
         readAllCode()

Platform/Apple/virtual/src/plasma/build.xml

@@ -31,7 +31,7 @@
     <apply executable="../../../tools/PLASMA/src/plasm" dir="${src.dir}" 
            relative="true" parallel="false" failonerror="true" verbose="true"
            addsourcefile="false">
-      <fileset dir="${src.dir}" includes="*.pla" excludes="gen_*,heaptest*,playtype*"/>
+      <fileset dir="${src.dir}" includes="*.pla" excludes="heaptest*,playtype*"/>
       <arg value="-AM"/>
       <redirector logError="yes">
         <!-- redirect STDIN; fileset collects relative to its dir, but we need -->

Platform/Apple/virtual/src/plasma/globalScripts.pla

@@ -238,73 +238,5 @@ def new_Player_Mokahnu
   return p
 end
 
-///////////////////////////////////////////////////////////////////////////////////////////////////
-def new_Enemy_Dirt_Bag
-  word p
-  p = mmgr(HEAP_ALLOC, TYPE_ENEMY)
-  p=>s_name = mmgr(HEAP_INTERN, "Dirt-Bag(s)")
-  p=>w_health = rollDice(encodeDice(1, 6, 0))
-  p->ba_images[0] = PORTRAIT_GUNMAN5
-  p->b_attackType = 1 // melee
-  p=>s_attackText = mmgr(HEAP_INTERN, "swings at")
-  p->b_enemyAttackRange = 5
-  p->b_chanceToHit = 15
-  p=>r_enemyDmg = encodeDice(1, 6, 0) // 1d6
-  p=>r_groupSize = encodeDice(1, 4, 0) // 1d4
-  p=>r_initialRange = encodeDice(2, 10, 0)
-  return p
-end
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-def new_EnemyGroup_Dirt_Bags
-  word p, enem, groupSize
-  p = mmgr(HEAP_ALLOC, TYPE_ENEMY_GROUP)
-  enem = new_Enemy_Dirt_Bag()
-  p->b_enemyGroupRange = rollDice(enem=>r_initialRange)
-
-  groupSize = rollDice(enem=>r_groupSize)
-  addToList(p + p_enemies, enem)
-  while groupSize > 1
-    addToList(p + p_enemies, new_Enemy_Dirt_Bag())
-    groupSize = groupSize - 1
-  loop
-
-  return p
-end
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-def new_Enemy_Flesh_Feeder
-  word p
-  p = mmgr(HEAP_ALLOC, TYPE_ENEMY)
-  p=>s_name = mmgr(HEAP_INTERN, "Flesh Feeder(s)")
-  p=>w_health = rollDice(encodeDice(6, 6, 0))
-  p->ba_images[0] = PORTRAIT_U_D_MAN1
-  p->b_attackType = 1 // melee
-  p=>s_attackText = mmgr(HEAP_INTERN, "bites")
-  p->b_enemyAttackRange = 5
-  p->b_chanceToHit = 40
-  p=>r_enemyDmg = encodeDice(3, 6, 0) // 3d6
-  p=>r_groupSize = encodeDice(1, 6, 0) // 1d6
-  p=>r_initialRange = encodeDice(1, 5, 0)
-  return p
-end
-
-///////////////////////////////////////////////////////////////////////////////////////////////////
-def new_EnemyGroup_Flesh_Feeders
-  word p, enem, groupSize
-  p = mmgr(HEAP_ALLOC, TYPE_ENEMY_GROUP)
-  enem = new_Enemy_Flesh_Feeder()
-  p->b_enemyGroupRange = rollDice(enem=>r_initialRange)
-
-  groupSize = rollDice(enem=>r_groupSize)
-  addToList(p + p_enemies, enem)
-  while groupSize > 1
-    addToList(p + p_enemies, new_Enemy_Flesh_Feeder())
-    groupSize = groupSize - 1
-  loop
-
-  return p
-end
-
 return @funcTbl
 done

Platform/Apple/virtual/src/plasma/playtype.plh

@@ -170,7 +170,6 @@ struc Enemy
   byte b_chanceToHit
   word r_enemyDmg     // 3 hex digits: num dice, die size, add. E.g. $361 = 3d6+1
   word r_groupSize    // number encountered, as 3 hex digits for dice
-  word r_initialRange
 end
 
 const TYPE_ENEMY_GROUP = $89