def choice_clicked(self, choice): clickable.unregister_all() if choice.set: setattr(World, choice.set, choice.value) if choice.morale_bonus: hero.active_hero.morale += choice.morale_bonus if hero.active_hero.morale > 100: hero.active_hero.morale = 100 if choice.next == "end_act1": if World.next_dungeon == "ogre": World.finding = "shield" if choice.next == "end_act2": if World.next_dungeon == "fire": World.finding = "sword" else: World.finding = "armor" if "end_act" in choice.next: import game event.fire("dungeon.setup", World.next_dungeon) game.mode = "dungeon" else: self.load_option(choice.next)
def calc_next_wave(): global wave, wave_landers, wave_units, wave_hp, wave_type global next_wave_type, next_wave_landers, next_wave_units, next_wave_hp wave += 1 log.debug("Next wave is %i", wave) wave_type = next_wave_type wave_hp = next_wave_hp wave_landers = next_wave_landers wave_units = next_wave_units #every six waves, things get harder. stage = int(wave/6) if wave % 6 == 0: next_wave_type = 'Swarm' next_wave_hp = 4 + int(wave ** low_power) next_wave_landers = 4 + int(stage ** high_power) next_wave_units = 1 + int(stage ** low_power) elif wave % 6 == 3: next_wave_type = 'Cluster' next_wave_hp = 8 + int(wave ** 1.2) next_wave_landers = 2 + + int(stage ** mid_power) next_wave_units = 3 + + int(stage ** mid_power) else: next_wave_type = 'Normal' next_wave_hp = 5 + wave next_wave_landers = 2 + int(stage ** mid_power) next_wave_units = 1 + stage if wave == 31: event.fire('victory')
def title_prompt(): while True: c = term.getkey() if c == 'enter': event.fire('explore.start') state.mode = 'explore' raise state.StateChanged()
def move(self): if self.dead: return self.move_delay -= 1 if self.move_delay > 0: return leaving = self.path.pop(0) leaving.in_path_of.discard(self) leaving.baddies.discard(self) self.move_delay = self.speed if leaving.character == world.Hill: self.move_delay += 3 if leaving.character == world.Mountain: self.move_delay += 6 if len(self.path) <= 1: log.debug("got to the target with %r hp", self.health) all_baddies.discard(self) life_cost = 1 + (game.wave/6) game.lives -= life_cost if game.lives <= 0 and game.mode != "defeat": event.fire('defeat') event.fire('error', "%i Li%s Lost!" % (life_cost, "fe" if life_cost == 1 else "ves")) return current = self.path[0] current.baddies.add(self)
def tick(self, dungeon): if not self.active_monster: if self.move_path: self.hero_location = self.move_path.pop(0) self.center_map_on_hero() else: dungeon.message_log.add("The hero has reached\nthe end of the dungeon!") import game game.mode = "boss" event.fire("boss.setup", dungeon) else: self.active_monster.battle_tick(hero.active_hero, self.hero_sprite, self.monster_sprite, dungeon) if self.active_monster.defeated: self.active_monster = None self.monster_sprite.is_invisible = True self.dirty = True if hero.active_hero.defeated: hero.active_hero.defeated = False self.active_monster = None hero.active_hero.in_combat = False self.monster_sprite.is_invisible = True hero.active_hero.lose_morale(10) if hero.active_hero.morale > 0: self.hero_sprite.set_at(0, 0, fg=pytality.colors.WHITE) dungeon.message_log.add("<LIGHTMAGENTA>Hero loses morale!") dungeon.message_log.add("The hero rises again...") hero.active_hero.hp = hero.active_hero.max_hp / 2 self.dirty = True
def title_input(key): global difficulty if key == "e" or (key == "left" and difficulty == "medium"): difficulty = "easy" elif key == "m" or (key == "left" and difficulty == "hard") or (key == "right" and difficulty == "easy"): difficulty = "medium" elif key == "h" or (key == "right" and difficulty == "medium"): difficulty = "hard" if key == "enter": if difficulty == "easy": game.lives = 120 game.resources = 500 game.reward_factor = 12 game.high_power = 2.0 game.mid_power = 1.1 game.low_power = 0.75 elif difficulty == "medium": game.lives = 100 game.resources = 400 game.reward_factor = 10 game.high_power = 2.2 game.mid_power = 1.2 game.low_power = 0.8 else: game.lives = 80 game.resources = 400 game.reward_factor = 8 game.high_power = 2.3 game.mid_power = 1.4 game.low_power = 0.85 create_help() game.mode = "game" event.fire("message", "Game started on %s difficulty." % difficulty.capitalize())
def test_prompt(self): import game event.fire("setup") event.fire("adventure.setup") active_adventure.load_option("final_1") game.mode = "adventure" game.start()
def lose_morale(self, loss): self.morale -= loss if self.morale <= 0: self.morale = 0 self.defeated = True import game game.mode = "defeat" event.fire("moraledefeat.setup")
def add_message(message, flip=False): log.debug("adding message: %r", message) rt = screen.RichText(message, x=0, wrap_to=M.text_width) M.messages.append(rt) M.last_message_idx = calc_offset(len(M.messages)) if flip: draw_message_log() event.fire('flip')
def test_mode(self): import game event.fire("setup") event.fire("dungeon.setup") hero.active_hero.has_sword = True hero.active_hero.has_shield = True game.mode = "dungeon" game.start(nosetup=True)
def try_move(self, x=0, y=0): px = self.player_x + x py = self.player_y + y if px < 0 or py < 0 or px >= self.width or py >= self.height: message.error("You cannot exit the map.", flip=True) return False tile = self.tiles[py][px] if tile.door: message.add("<YELLOW>You enter the next room.", flip=True) return ("changeroom", (x, y)) elif tile.warp: message.add("<YELLOW>You descend into the darkness.", flip=True) return ("changelevel", (None,)) elif tile.monster: message.add("<LIGHTRED>You attack the monster!", flip=True) state.mode = 'battle' event.fire('battle.start', tile.monster_properties) state.after_battle_tile = tile state.after_battle_pos = (px, py) raise state.StateChanged() elif tile.boss_door and not state.found_key: message.add("<LIGHTRED>You need a boss key to pass through this door.", flip=True) elif tile.passable: if tile.is_pickup and not tile.picked_up: #they found a thing! if tile.pickup_type == "health": message.add("<GREEN>You found a <LIGHTGREEN>Stone Of Health</>!", flip=True) state.player.bonus_hp += 1 state.player.cur_hp += 1 state.player.hp += 1 player.update_player_statblock(state.player) if tile.pickup_type == "key": message.add("<GREEN>You found a <LIGHTGREEN>Boss Key</>!", flip=True) state.found_key = True if tile.pickup_type == "limb": message.add("<GREEN>You found an <LIGHTGREEN>Orb Of Shiva</>!", flip=True) state.player.add_limb() if tile.pickup_type == "macguffin": message.add("<GREEN>You found a <LIGHTGREEN>Melimnerian Artifact</>!", flip=True) message.add("<GREEN>These powerful wards give you some control\nover the magical curse of Melimnor.", flip=True) state.player.quest_accuracy_bonus += 1 state.player.found_artifacts += 1 state.player.calc_stats() player.update_player_statblock(state.player) tile.clear() self.move_player(px, py) return True else: message.error("Something is in the way.", flip=True) return False
def level_prompt(): while True: event.fire('flip') ret = False key = term.getkey() if key in ('up', 'down', 'left', 'right') and not level.been_cursed: message.newline() message.add("The curse of Melimnor takes hold upon you!") state.player.add_limb() message.newline() level.been_cursed = True if key == 'enter': return elif key == 'f3' and False: #TAKE ME OUT BEFORE RELEASE state.player.mutate() elif key == 'f4' and False: #TAKE ME OUT BEFORE RELEASE state.player.add_limb() elif key == 'up': ret = level.layout.curr_room.try_move(y=-1) elif key == 'down': ret = level.layout.curr_room.try_move(y=+1) elif key == 'left': ret = level.layout.curr_room.try_move(x=-1) elif key == 'right': ret = level.layout.curr_room.try_move(x=+1) log.debug('ret: %r', ret) if not ret: continue elif ret is True: return else: action, args = ret log.debug("action: %r, args: %r", action, args) if action == 'changeroom': level.layout.change_room(*args) add_room_messages() draw_explore() elif action == 'changelevel': log.debug("changing level") level.layout = layouts.random_layout() state.found_key = False add_room_messages() draw_explore() message.add("<LIGHTRED>The stairs vanish behind you!") return
def start(): # For compatability reasons, i'm going to force pytality to be SDL only for this compo. pytality.term.init(backends=['pygame'], width=screen_width, height=screen_height) pytality.term.set_title('Untitled (Ludum Dare Jam #27: 10 Seconds)') pytality.term.set_cursor_type(2) pytality.term.clear() if '--no-sound' in sys.argv: sys.argv.remove('--no-sound') sound.no_sound = True if 'load-image' in sys.argv: # hack to view images easily import time import os import pygame while True: print "Updating" with open(sys.argv[-1]) as f: buf = pytality.ansi.read_to_buffer(f, width=80, crop=False) pytality.term.clear() buf.draw() pytality.term.flip() mtime = new_mtime = os.stat(sys.argv[-1]).st_mtime while new_mtime == mtime: if pygame.event.peek(pygame.locals.QUIT): sys.exit(0) pygame.event.pump() time.sleep(0.1) new_mtime = os.stat(sys.argv[-1]).st_mtime if 'test' in sys.argv: sys.argv.remove('test') import importlib import unittest unittest.main(importlib.import_module('gamelib.%s' % sys.argv[-1]), argv=['Test']) try: event.fire('setup') game.start() except game.GameShutdown: pytality.term.clear() except KeyboardInterrupt: pytality.term.clear() raise except Exception, e: log.exception(e) traceback.print_exc(e, file=sys.stderr) raise
def on_tick(): if game.growings: game.growings -= 1 world.grow_map() world.cursor_slop_x += 1 world.cursor_slop_y += 1 if not game.growings: world.cursor_slop_x = 0 world.cursor_slop_y = 0 game.wave_delay = game.fps * 60 return if game.wave_delay: game.wave_delay -= 1 if not game.wave_delay: event.fire('game.nextwave') return if not all_landers and not all_baddies: reward = game.reward_factor*(game.wave+9) game.resources += reward event.fire('message', "Wave %i Complete! <YELLOW>+$%i</>" % (game.wave, reward)) if game.wave < 5: event.fire('message', "The world begins to grow.") if game.wave % 6 == 0: event.fire('message', "The world is growing faster.") game.growings = 1 + (game.wave/6) return for lander in list(all_landers): lander.tick() #can't mutate during iteration for baddie in list(all_baddies): baddie.move()
def main(): log.debug('Starting up') term.init() term.settitle('Mutants Of Melimnor (PyWeek #13: Mutate!)') try: event.fire('setup') game.start() except game.GameShutdown: term.reset() except KeyboardInterrupt: term.reset() raise except Exception, e: log.exception(e) raise
def start(): log.debug("Game starting") state.new_state() state.mode = 'title' event.fire('%s.start' % state.mode) while state.running: try: event.fire('%s.tick' % state.mode) event.fire('%s.draw' % state.mode) event.fire('%s.prompt' % state.mode) event.fire('flip') except state.StateChanged: continue return
def main(): pytality.term.init(width=state.width, height=state.height) pytality.term.set_title('Dungeon Game (LD48 #22: Alone)') try: event.fire('setup') game.start() except game.GameShutdown: pytality.term.reset() except KeyboardInterrupt: pytality.term.clear() pytality.term.reset() raise except Exception, e: log.exception(e) raise
def scroll_message(rel=0, home=False, end=False): if state.mode not in ('battle', 'explore', 'defeat'): return if home: off = 0 elif end: off = len(M.messages) else: off = M.last_message_idx M.last_message_idx = calc_offset(off + rel) log.debug("new scroll offset: %r", M.last_message_idx) M.pointer.y = min(1+M.text_height, max(1, int(float(M.last_message_idx) * (M.text_height) / (len(M.messages) or 1)))) M.message_zone.dirty = M.pointer.dirty = True draw_message_log() event.fire('flip')
def test_generate(self): import dungeon import game event.fire("setup") event.fire("adventure.setup") #adventure.active_adventure.start_act() #adventure.active_adventure.start_act() #adventure.active_adventure.start_act() event.fire("dungeon.setup") game.mode = "boss" event.fire("boss.setup", dungeon.active_dungeon) game.start()
def main(): if len(sys.argv) > 1: pytality.term.init(backends=sys.argv[1:], width=screen_width, height=screen_height) else: pytality.term.init(width=screen_width, height=screen_height) pytality.term.set_title('The Battle For 35 Leukothea (LD48 #23: Tiny World)') pytality.term.clear() try: event.fire('setup') game.start() except game.GameShutdown: pytality.term.reset() except KeyboardInterrupt: pytality.term.clear() pytality.term.reset() raise except Exception, e: log.exception(e) raise
def getkey(): ''' Get a key of keyboard input. Returns 1 character or the name of the special key. Some special keys are hijacked and get events fired instead. ''' while True: key = raw_getkey() if key is None: continue if key in ['home', 'pgup', 'pgdn', 'end']: #message scroll if key == 'home': event.fire('scroll', home=True) if key == 'pgup': event.fire('scroll', rel= -1) if key == 'pgdn': event.fire('scroll', rel= 1) if key == 'end': event.fire('scroll', end=True) elif key == '\x03': #ctrl-c event.fire('ctrl-c') else: return key
def tick(self): if self.fire_end and self.i > self.fire_end: # and now fire adventure mode import game import adventure event.fire("adventure.setup") adventure.active_adventure.start_act() game.mode = "adventure" if self.i > self.end: if not self.reached_end: sound.play_music("Relax.mp3") self.reached_end = True self.root.children = [ self.title_tl_bg, self.title_tr_bg, self.title_tl, self.title_tr, self.title_bl, self.title_br, self.start_text, self.credits_text, ] if self.fire_end: self.root.children += [self.title_bl_fire, self.title_br_fire] if self.i % 15 == 7: self.start_text.fg = pytality.colors.WHITE self.start_text.update_data() elif self.i % 15 == 0: self.start_text.fg = pytality.colors.LIGHTGREY self.start_text.update_data() self.root.dirty = True self.i += 1 while self.stages and self.i >= self.stages[0][0]: i, line, color = self.stages.pop(0) line.fg = color line.update_data()
def run(event_name, *args): global mode with logic_lock: event.fire('%s.%s' % (mode, event_name), *args) event.fire('%s.predraw' % mode) event.fire('%s.draw' % mode) pytality.term.flip()
def start(): log.debug("Game starting") lastmode = None while True: if lastmode != state.mode: lastmode = state.mode event.fire('%s.start' % lastmode) event.fire('%s.draw' % state.mode) event.fire('%s.run' % state.mode)
def start(nosetup=False): log.debug("Starting Game") global tick_thread tick_thread = threading.Thread(target=tick_loop, name="tick_loop") tick_thread.daemon = True tick_thread.start() global input_thread input_thread = threading.Thread(target=input_loop, name="input_loop") input_thread.daemon = True input_thread.start() if not nosetup: event.fire("setup") event.fire("unknown.setup") try: while True: kwargs = action_queue.get() if kwargs is Stop: raise GameShutdown() event_name = kwargs.pop('type') if event_name == 'mouse_motion': clickable.mouse_move(**kwargs) pytality.term.move_cursor(**kwargs) if event_name == 'mouse_down': clickable.mouse_down(**kwargs) pytality.term.move_cursor(**kwargs) event.fire('%s.%s' % (mode, event_name), **kwargs) event.fire('%s.draw' % mode) pytality.term.flip() except KeyboardInterrupt as e: raise GameShutdown()
def test_victory(self): import game event.fire("victory.setup") game.mode = "victory" game.start()
def on_input(key): if key == '\x1b' and game.wave_delay: event.fire("message", "Skipping wave timer.") game.wave_delay = 1
def on_input(key): if key == 'v': event.fire('victory') if key == 'b': event.fire('defeat')
def tick(self): self.i += 1 if self.i % 15 == 0: # safety margin self.root.dirty = True self.stat_display.tick(self) # animation tickers self.hero_sprite.tick() self.boss_sprite.tick() self.action_overlay.tick(self.action_overlay) if self.state_delay: self.state_delay -= 1 if self.after_animation_state and not self.action_overlay.animation: self.next_state = self.after_animation_state self.after_animation_state = None self.state_delay = 0 if self.state_delay is not None and self.state_delay <= 0: self.state_delay = None if self.next_state == "hero_talk": if self.pending_attack_type: if self.pending_attack_type == "phys": self.message_log.add("The boss strikes!") damage = monsters.combat(self.boss_attack, hero.active_hero.defense * hero.active_hero.morale_multiplier(), powerful=self.pending_attack_powerful, durable=False) self.message_log.add("%s damage!" % damage) hero.active_hero.hp -= damage else: self.message_log.add("The boss uses magic!") damage= monsters.combat(self.boss_attack, hero.active_hero.m_defense * hero.active_hero.morale_multiplier(), powerful=self.pending_attack_powerful, durable=False) self.message_log.add("%s damage!" % damage) hero.active_hero.hp -= damage self.pending_attack_type = None if hero.active_hero.hp <= 0: self.message_log.add("The hero is defeated!") clickable.unregister_all() hero.active_hero.hp = 0 self.hero_sprite.animate("fade_out", anim_speed=3, restrict=True) self.next_state = "hero_defeated" self.state_delay = len(self.hero_sprite.overlay.empty_cells) / 3 + 5 elif not self.real_boss: hero.active_hero.morale += 5 if self.pending_attack_powerful: hero.active_hero.morale += 10 if hero.active_hero.morale > 100: hero.active_hero.morale = 100 if hero.active_hero.hp > 0: choice = random.choice(exchanges) self.show_dialog("hero", choice['hero'], "hero_attack", 0) self.next_choice = choice elif self.next_state == "hero_attack": self.hero_sprite.animate("flash") self.next_state = "hero_attack_2" self.state_delay = 6 elif self.next_state == "hero_attack_2": self.boss_sprite.animate("flash", color=pytality.colors.LIGHTRED) self.next_state = "boss_choose" self.state_delay = 15 elif self.next_state == "boss_choose": self.message_log.add("The hero strikes!") damage = monsters.combat(hero.active_hero.attack * hero.active_hero.morale_multiplier(), self.boss_defense, powerful=False, durable=False) self.message_log.add("%s damage!" % damage) self.boss_hp -= damage if self.boss_hp <= 0: self.message_log.add("The boss is defeated!") clickable.unregister_all() hero.active_hero.level_up(self.message_log) hero.active_hero.level_up(self.message_log) self.boss_hp = 0 self.boss_sprite.animate("fade_out", anim_speed=12, restrict=True) self.next_state = "boss_defeated" self.state_delay = len(self.boss_sprite.overlay.empty_cells) / 12 + 5 else: self.offer_choices(self.next_choice['choices']) elif self.next_state == "boss_attack": self.boss_sprite.animate("flash") self.next_state = "boss_attack_2" self.state_delay = 6 elif self.next_state == "boss_attack_2": self.hero_sprite.animate("flash", color=pytality.colors.LIGHTRED) self.next_state = "hero_talk" self.state_delay = 15 elif self.next_state == "boss_defeated": import game if self.real_boss: game.mode = "victory" event.fire("victory.setup") else: game.mode = "adventure" hero.active_hero.in_combat = False adventure.active_adventure.start_act() elif self.next_state == "hero_defeated": import game game.mode = "defeat" event.fire("defeat.setup")
if api_response['items'] != []: clusterObject = api_response['items'][0] clusterName = clusterObject['metadata']['name'] # Look for the ACM managed object, may contain the hibernate=skip label managedCluster = api_instance.get_cluster_custom_object( "cluster.open-cluster-management.io", "v1", "managedclusters", clusterName) if ('hibernate' in clusterObject['metadata']['labels'] and 'skip' == clusterObject['metadata']['labels']['hibernate']) or \ ('hibernate' in managedCluster['metadata']['labels'] and 'skip' == managedCluster['metadata']['labels']['hibernate']): print("Skip : " + clusterName) event.fire( clusterName, namespaceName, "clusterdeployment", "hibernating", "Skipping cluster " + clusterName + " labels.hibernate=skip. It will not be hibernating", "skipHibernating", "Normal", api_core) else: if clusterName != namespaceName: print("Skip : Namespace: " + namespaceName + " does not match cluster name: " + clusterName + "") continue print(TAKE_ACTION + ": " + clusterName, end='') clusterPatch = { "apiVersion": "hive.openshift.io/v1", "kind": "ClusterDeployment", "metadata": { "name": clusterName },
secret_data['projectID']), region=region) resp = req.execute() for quota in resp['quotas']: if quota['limit'] != 0 and quota['usage'] / quota[ 'limit'] > CM_THRESHOLD: msg = quota['metric'] + " " + str( quota['usage']) + "/" + str(quota['limit']) print(" \\ -> " + msg) eventName = 'quota-' + provider_name + "-" + quota[ 'metric'] event.fire( cloud_provider.metadata.name, cloud_provider.metadata.namespace, 'secret', eventName, "Quota warning for cloud provider " + provider_name + ": " + msg, 'FullQuota', 'Warning', api_core) elif cloud == "azr": azOSP = json.loads( dc(secret_data['osServicePrincipal.json'])) access_token = azurerm.get_access_token( azOSP['tenantId'], azOSP['clientId'], azOSP['clientSecret']) for region in [ 'centralus', 'eastus', 'eastus2', 'westus', 'westus2', 'southcentralus' ]: compute_usage = azurerm.get_compute_usage(
def on_input(key): x,y = world.cursor_pos() current_cell = world.get_at(x, y) if current_cell.tower: tower = current_cell.tower if key == '$': current_cell.tower = None all_towers.discard(tower) ordered_towers.remove(tower) game.resources += tower.value event.fire("message", "Tower sold!") return if key in "drs": if key == "d": cost = tower.upgrade_cost("damage") elif key == "r": cost = tower.upgrade_cost("range") elif key == "s": cost = tower.upgrade_cost("speed") else: return if cost > game.resources: event.fire("error", "Cannot upgrade tower:\n Insufficient resources") return if key == "d": tower.upgrade("damage") event.fire("message", "Tower Damage upgraded!") elif key == "r": tower.upgrade("range") event.fire("message", "Tower Range upgraded!") elif key == "s": tower.upgrade("speed") event.fire("message", "Tower Speed upgraded!") elif current_cell.buildable: if key in "blrs": if key == 'b': tower_type = BasicTower elif key == "l": tower_type = LongRangeTower elif key == "r": tower_type = RapidFireTower elif key == "s": tower_type = SniperTower if game.resources < tower_type.base_cost: event.fire("error", "Cannot construct tower:\n Insufficient resources") return game.resources -= tower_type.base_cost tower = tower_type(x=x, y=y) current_cell.tower = tower all_towers.add(tower) ordered_towers.append(tower) else: if key in "blrs": event.fire("error", "Cannot construct tower:\n Cell is not buildable") return