run

#!/usr/bin/ruby1.9.1

require './lib/dsl'

##### 30 turns
# build 2^8 = 8192
def build8192
  slot(2) { num8192 }
end

##### 44 turns
# build 10k-1 == 9999
if false then
  slot(2) { num9999 }
end

##### 602 turns total (including setup from above)
# heal from 10k to 20k
def heal
  1.times do
    lisp :inc, :zero
    lisp :help,
      :zero,
      :zero,
      [:get, [:succ, [:succ, :zero]]]
  end
end

##### 214-23 total turns
# heals 48493 at once, calls help using value stored in slot 2 (setup above)
def setup_rec_heal
  lisp :s,
          [:s, [:k, :get], [:k, :zero] ],
          [:s,
            [:s,
              [:k, [:help, :zero, :zero] ], 
              [:s,
                 [:k, :get],
                 :i] ],
            [:k, :zero]
          ]
  k!; s!; succ; k!; s!; succ;
end

# attack for 9k points, dealing 10k damage to own slot 0
def kick
  lisp :attack,
    :zero,
    [:get, [:succ, :zero]],
    [:succ, [:get, [:succ, [:succ, :zero]]]] # 1+9999
end

# attack for 2*8192 points, dealing similar damage to own slot 0
# this will kill the opponent in 1 turn, if they haven't healed
def setup_punch
  slot 0 do
    lisp :attack,
      :zero,
      [:get, [:succ, [:succ, [:succ, :zero]]]] # slot to attack
    k!; s!; get; k!; s!; succ; k!; s!; succ
  #    [:dbl, [:get, [:succ, [:succ]]]] # 1+9999
  end
end

def heal_once
  setup_rec_heal
  # copy into slot 1.. this is easier (and faster) than setting up a formula
  slot(1) { get; zero; }
  # heal once.. we are now at 48493
  zero
end

def super_heal
  lisp :get, [:succ, :zero]
  zero
end

# heal again, which will max us out at 65535
#super_heal

#####
# slot 0: active slot.. current functions are run from there
# slot 1: stores copy of rec_heal
# slot 2: stores LARGE_NUM, used for attack/heal
# slot 3: stores slot to attack
# slot 4: stores copy of punch

def perform_attack
  slot(3) { zero } # start with slot 0
  slot(2) { dbl! }

  # start attacking
  0.upto(255) do |j|
    if j > 0 and j % 2 == 1 then
      super_heal
    end

    # copy punch into slot 0
    setup_punch

    # attack
    slot(0) { zero }

    # next slot
    slot(3) { succ! } 
  end
end

def setup_heal10_rec
  slot 8 do
    lisp :s,
        [:s,
          [:help, :zero, :zero],
          [:s, 
            [:help, :zero, :zero],
            [:s,
              [:help, :zero, :zero],
              [:s,
                [:help, :zero, :zero],
                [:s,
                  [:help, :zero, :zero],
                  [:s,
                    [:help, :zero, :zero],
                    [:s,
                      [:help, :zero, :zero],
                      [:s,
                        [:help, :zero, :zero],
                        [:s,
                          [:help, :zero, :zero],
                          [:s,
                            [:help, :zero, :zero],
                            [:help, :zero, :zero]]]]]]]]]]],
        [:s,
            [:s,
                [:k, :get],
                [:k, :zero]],
            [:k, :zero]]
  end
end

def setup_rec_attack_heal
  lisp :s, [:attack, :zero, :slot3], :slot8
  k!; s!; get; k!; s!; succ; k!; s!; succ
end

def setup
  build8192
  heal_once

  slot(3) { zero } # start with slot 0
  setup_heal10_rec
end

def loop_attack
  0.upto(255) do |i|
    setup_rec_attack_heal
    zero
    " This isn't working yet.. we need to zombify slot3 with the code in slot8,
      and bind it inside K()
    "
    "
    zombie 
    slot3
    k!; s!; s; k!; s!; k; slot8; k!; s!; k; zero
    "
    slot(3) { succ! }
  end
end

def main
  setup
  while true do
    loop_attack

    # re-initialize state
    slot(0) { put! }
    slot(1) { put! }
    slot(2) { put! }
    slot(3) { put! }
    slot(4) { put! }
    slot(8) { put! }
    setup

    # revive all slots
    slot(0) { put!; zero; revive!; super_heal }
    slot(1) { put!; zero; revive!; super_heal }
    slot(2) { put!; zero; revive!; super_heal }
    slot(3) { put!; zero; revive!; super_heal }
    slot(4) { put!; zero; revive!; super_heal }
    slot(8) { put!; zero; revive!; super_heal }
  end
end

main