From 35ee989a704ccd73a52ee734f32dc13dde27f8a8 Mon Sep 17 00:00:00 2001 From: Dmitry Jemerov Date: Fri, 17 Jun 2011 17:32:57 +0200 Subject: [PATCH] implementation so far --- examples/src/LambdaTheGathering.jetl | 217 +++++++++++++++++++++++++++ 1 file changed, 217 insertions(+) create mode 100644 examples/src/LambdaTheGathering.jetl diff --git a/examples/src/LambdaTheGathering.jetl b/examples/src/LambdaTheGathering.jetl new file mode 100644 index 00000000000..efcf3a5652e --- /dev/null +++ b/examples/src/LambdaTheGathering.jetl @@ -0,0 +1,217 @@ +namespace LambdaTheGathering; + +class GameError(msg: String): Exception(msg) { +} + +fun print(s: String) { + System.out?.println(s) +} + +class Function(val name: String) { + fun apply(x: Value, proponent: Player): Value + fun toString() = name + fun asNumber(): Int { throw GameError("could not get numeric value of a function") } +} + +object Identity: Function("I") { + fun apply(x: Value, proponent: Player): Value = x +} + +object IdentityValue: Value(Identity) + +object Zero: Function("zero") { + fun apply(x: Value, proponent: Player): Value = Value(0) + fun asNumber(): Int = 0 +} + +object Succ: Function("succ") { + fun apply(x: Value, proponent: Player): Value = Value(x.asNumber() + 1) +} + +object Get: Function("get") { + fun apply(x: Value, proponent: Player): Value = proponent.getSlot(x.asNumber()).field +} + +object Dbl: Function("dbl") { + fun apply(x: Value, proponent: Player): Value = Value(x.asNumber() * 2) +} + +class HelpFunc2(val i: Value, val j: Value): Function("help(" + i + ")(" + j + ")") { + fun apply(x: Value, proponent: Player): Value { + val n = x.asNumber() + proponent.getSlot(i.asNumber()).decreaseVitality(n) + proponent.getSlot(j.asNumber()).increaseVitality(n * 11 / 10); + return Value(Identity) + } +} + +class HelpFunc(val i: Value): Function("help(" + i + ")") { + fun apply(x: Value, proponent: Player): Value = Value(HelpFunc2(i, x)) +} + +object Help: Function("help") { + fun apply(x: Value, proponent: Player): Value = Value(HelpFunc(x)) +} + +class KFunc(val arg: Value): Function("K(" + arg + ")") { + fun apply(x: Value, proponent: Player): Value = arg +} + +object K: Function("K") { + fun apply(x: Value, proponent: Player): Value = Value(KFunc(x)) +} + +class SFunc2(val f: Value, val g: Value): Function("S(" + f + ")(" + g + ")") { + fun apply(x: Value, proponent: Player): Value { + val h = f.apply(x, proponent) + val y = g.apply(x, proponent) + val z = h.apply(y, proponent) + return z + } +} + +class SFunc(val f: Value): Function("S(" + f + ")") { + fun apply(x: Value, proponent: Player): Value = Value(SFunc2(f, x)) +} + +object S: Function("S") { + fun apply(x: Value, proponent: Player): Value = Value(SFunc(x)) +} + +class Value(val n: Int, val f: Function, val isFunction: Boolean) { + this(n: Int): this(if (n > 65535) 65535 else n, Identity, false) {} + this(f: Function): this(0, f, true) {} + + fun equals(rhs: Any?): Boolean { + if (rhs is Value) { + val rhsValue = rhs as Value + if (rhsValue.isFunction) { + return isFunction && f === rhsValue.f + } + else { + return ! isFunction && n == rhsValue.n + } + } + return false + } + + fun apply(x: Value, proponent: Player): Value { + if (isFunction) return f.apply(x, proponent) + throw GameError("could not apply non-function value"); + } + + fun asNumber(): Int { + if (! isFunction) return n; + return f.asNumber() + } + + fun toString() = if (isFunction) f.name else Integer.toString(n) +} + +class Slot() { + var vitality: Int = 10000 + var field: Value = Value(Identity) + + val alive: Boolean get() = vitality > 0 + + fun isDefault() = vitality == 10000 && field == Value(Identity) + + fun increaseVitality(delta: Int) { + if (alive) { + vitality += delta + if (vitality > 65535) vitality = 65535; + } + } + + fun decreaseVitality(delta: Int) { + if (!alive || delta > vitality) throw GameError("cannot decrease vitality") + vitality -= delta + } + + fun toString() = "{" + vitality + "," + field.toString() + "}"; +} + +class Player() { + var opponent: Player + + val slots: Array = Array(256) + { + for(i in 0..255) { + slots[i] = Slot() + } + } + + fun getSlot(i: Int): Slot { + if (i < 0 || i > 255) throw GameError("invalid slot index") + if (!slots[i].alive) throw GameError("the slot is dead") + return slots[i] + } + + fun printSlots() { + print("(slots {10000,I} are omitted)") + for(val i in 0..255) { + if (!slots[i].isDefault()) { + print("" + i + "=" + slots[i].toString()) + } + } + } + + fun applyCardToSlot(index: Int, card: Function) { + print("applying card " + card + " to slot " + index) + slots[index].field = card.apply(slots[index].field, this) + } + + fun applySlotToCard(index: Int, card: Function) { + print("applying slot " + index + " to card " + card) + slots[index].field = slots[index].field.apply(Value(card), this) + } +} + +val p0 = Player() +val p1 = Player() + +fun main(args: Array) { + p0.opponent = p1 + p1.opponent = p0 + + print("player 0") + p0.printSlots() + p0.applySlotToCard(0, Help) + p0.printSlots() + p0.applySlotToCard(0, Zero) + p0.printSlots() + p0.applyCardToSlot(0, K) + p0.printSlots() + p0.applyCardToSlot(0, S) + p0.printSlots() + p0.applySlotToCard(0, Succ) + p0.printSlots() + p0.applySlotToCard(0, Zero) + p0.printSlots() + p0.applySlotToCard(1, Zero) + p0.printSlots() + p0.applyCardToSlot(1, Succ) + p0.printSlots() + p0.applyCardToSlot(1, Dbl) + p0.printSlots() + p0.applyCardToSlot(1, Dbl) + p0.printSlots() + p0.applyCardToSlot(1, Dbl) + p0.printSlots() + p0.applyCardToSlot(1, Dbl) + p0.printSlots() + p0.applyCardToSlot(0, K) + p0.printSlots() + p0.applyCardToSlot(0, S) + p0.printSlots() + p0.applySlotToCard(0, Get) + p0.printSlots() + p0.applyCardToSlot(0, K) + p0.printSlots() + p0.applyCardToSlot(0, S) + p0.printSlots() + p0.applySlotToCard(0, Succ) + p0.printSlots() + p0.applySlotToCard(0, Zero) + p0.printSlots() +}