still wip modularisation, game somehow boots

src/net/torvald/terrarum/modulebasegame/magiccontroller/TheMagicLanguage.kt

@@ -0,0 +1,109 @@
+package net.torvald.terrarum.modulebasegame.magiccontroller
+
+import net.torvald.terrarum.modulebasegame.gameactors.AVKey
+import net.torvald.terrarum.gameactors.Actor
+
+/**
+ * "Data Type" describing magical force
+ *
+ * Created by minjaesong on 2018-06-03.
+ */
+class TheMagicLanguage(vm: TheMagicMachine) {
+
+    open class MagicException : Exception()
+    class MagicPortReadError : MagicException()
+    class MagicPortWriteError : MagicException()
+
+
+    /**
+     * A vessel contains magical power to be process.
+     *
+     * Negative numbers are tsraoatrsed as if it's negative power (still has >0 amount)
+     */
+    class MagicAccumulator {
+        private var power = 0.0
+
+        fun pourIn(value: Double) {
+            power += value // positive powers and negative powers will cancel eath other
+        }
+        fun pourOut(value: Double) {
+            power -= value
+        }
+        fun pourOutInto(other: MagicAccumulator, value: Double) {
+            if (power >= 0) {
+                // pour out positive power without inversion; result is positive power
+                if (value >= 0) {
+                    val value = minOf(power, value)
+                    other.pourIn(value)
+                    power -= value
+                }
+                // pour out positive power with inversion; result is negative power
+                else {
+                    val value = minOf(-power, value)
+                    other.pourIn(value)
+                    power += value
+                }
+            }
+            else {
+                // pour out negative power without inversion; result is negative power
+                if (value < 0) {
+                    val value = minOf(power, value)
+                    other.pourIn(-value)
+                }
+                // pour out negative power with inversion; result is positive power
+                else {
+                    val value = minOf(-power, value)
+                    other.pourIn(-value)
+                }
+            }
+        }
+        fun dumpAllInto(other: MagicAccumulator) {
+            pourOutInto(other, this.power)
+        }
+        fun empty() {
+            // release residual power as heat or something
+
+            power = 0.0
+        }
+        fun readForPortWrite(): Double {
+            val r = power
+            power = 0.0
+            return r
+        }
+    }
+
+    interface MagicOutputPort {
+        fun read(a: MagicAccumulator): Double?
+        fun write(a: MagicAccumulator)
+    }
+
+    class HealthPort(val output1: Actor) : MagicOutputPort {
+
+        override fun read(a: MagicAccumulator): Double {
+            val value = output1.actorValue.getAsDouble(AVKey.HEALTH) ?: throw MagicPortReadError()
+            a.pourIn(value)
+            return value
+        }
+
+        override fun write(a: MagicAccumulator) {
+            val value = output1.actorValue.getAsDouble(AVKey.HEALTH) ?: throw MagicPortReadError()
+            output1.actorValue[AVKey.HEALTH] = value + a.readForPortWrite()
+        }
+    }
+
+
+
+    fun opCombine(a: MagicAccumulator, b: MagicAccumulator, c: MagicAccumulator) {
+        b.dumpAllInto(a)
+        c.dumpAllInto(a)
+    }
+
+    fun opRelease(akku: MagicAccumulator, port: MagicOutputPort) {
+        port.write(akku)
+    }
+
+    fun opSiphon(akku: MagicAccumulator, port: MagicOutputPort) {
+        port.read(akku)
+    }
+
+}