def boost_muthafucka(self, critical_slot): boost_slot = reduce(lambda x, y: y if scnt(y[0]) < scnt(x[0]) and y[0] > 31 and y[1] >= 10000 and str(y[2]) == 'I' else x, zip(range(SLOTS), self.game.proponent.vitalities, self.game.proponent.values), (255, 0, ''))[0] if boost_slot != 255: self.boostable = False boost = self.boost_term crtslot = number_term(critical_slot) bstslot = number_term(boost_slot) boost_bot = LambdaSequenceBot(boost_slot, r'(help bstslot crtslot boost)', locals()) boost_bot.set_game(self.game) self.bots.insert(0, boost_bot)
def mk_seq(self): batslot = number_term(self.battery_slot) boost = number_term(self.boost) sequence = [] for t in [ r'(S help I batslot boost)', ]: t = parse_lambda(t, locals()) t = binarize_term(t) sequence += term_to_sequence(t) seq = SequenceBotNone(sequence, self.execution_slot) seq.set_game(self.game) return seq
def test_combo_bot(slot = 0): tgtslot = number_term(0) selfslot = number_term(slot) #m = number_term(INITIAL_VITALITY) sequence = [] for t in [ #r'((\c f x. (\i. (\g. i c f x) (i f x))) (\c f x. (\i. (\g. i c f x) (i f x))) (dec) (zero))', r'(((\atkslot icomb. K (icomb get selfslot) (icomb dec atkslot)) tgtslot) I)', ]: t = parse_lambda(t, locals()) t = binarize_term(t) sequence += term_to_sequence(t) return SequenceBot(sequence, slot)
def mk_seq(self): batslot = number_term(self.battery_slot) boost = number_term(40960) sequence = [] for t in [ r'(\icomb. (K (icomb get batslot)) (icomb S help I batslot boost))', ]: t = parse_lambda(t, locals()) t = binarize_term(t) sequence += term_to_sequence(t) seq = SequenceBotNone(sequence, self.battery_slot) seq.set_game(self.game) return seq
def mk_seq(self): batslot = number_term(self.battery_slot) atkslot = number_term(MAX_SLOT - self.target_slot) dmg = number_term(self.dmg) sequence = [] for t in [ r'(attack batslot atkslot dmg)', ]: t = parse_lambda(t, locals()) t = binarize_term(t) sequence += term_to_sequence(t) seq = SequenceBotNone(sequence, self.execution_slot) seq.set_game(self.game) return seq
def mk_seq(self): batslot = number_term(self.battery_slot) pppslot = number_term(self.pain_slot) obsslot = number_term(self.observer_slot) ggeslot = number_term(self.gauge_slot) sequence = [] for t in [ r"(\icomb. (K (icomb get batslot)) ((K (((S help I) batslot) (icomb get pppslot))) (attack batslot (icomb get obsslot) (icomb get ggeslot))))" ]: t = parse_lambda(t, locals()) t = binarize_term(t) sequence += term_to_sequence(t) seq = SequenceBotNone(sequence, self.battery_slot) seq.set_game(self.game) return seq
def __init__(self, bots, lcl): self.boost_term = number_term(8192) self.boostable = True self.lcl = lcl self.bots = [] for bot_slot, bot_lmb in bots: self.bots.append(LambdaSequenceBot(bot_slot, bot_lmb, self.lcl))
def allocate_register(self, register_slot): if not self.is_slot_available(register_slot): return False prop = self.game.proponent register_clean = str(prop.values[register_slot]) == 'I' terms = [goal.term for goal in self.goals] register_access = (cards.get, number_term(register_slot)) register_cost = sequential_cost(register_access) sub_term, advantage = optimal_subterm(register_cost, *terms) if not register_clean: advantage -= 1 # because we have to clean it up if advantage <= 0: return False sub_goal = Goal(sub_term, register_slot) self.introduce_get(sub_term, register_access) self.add_goal(sub_goal) return True
def test_seq_bot(slot = 0): n = number_term(8192) m = number_term(INITIAL_VITALITY) #Y = r'(\f. (\q. q q) (\x. f (x x)))' #Y = parse_lambda(Y) sequence = [] for t in [ r'(attack zero zero n)', r'(attack (succ zero) zero n)', r'(zombie zero (\id. (help ((id succ) zero) zero m))' ]: t = parse_lambda(t, locals()) t = binarize_term(t) sequence += term_to_sequence(t) return SequenceBot(sequence, slot)
def mk_seq(self): value = number_term(self.value) sequence = [] for t in [ r'((put I) value)', ]: t = parse_lambda(t, locals()) t = binarize_term(t) sequence += term_to_sequence(t) seq = SequenceBotNone(sequence, self.slot) seq.set_game(self.game) return seq
def __init__(self): self.terminate = False self.voltage = number_term(8192) self.otake = number_term(768) self.tgt = number_term(255) voltage = self.voltage otake = self.otake tgt = self.tgt self.sequence = MultipleLambdaSequencesBot([ ####(2, r'(\icomb. (icomb K (icomb get (succ (succ zero))) icomb) ((icomb get zero) (icomb get (succ zero))))'), ####(2, r'(\zeroarg icomb. (K (icomb (get (succ (succ zero))) (succ zeroarg) icomb)) ((icomb get zero) zeroarg))'), ###(2, r'(\zeroarg icomb. ((icomb get) (succ (succ zero)) (succ zeroarg)) ((icomb get) zero zeroarg))'), ###(0, r'(\x. help x x voltage)'), ####(1, r'(voltage)'), ###(3, r'((get (succ (succ zero))) zero I)'), #(2, r'(\icomb. (icomb K (icomb get (succ (succ zero))) icomb) ((icomb get zero) (icomb get (succ zero))))'), #(2, r'(\zeroarg icomb. (K (icomb (get (succ (succ zero))) (succ zeroarg) icomb)) ((icomb get zero) zeroarg))'), (0, r'(\icomb. icomb get 0 (icomb get 1 (icomb get 2)))'), (1, r'(\x. (\ic. ic attack 0 x otake) (K I x help 0 0 voltage))'), (2, r'(tgt)'), (3, r'(put I get zero I)'), ], locals())
def rec(cur, depth): global cnt scur = str(cur) if scur.isdigit() and scur not in optimized_numbers: t = terms.number_term(int(scur)) cost = terms.sequential_cost(t) if cost > len(steps): print len(steps), steps_to_str(steps), "->", scur optimized_numbers.add(scur) if scur in desired: print len(steps), steps_to_str(steps), "->", scur desired.remove(scur) if len(desired) == 0: print "Done. Press enter to exit" raw_input() exit() if depth == 0: return cnt += 1 if cnt % 500000 == 0: print cnt for i, (f, side) in enumerate(possible_steps): if len(steps) == 0 and i % num_parts != our_part: continue try: context.app_limit = 30 if side == "r": next = apply(cur, f, context) else: next = apply(f, cur, context) except Error as e: continue # except Exception as e: # print steps_to_str(steps+[(f, side)]) # print e # raise e # exit() steps.append((f, side)) rec(next, depth - 1) steps.pop()
def reuse_shit(self): assert self.current_goal is None prop = self.game.proponent terms = [goal.term for goal in self.goals] costs, _ = calc_costs_and_weights(*terms) for slot in slot_numbers_by_reachability: if prop.vitalities[slot] <= 0: continue value = prop.values[slot] if value == cards.I: continue # for speed shit = value_to_term(value) shit = unfold_numbers(shit) if shit in costs: access = (cards.get, number_term(slot)) if sequential_cost(access) < costs[shit]: if self.is_slot_available(slot): self.introduce_get(shit, access) del costs[shit]
def choose_move(self): if self.terminate: danger = self.spider_sense() # if self.we_re_done_for(): # return (LEFT_APP, 0, cards.I) if self.game.proponent.vitalities[0] > 0 and str(self.game.proponent.values[0]) == 'I': self.sequence = MultipleLambdaSequencesBot([ (0, r'(\icomb. icomb get 0 (icomb get 1 (icomb get 2)))'), ], locals()) self.sequence.set_game(self.game) self.terminate = False return self.choose_move() elif self.game.proponent.vitalities[1] > 0 and str(self.game.proponent.values[1]) == 'I': voltage = self.voltage otake = self.otake self.sequence = MultipleLambdaSequencesBot([ (1, r'(\x. (\ic. ic attack 0 x otake) (K I x help 0 0 voltage))'), ], locals()) self.sequence.set_game(self.game) self.terminate = False return self.choose_move() elif self.game.proponent.vitalities[2] > 0 and str(self.game.proponent.values[2]) == 'I': self.sequence = MultipleLambdaSequencesBot([ (2, r'(zero)'), ], locals()) self.sequence.set_game(self.game) self.terminate = False return self.choose_move() elif danger != -1: dng = number_term(MAX_SLOT - danger) self.sequence = MultipleLambdaSequencesBot([ (2, r'(put I dng)'), (3, r'(put I get zero I)'), ], locals()) self.sequence.set_game(self.game) self.terminate = False return self.choose_move() elif isinstance(self.game.proponent.values[2], IntValue) and self.game.opponent.vitalities[MAX_SLOT - self.game.proponent.values[2]] > 0: self.sequence = MultipleLambdaSequencesBot([ (3, r'(put I get zero I)'), ], locals()) self.sequence.set_game(self.game) self.terminate = False return self.choose_move() elif self.game.proponent.values[2] == 255: self.sequence = MultipleLambdaSequencesBot([ (2, r'(put I zero)'), ], locals()) self.sequence.set_game(self.game) self.terminate = False return self.choose_move() elif isinstance(self.game.proponent.values[2], IntValue) and self.game.opponent.vitalities[MAX_SLOT - self.game.proponent.values[2]] <= 0: self.terminate = False return (LEFT_APP, 2, cards.succ) else: self.terminate = False return (LEFT_APP, 2, cards.succ) move = self.sequence.choose_move() if move != None: return move self.terminate = True return self.choose_move()
def attack_term(i, j, n): i = number_term(i) j = number_term(j) n = number_term(n) return (cards.attack, i, j, n)
def introduce_get(self, sub_term, register_access): g, register_slot = fold_numbers(register_access) assert isinstance(register_slot, int) assert g == cards.get self.gets.add(register_slot) if not is_subterm_eager(sub_term, self.term): self.lazy_gets.add(register_slot) self.term = replace_leaf_subterm(sub_term, register_access, self.term) slot_numbers_by_reachability = sorted( range(rules.SLOTS), key=lambda n: sequential_cost(number_term(n))) class NetworkFail(Exception): pass def global_optimize_network(network): best = None best_cost = 1e100 orig = str(network) for reg_count in [1]+[3]*5: assert str(network) == orig t = network.clone() t.reg_count = reg_count t.refine()