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 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():
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
