def __init__(self, prevstate): Screen.__init__(self) Battle.__init__(self, prevstate) text1 = Font("menu", 24, (255, 0, 0), "Battle Screen Goes Here") text2 = Font("menu", 16, (255, 255, 255), "Press 'Esc' to go back to the game.") self.add([text1, text2]) print "init battle" sounds.sounds.SWORD.play()
def action(self, controller): pos = controller.pos() for i, bounds in enumerate(WORLDS_BOUNDS): if controller.button_a and scene.contains(bounds, pos): self.client.send(i) s = Battle(self.client, self.player_id, i) s.server = self.server return s return self
def update(self, date): if self.way and self.next_province != self.way[-1]: #change way since last update self.next_province = self.way[-1] self.time_walking = 0 if self.time_walking >= self.location.size: #enter a new province self.time_walking -= self.location.size province = self.next_province self.location = province self.way.pop() if self.way: self.next_province = self.way[-1] else: self.next_province = None self.attitude = 'normal' #when enter a new province, look if there is enemy or already a battle person = self.for_the battle = province.battle if not battle: war = None enemies = [] for army_in_province in province.armies: if not war: war = person.in_war_against(army_in_province.for_the)['war'] enemies.append(army_in_province) else: w = person.in_war_against(army_in_province.for_the)[0]['war'] if w == war: enemies.append(army_in_province) if enemies: #enemy so battle self.stop() Battle.new(war, province, [self], enemies) else: war = battle.war if person in war.aggressors: self.stop() battle.add_aggressor(self) if person in war.defenders: self.stop() battle.add_defender(self) if self.next_province: self.time_walking += 500 * self.location.land.walkable else: self.time_walking = 0 #morale if self.attitude == 'normal': if self.morale < 95: self.morale += 5 else: self.morale = 100 self.save()
def client(server_address, local_player): global battle, pokemon_client, pokemon_server, player player = local_player battle = Battle(client = True) pokemon_client = Pokemon.create_pokemon() xml = xml_pokemon.generate(pokemon_client, pokemon_server) response = requests.post('http://' + server_address + ':5000/battle', data = xml, headers={'Content-Type': 'application/xml'}) not_first_round = False while response.status_code == 200: if not_first_round: server_hp = pokemon_server.hp dummy, pokemon_server = xml_pokemon.parse(response.content.decode('utf-8')) print (pokemon_client.name + " inflicted " + str(server_hp - pokemon_server.hp) + " points of damage in " + pokemon_server.name + "!") battle.print_battle_status(pokemon_client, pokemon_server) if battle.battle_ended(pokemon_client, pokemon_server): return client_hp = pokemon_client.hp pokemon_client, dummy = xml_pokemon.parse(response.content.decode('utf-8')) print (pokemon_server.name + " inflicted " + str(client_hp - pokemon_client.hp) + " points of damage in " + pokemon_client.name + "!") battle.print_battle_status(pokemon_client, pokemon_server) if battle.battle_ended(pokemon_client, pokemon_server): return else: pokemon_client, pokemon_server = xml_pokemon.parse(response.content.decode('utf-8')) battle.print_battle_status(pokemon_client, pokemon_server) if player == "user": option = pokemon_client.perform_attack_client() elif player == "ai": option = pokemon_client.perform_attack_client_ai(pokemon_server) xml = xml_pokemon.generate(pokemon_client, pokemon_server) response = requests.post('http://' + server_address + ':5000/battle/attack/' + option, data = xml, headers={'Content-Type': 'application/xml'}) not_first_round = True
def execute(self): from battle import Battle; battle = self.black_board.get("battle"); is_attack = self.black_board.get("side"); target_list = []; if is_attack: target_list = list(Battle.get_all_alive(battle.defenders_list)); else: target_list = list(Battle.get_all_alive(battle.attackers_list)); target = self.choose_target(target_list); battle.add_event(NormalAttackEvent(self.black_board.get("self"), target, battle));
def test_one(self): hero = Fighter("Hero", 8) hero.set_attack(5) hero.set_armor(5) boss = Fighter("Boss", 12) boss.set_attack(7) boss.set_armor(2) battle = Battle(hero, boss) battle.start() expected = hero actual = battle.get_winner() self.assertEqual(expected, actual)
class Game(object): """ Constructor for Game. Initializes pygame and sets up the window """ def __init__(self): pygame.init() width = 800 height = 600 self.screen = pygame.display.set_mode((width, height)) pygame.display.set_caption("AI Combat") self.clock = pygame.time.Clock() # For now, start directly in Battle mode # Other modes in the future may include menu, settings, splash, etc. self.battle = Battle() self.game_tick = 20 """ Starts the game by entering into the infinite game loop """ def start(self): elapsed = 0 while 1: # Sleep in such a way that the game does not exceed 60 FPS # (This value is completely arbitrary) elapsed += self.clock.tick(60) while elapsed >= self.game_tick: # Event processing events = [] for event in pygame.event.get(): if event.type == pygame.QUIT: return events.append(event) # Update battle state self.battle.update(events, self.game_tick) elapsed -= self.game_tick # Paint stuff (does not actually paint until you call # pygame.display.update) # The list of rects returned by the draw tells pygame.display # which parts to actually draw rects = self.battle.draw(self.screen) # Paint the screen pygame.display.update(rects)
def start_battle(self): try: self.poke_cliente = Pokemon(request.data, xml = True) except etree.XMLSyntaxError as e: print('Erro de sintaxe no XML: ', e) abort(422) if len(sys.argv) == 3: poke = Pokemon(sys.argv[2]) elif len(sys.argv) == 2: poke = Pokemon(sys.stdin) self.poke_server = poke self.battle = Battle() self.ai = AI() first = self.battle.get_first(self.poke_server, self.poke_cliente) if first is self.poke_server: choice = self.battle.make_choice(self.poke_server, self.poke_cliente, self.ai) self.battle.attack(self.poke_server, self.poke_cliente, choice) self.battle.all_alive(self.poke_server, self.poke_cliente) xml = self.poke_cliente.to_XML('<battle_state></battle_state>') xml = self.poke_server.to_XML(xml) else: xml = self.poke_server.to_XML(request.data) return xml, 200
def run(self): if not self.fleet.isReady(): return Auto25.Error self.battle = Battle(self.game, 205, self.fleet) spot, enemy = self.battle.go() Log.i('Spot: ' + str(spot)) Log.i('Enemy fleet: ' + str(enemy)) # if spot != 991602: # return AutoE3.Pit self.newShips = [ None, None, None ,None,None] for i in range(5): if i != 0: spot, enemy = self.battle.go() Log.i('Spot: ' + str(spot)) Log.i('Enemy fleet: ' + str(enemy)) if i == 2: if spot != 20504: return Auto25.Pit self.battle.start(2) self.newShips[i], hp = self.battle.giveUp() Log.i('Got %s at spot %d' % (self.newShips[i].getName() if self.newShips[i] is not None else 'nothing', i)) Log.i(self.fleet.printHp()) for ship in self.fleet.ships: if ship.isBadlyBroken(): self.end() return Auto25.Broke self.end() return Auto25.OK
def run(self): if not self.fleet.isReady(): return AutoE4.Error self.battle = Battle(self.game, 9916, self.fleet) spot, enemy = self.battle.go() Log.i('Spot: ' + str(spot)) Log.i('Enemy fleet: ' + str(enemy)) if spot != 991602: return AutoE4.Pit self.newShips = [ None, None, None ] for i in range(3): if i != 0: self.battle.go() self.battle.engage(2) self.newShips[i], hp = self.battle.giveUp() Log.i('Got %s at spot %d' % (self.newShips[i].getName() if self.newShips[i] is not None else 'nothing', i)) Log.i(self.fleet.printHp()) for ship in self.fleet.ships: if ship.isBroken(): self.end() return AutoE4.Broke self.end() return AutoE4.OK
def __init__(self): pygame.init() width = 800 height = 600 self.screen = pygame.display.set_mode((width, height)) pygame.display.set_caption("AI Combat") self.clock = pygame.time.Clock() self.battle = Battle()
class TestGame(object): def __init__(self): self.screen = pygame.display.set_mode(screen_size) self.key_repeater = self.construct_key_repeater() self.battle = Battle() @staticmethod def construct_key_repeater(): return KeyRepeater( one_time_keys=( pygame.K_ESCAPE, pygame.K_s, pygame.K_d, ), repeated_keys=( pygame.K_UP, pygame.K_RIGHT, pygame.K_DOWN, pygame.K_LEFT, ), pause=framerate/4, repeat=framerate/8, ) def game_loop(self): while True: if self.handle_events(): self.draw() time.sleep(delay) def handle_events(self): for event in pygame.event.get(): if event.type == pygame.QUIT: sys.exit() self.key_repeater.handle_event(event) keys = self.key_repeater.query() if pygame.K_ESCAPE in keys: sys.exit() return self.battle.transition(keys) def draw(self): self.battle.draw(self.screen) pygame.display.flip()
def main(): player = Player() printIntro() choice = 'yes' no = ['no','n'] yes = ['yes','y','ye'] while player.getPurse() > 0 and choice not in no: print "You have", player.getPurse(),"in your pouch.\n" battle = Battle() print "\nThe next battle is between %s and %s.\n" % (battle.warrior1.getName(),battle.warrior2.getName()) announceWarriors(battle.warrior1,battle.odds1,battle.warrior2,battle.odds2) print "\nDo you want to bet?\n\n" player.getChoice(battle.warrior1,battle.warrior2) winner, odds = battle.battle() if winner == player.getPick(): player.updatePurse("win",player.getBet(),odds) else: player.updatePurse("lose",player.getBet(),odds) print "\nWould you like to bet on the next battle?\n" while True: try: choice = string.lower(str(raw_input(">> "))) if choice in yes: break elif choice in no: choice = 'no' break else: print "\nPlease choose yes or no.\n" continue except ValueError: print "\nPlease choose yes or no.\n" continue print "\nThank you so much for playing!\n" if player.getPurse() > 1: print "\nYou leave the Colosseum with %d coins in your purse.\n" % player.getPurse() elif player.getPurse() == 1: print "\nYou leave the Colosseum with one coin, not even another to rub it against.\n" else: print "\nYou're leaving dead broke!\n"
def __init__(self): pygame.init() width = 800 height = 600 self.screen = pygame.display.set_mode((width, height)) pygame.display.set_caption("AI Combat") self.clock = pygame.time.Clock() # For now, start directly in Battle mode # Other modes in the future may include menu, settings, splash, etc. self.battle = Battle() self.game_tick = 20
class Game(): """ Constructor for Game. Initializes pygame and sets up the window """ def __init__(self): pygame.init() width = 800 height = 600 self.screen = pygame.display.set_mode((width, height)) pygame.display.set_caption("AI Combat") self.clock = pygame.time.Clock() self.battle = Battle() """ Starts the game by entering into the infinite game loop """ def start(self): while 1: # Sleep in such a way that the game does not exceed 30 FPS elapsed = self.clock.tick(30) # Event processing events = [] for event in pygame.event.get(): if event.type == pygame.QUIT: return events.append(event) # Update battle state self.battle.update(events, elapsed) # Paint stuff (does not actually paint until you call # pygame.display.flip) self.screen.fill((0,0,0)) self.battle.draw(self.screen) # Paint the screen pygame.display.flip()
def __init__(self,map_name): pygame.init() self.core = Core() self.mode = Event_Handler() self.file = 'ingame_temp'#заміна self.file в Core.py #self.map_type - треба замінити в Core.py #self.x_coord_start self.x_coord_end - замінити в Core.py self.battle = Battle('1') self.resources = Resources() self.graphical_logic = Graphical_logic() self.w_event = Events() self.minimap_x =0 self.minimap_y =0 self.count = 0 self.days = 0 self.fraction = 1 # першими ходять червоні self.map_name = map_name self.stage = 0 self.save_load_name = '' self.fractions = [[1, 1, 0, 0, 3, 1],[2, 1, 0, 0, 0, 0]]
def battle_start(): global battle, pokemon_client, pokemon_server, player if battle == None: battle = Battle(server = True) else: abort(403) xml = request.data.decode('utf-8') pokemon_client, dummy = xml_pokemon.parse(xml) pokemon_server = Pokemon.create_pokemon() battle.print_battle_status(pokemon_client, pokemon_server) if pokemon_server.speed > pokemon_client.speed: if player == "user": option = pokemon_server.perform_attack_server() elif player == "ai": option = pokemon_server.perform_attack_server_ai(pokemon_client) pokemon_server.inflict_and_announce_damage_server(pokemon_client, option) battle.print_battle_status(pokemon_client, pokemon_server) if battle.battle_ended(pokemon_client, pokemon_server): server_shutdown() xml = xml_pokemon.generate(pokemon_client, pokemon_server) return xml
def create_battle(): window = create_window() battle = Battle(window) return battle
from sayan import Sayan from shadow import Shadow from store import Store from thief import Thief from wizard import Wizard from zombie import Zombie from mimic import Mimic hero = Hero('Oakley') enemies = [ Goblin('Bob'), Wizard('Jethro'), Medic('Mercy'), Thief('Barry'), Mimic('Harry'), Zombie('Rick'), Shadow('Matt'), Sayan('Goku') ] # enemies = [Thief('Barry')] Goblin('Bob'), Wizard('Jethro'), Medic('Mercy'), Thief('Barry'), Zombie('Rick'), Shadow('Matt'), Sayan('Goku'), battle_engine = Battle() shopping_engine = Store() for enemy in enemies: hero_won = battle_engine.do_battle(hero, enemy) if not hero_won: print("YOU LOSE!") exit(0) shopping_engine.do_shopping(hero, enemy) print("YOU WIN!")
async def battle(self, ctx, *, args=""): '''Begin a battle against another player. Can specify size of game as well.''' if not self.cached: await ctx.send("Caching things on first run") await self.set_local_cache() player = str(ctx.author.id) if not player in self.battles: args = args.split() if len(args) == 0: args = [""] enemy = await self.at_to_id(args[0].strip()) if len(args) > 1: cap = int(args[1]) else: cap = 10 if not enemy in self.trading: await ctx.send( "Player not recognised!\nFor now, starting a testing battle" ) self.battles[player] = Battle( { player: [], "test": self.capelist[:2] }, self.battle_stats, cap=cap, channel=ctx.channel) self.battles[player].teams["test"].ready = True self.battles[player].teams["test"].move = "Defend" return else: await ctx.send( "Starting a battle. Both go add your cards as fighting capes in PMs using `%battle add capename, capename, capename`!" ) self.battles[player] = Battle({ player: [], enemy: [] }, self.battle_stats, cap=cap, channel=ctx.channel) self.battles[enemy] = self.battles[player] elif not self.battles[player].started: if args.split()[0] == "add": splittup = args[4:].split(",") capes = [] for i in splittup: capes += [i.strip()] if await self.has_cards(player, capes): for card in capes: cape = await self.get_cape(card) self.trading[player].remove(cape) if not self.battles[player].teams[player].add_cape( cape): await ctx.send( f"Adding {card} exceeds the quota for the team" ) else: await ctx.send(f"You don't have all of those cards!") await ctx.send( self.battles[player].teams[player].info_string()) elif args.split()[0].lower() == "quit" or args.split()[0].lower( ) == "cancel": # Quitting before the game starts! await ctx.send("Quitting the game") for i in self.battles[player].teams: if i != player: enemy = i await self.battles[player].channel.send( f"<@{enemy}>, <@{player}> has cancelled the battle!") for bc in self.battles[player].teams[player].team: self.trading[player] += [bc.cape] del self.battles[player] if enemy in self.battles: for bc in self.battles[enemy].teams[enemy].team: self.trading[enemy] += [bc.cape] del self.battles[enemy] elif args.split()[0].lower() == "start" or args.split()[0].lower( ) == "ready": p_team = self.battles[player].teams[player] if p_team.cap is not None and p_team.quota( ) < p_team.cap and not p_team.forcing: p_team.forcing = True await ctx.send( "You haven't filled your team to the cap, are you sure you want to start? Resend the command if so!" ) return p_team.ready = True if self.battles[player].ready(): self.battles[player].started = True await ctx.send("Other player is ready. Game starting!") await self.start_battle(self.battles[player]) else: await ctx.send("Waiting for other player!") elif self.battles[player].started: strategy = args.split()[0].lower() p_team = self.battles[player].teams[player] if strategy == "attack": p_team.move = "Attack" elif strategy == "defend": p_team.move = "Defend" elif strategy == "ambush": p_team.move = "Ambush" elif strategy == "flee": p_team.move = "Flee" elif strategy == "stats": await ctx.send( self.battles[player].teams[player].info_string()) return else: await ctx.send("Strategy is not recognised") return if self.battles[player].do_turn(): await ctx.send("Starting the new round!") await self.do_battle_round(self.battles[player]) else: await ctx.send("Waiting for other player to decide strategy")
def play(self): battle = Battle(self, self.units) battle.start()
from battle import Battle import monsters import heroes if __name__ == "__main__": #creates a battle battle = Battle() #create enemies battle.add_enemy(monsters.BasicMonster("evil bert", 10, 20)) battle.add_enemy(monsters.BasicMonster("evil ernie", 5, 8)) battle.add_enemy(monsters.BasicMonster("chicken", 5, 8)) battle.add_enemy(monsters.Ant("ant", 1, 1)) battle.add_enemy(monsters.SuperAnt("super ant", 1, 1)) #create heroes battle.add_hero(heroes.Coward("super grover", 21, 28)) battle.add_hero(heroes.Healer("big bird", 35, 38)) #start battle while len(battle.heroes) > 0 and len(battle.enemies) > 0: battle.next_battle_round() print "\n===== THE BATTLE IS OVER ===="
class App: item_database = [] paused = False def __init__(self): pyxel.init(128, 128, caption="WHAT THE ACTUALLY F**K", fps=25) try: # load files in cx_freeze pyxel.load( os.path.join( os.path.dirname(__file__)[:-16], 'my_resource.pyxel')) file = open( os.path.join(os.path.dirname(__file__)[:-16], 'items.txt')) for line in file: exec(f'self.item_database.append({line})') file.close() except FileNotFoundError: # load files in python pyxel.load( os.path.join(os.path.dirname(__file__), 'my_resource.pyxel')) file = open(os.path.join(os.path.dirname(__file__), 'items.txt')) for line in file: exec(f'self.item_database.append({line})') file.close() self.player_damage = 4 self.player_hp = 10 pyxel.mouse(visible=True) self.battle = Battle() self.menu_opened = False self.player_direction = 0 self.player_animation_frame = 1 self.player_animation_frame_counter = 0 self.x = 0 self.y = 0 self.sx = 56 self.sy = 48 self.level = Level1() self.battle_init = False # init inventory self.inventory = [] # init game app pyxel.run(self.update, self.draw) def update(self): pyxel.mouse(True) Monster.paused = App.paused # sending vars to "monster.py" Monster.player_x = self.sx Monster.player_y = self.sy if Monster.battle: if not self.battle_init: self.battle.monster_id = Monster.monster_id self.battle.player_hp = self.player_hp self.battle.player_dmg = self.player_damage self.battle.monster_hp = Monster.monster_database[ self.battle.monster_id][7] self.battle.monster_dmg = Monster.monster_database[ self.battle.monster_id][7] self.battle_init = True print('init') App.paused = True elif not Monster.battle and not self.menu_opened: if self.battle_init: self.player_hp = self.battle.player_hp App.paused = False self.battle_init = False # CONTROLS # if pyxel.btnp(pyxel.KEY_Q): pyxel.quit() if not App.paused: if pyxel.btn(pyxel.KEY_LEFT): self.player_direction = 1 if self.is_empty(self.sx, self.sy + 1) and self.is_empty( self.sx, self.sy + 6): self.sx = self.sx - 1 if pyxel.btn(pyxel.KEY_RIGHT): self.player_direction = 0 if self.is_empty(self.sx + 7, self.sy + 1) and self.is_empty( self.sx + 7, self.sy + 6): self.sx = self.sx + 1 if pyxel.btn(pyxel.KEY_UP): self.player_direction = 2 if self.is_empty(self.sx + 1, self.sy) and self.is_empty( self.sx + 6, self.sy): self.sy = self.sy - 1 if pyxel.btn(pyxel.KEY_DOWN): self.player_direction = 3 if self.is_empty(self.sx + 1, self.sy + 8) and self.is_empty( self.sx + 6, self.sy + 8): self.sy = self.sy + 1 if pyxel.btnp(pyxel.KEY_E): if App.paused and not self.menu_opened: pass else: if not self.menu_opened: App.paused = True self.menu_opened = True else: App.paused = False self.menu_opened = False elif pyxel.btnp(pyxel.KEY_F): for item in self.item_database: if self.get_tile() == item[1]: pyxel.tilemap(0).set((self.sx + 4) // 8, (self.sy + 4) // 8, 0) # clear that tile self.inventory.append(self.item_database.index(item)) def draw(self): pyxel.cls(0) print(self.player_hp) self.level.draw_level() self.mouse_button() if Monster.battle: self.battle.draw() if not App.paused: self.draw_player() elif self.menu_opened: self.draw_menu() def draw_menu(self): pyxel.bltm(0, 0, 0, 0, 16, 16, 16, 0) pyxel.text(14, 16, 'INVENTORY:', 9) # text for i in range(9): try: pyxel.text(14, (i * 10) + 26, self.item_database[self.inventory[i]][0], 15) except IndexError: break def mouse_button(self): if pyxel.btn(pyxel.MOUSE_LEFT_BUTTON): self.sx = pyxel.mouse_x self.sy = pyxel.mouse_y tx = pyxel.mouse_x // 8 ty = pyxel.mouse_y // 8 self.x = tx self.y = ty print(tx * 8, ty * 8, pyxel.tilemap(0).get(tx, ty)) def draw_player(self): going = [ pyxel.btn(pyxel.KEY_LEFT), pyxel.btn(pyxel.KEY_RIGHT), pyxel.btn(pyxel.KEY_UP), pyxel.btn(pyxel.KEY_DOWN) ] if any(going): self.player_cycle_animation() pyxel.blt(self.sx, self.sy, 0, self.player_direction * 8, self.player_animation_frame * 8, 8, 8, 0) def is_empty(self, x, y): if pyxel.tilemap(0).get( x // 8, y // 8) == 0 or pyxel.tilemap(0).get(x // 8, y // 8) >= 32: return True else: return False def get_tile(self): return pyxel.tilemap(0).get((self.sx + 4) // 8, (self.sy + 4) // 8) def player_cycle_animation(self): if self.player_animation_frame_counter < 4: self.player_animation_frame_counter += 1 else: if self.player_animation_frame == 1: self.player_animation_frame = 2 self.player_animation_frame_counter = 0 else: self.player_animation_frame = 1 self.player_animation_frame_counter = 0
def play(self): battle = Battle(self.units) battle.start()
def main(): A = Battle() A.battle()
from classes import Prints, Human from battle import Battle, IQcheck, STRcheck, CHAcheck import random # initializing variables p1damage = 0 p2damage = 0 ross = Human("Ross", 100,1,100,50,50) carlos = Human("Carlos", 100,1,75,50,75) out = Prints(False) out.line = carlos.description() out.delay_print() out.line = ross.description() out.delay_print() Battle(ross,carlos) out.line = carlos.description() out.delay_print() out.line = ross.description() out.delay_print()
def startBattle(self): self.battle_num += 1 self.current_battle = Battle(self.battle_num, self.max_battles) return self.current_battle
def performAttackOnUnit(battle, target_unit): # perform an attack on the given target BattleUnit turn_unit = battle.getTurnUnit() if turn_unit is None or target_unit is None\ or turn_unit.isDestroyed() or target_unit.isDestroyed(): # TODO: make sure it is a player unit's turn return 0 src_cell = turn_unit.col, turn_unit.row dest_cell = target_unit.col, target_unit.row # minimum travel time to target used to determine when to show the damage floater min_travel_time = 0 # maximum travel time to target used to determine when all animations are finished max_travel_time = 0 # cell distance used to determine which range of weapons will fire cell_distance = Battle.getCellDistance(src_cell, dest_cell) target_range = Battle.getDistanceRange(cell_distance) print(target_range + ": " + str(src_cell) + " -> " + str(dest_cell) + " = " + str(cell_distance)) # TODO: introduce dynamic damage (optional?) attack_damage = int(getattr(turn_unit, target_range)) # apply damage to model before animating attack_remainder = target_unit.applyDamage(attack_damage) # determine actual target point based on the target unit sprite size target_sprite = target_unit.getSprite() real_x = (dest_cell[0] * Board.TILE_SIZE) + Board.TILE_SIZE // 2 real_y = (dest_cell[1] * Board.TILE_SIZE) + (2 * target_sprite.get_height() // 3) for weaponMap in turn_unit.mech.weapons: for weapon in weaponMap.iterkeys(): if not weapon.inRange(cell_distance): continue weapon_data = weaponMap[weapon] # get sound channel to use just for this weapon weapon_channel = pygame.mixer.find_channel() if weapon_channel is None: weapon_channel = pygame.mixer.Channel(0) weapon_offset = weapon_data.get('offset', [0, 0]) weapon_x = turn_unit.sprite.position[0] + weapon_offset[0] weapon_y = turn_unit.sprite.position[1] + weapon_offset[1] weapon_color = weapon.get_color() if weapon.isPPC(): # fire test ppcs ppc = Meteor() ppc.size = 10 ppc.speed = 20 ppc.gravity = Point2(0, 0) # TODO: offer decreased particle emission rate to improve performance ppc.emission_rate = 100 ppc.life = 0.5 ppc.life_var = 0.1 ppc.position = weapon_x, weapon_y battle.board.add(ppc, z=1000) target_x = real_x + random_offset() target_y = real_y + random_offset() target_pos = target_x, target_y # figure out the duration based on speed and distance ppc_speed = weapon.get_speed() # pixels per second distance = Point2(ppc.x, ppc.y).distance(Point2(target_x, target_y)) ppc_t = distance / ppc_speed ppc_sound = Resources.ppc_sound weapon_channel.play(ppc_sound) action = Delay(0.5) + MoveTo((target_x, target_y), duration=ppc_t) \ + CallFunc(impact_ppc, ppc) \ + Delay(0.5) + CallFunc(ppc.kill) \ + Delay(ppc_sound.get_length()) \ + CallFunc(weapon_channel.stop) ppc.do(action) travel_time = 0.5 + ppc_t if min_travel_time == 0 or min_travel_time > travel_time: min_travel_time = travel_time if travel_time > max_travel_time: max_travel_time = travel_time elif weapon.isFlamer(): # fire test flamer flamer = Fire() flamer.size = 25 flamer.speed = 300 flamer.gravity = Point2(0, 0) # TODO: offer decreased particle emission rate to improve performance flamer.emission_rate = 100 dx = real_x - weapon_x dy = real_y - weapon_y rads = atan2(-dy, dx) rads %= 2 * pi angle = degrees(rads) + 90 flamer.rotation = angle flamer.angle_var = 5 flamer.pos_var = Point2(5, 5) flamer.position = weapon_x, weapon_y battle.board.add(flamer, z=1000) target_x = real_x + random_offset() target_y = real_y + random_offset() target_pos = target_x, target_y # figure out the duration based on speed and distance flamer_speed = weapon.get_speed() # pixels per second distance = Point2(flamer.x, flamer.y).distance( Point2(target_x, target_y)) flamer_t = 1 flamer.life = distance / flamer_speed flamer.life_var = 0 flamer_sound = Resources.flamer_sound weapon_channel.play(flamer_sound) action = Delay(flamer_t) \ + CallFunc(impact_flamer, flamer) \ + CallFunc(weapon_channel.fadeout, 750) \ + Delay(flamer_t) + CallFunc(flamer.kill) \ + CallFunc(weapon_channel.stop) flamer.do(action) travel_time = flamer_t if min_travel_time == 0 or min_travel_time > travel_time: min_travel_time = travel_time if travel_time > max_travel_time: max_travel_time = travel_time elif weapon.isLaser(): # fire test laser las_life = 1.0 las_size = (1, 1, 1) if weapon.isShort(): las_size = (2, 1, 0.5) las_life = 0.5 elif weapon.isMedium(): las_size = (3, 2, 1) las_life = 0.75 elif weapon.isLong(): las_size = (6, 4, 2) las_life = 1.0 target_x = real_x + random_offset() target_y = real_y + random_offset() target_pos = target_x, target_y las_outer = gl.SingleLine( (weapon_x, weapon_y), (target_x, target_y), width=las_size[0], color=(weapon_color[0], weapon_color[1], weapon_color[2], 50)) las_middle = gl.SingleLine( (weapon_x, weapon_y), (target_x, target_y), width=las_size[1], color=(weapon_color[0], weapon_color[1], weapon_color[2], 125)) las_inner = gl.SingleLine( (weapon_x, weapon_y), (target_x, target_y), width=las_size[2], color=(weapon_color[0], weapon_color[1], weapon_color[2], 200)) las_outer.visible = False las_middle.visible = False las_inner.visible = False node = cocos.layer.Layer() node.add(las_outer, z=1) node.add(las_middle, z=2) node.add(las_inner, z=3) battle.board.add(node, z=1000) # give lasers a small particle pre-fire effect laser_charge = Galaxy() laser_charge.angle = 270 laser_charge.angle_var = 180 laser_charge.position = weapon_x, weapon_y laser_charge.size = 10 laser_charge.size_var = 5 laser_charge.emission_rate = 15 laser_charge.life = 0.5 laser_charge.speed = 0 laser_charge.speed_var = 0 laser_charge.start_color = Color(weapon_color[0] / 255, weapon_color[1] / 255, weapon_color[2] / 255, 1.0) laser_charge.end_color = Color(weapon_color[0] / 255, weapon_color[1] / 255, weapon_color[2] / 255, 1.0) node.add(laser_charge, z=0) laser_drift = random.uniform(-15.0, 15.0), random.uniform( -15.0, 15.0) las_action = Delay(0.5) + ToggleVisibility() \ + CallFunc(create_laser_impact, battle.board, target_pos, laser_drift, las_life) \ + gl.LineDriftBy(laser_drift, las_life) \ + CallFunc(laser_charge.stop_system) + CallFunc(node.kill) las_outer.do(las_action) las_middle.do(las_action) las_inner.do(las_action) las_sound = Resources.las_sound weapon_channel.play(las_sound) las_duration_ms = int(las_action.duration * 1000) weapon_channel.fadeout(las_duration_ms) travel_time = 0.5 if min_travel_time == 0 or min_travel_time > travel_time: min_travel_time = travel_time if travel_time > max_travel_time: max_travel_time = travel_time elif weapon.isBallistic(): # fire test ballistic projectile num_ballistic = weapon.get_projectiles() if weapon.isGauss(): ballistic_img = Resources.gauss_img elif weapon.isLBX(): # LBX fires only one projectile, but will appear to have multiple random impacts num_ballistic = 1 ballistic_img = Resources.buckshot_img else: ballistic_img = Resources.ballistic_img # machine gun sound only plays once instead of per projectile cannon_sound = None if weapon.isMG(): cannon_sound = Resources.machinegun_sound elif weapon.isGauss(): cannon_sound = Resources.gauss_sound for i in range(num_ballistic): ballistic = Sprite(ballistic_img) ballistic.visible = False ballistic.position = weapon_x, weapon_y ballistic.scale = weapon.get_scale() ballistic.anchor = 0, 0 dx = real_x - weapon_x dy = real_y - weapon_y rads = atan2(-dy, dx) rads %= 2 * pi angle = degrees(rads) ballistic.rotation = angle target_x = real_x + random_offset() target_y = real_y + random_offset() target_pos = target_x, target_y # figure out the duration based on speed and distance ballistic_speed = weapon.get_speed() # pixels per second distance = Point2(weapon_x, weapon_y).distance( Point2(target_x, target_y)) ballistic_t = distance / ballistic_speed # setup the firing sound if cannon_sound is None: cannon_sound = Resources.cannon_sound impact_func = create_ballistic_impact if weapon.isLBX(): impact_func = create_lbx_impact action = Delay(i * 0.1) + ToggleVisibility() \ + CallFunc(weapon_channel.play, cannon_sound) \ + MoveTo((target_x, target_y), ballistic_t) \ + CallFunc(impact_func, weapon, battle.board, target_pos) \ + CallFunc(ballistic.kill) if weapon.isGauss(): # give gauss sound a bit more time to stop action += Delay(cannon_sound.get_length()) if i == num_ballistic - 1: # stop the sound channel after the last projectile only action += CallFunc(weapon_channel.stop) ballistic.do(action) battle.board.add(ballistic, z=1000 + i) travel_time = (i * 0.1) + ballistic_t if min_travel_time == 0 or min_travel_time > travel_time: min_travel_time = travel_time if travel_time > max_travel_time: max_travel_time = travel_time elif weapon.isMissile(): # get another sound channel to use just for the explosions explosion_channel = pygame.mixer.find_channel() if explosion_channel is None: explosion_channel = pygame.mixer.Channel(1) # fire test missile projectile missile_img = Resources.missile_img num_missile = weapon_data.get('count', 1) num_per_row = 1 if weapon.isLRM(): num_per_row = 5 elif weapon.isSRM(): num_per_row = 2 for i in range(num_missile): tube_x = i % num_per_row tube_y = i // num_per_row missile = Sprite(missile_img) missile.visible = False missile.position = weapon_x + tube_x, weapon_y + tube_y missile.scale = weapon.get_scale() missile.anchor = 0, 0 dx = real_x - weapon_x dy = real_y - weapon_y rads = atan2(-dy, dx) rads %= 2 * pi angle = degrees(rads) missile.rotation = angle target_x = real_x + random_offset() target_y = real_y + random_offset() target_pos = target_x, target_y # figure out the duration based on speed and distance missile_speed = weapon.get_speed() # pixels per second distance = Point2(weapon_x, weapon_y).distance( Point2(target_x, target_y)) missile_t = distance / missile_speed rand_missile_sound = random.randint(0, 7) missile_sound = Resources.missile_sounds[ rand_missile_sound] explosion_sound = Resources.explosion_sound action = Delay(i * 0.05) + ToggleVisibility() \ + CallFunc(weapon_channel.play, missile_sound) \ + MoveTo((target_x, target_y), missile_t) \ + CallFunc(create_missile_impact, battle.board, target_pos) \ + CallFunc(missile.kill) \ + CallFunc(explosion_channel.play, explosion_sound) \ + Delay(0.5) if i == num_missile - 1: # stop the sound channels after the last missile only action += CallFunc(weapon_channel.stop) + CallFunc( explosion_channel.stop) missile.do(action) battle.board.add(missile, z=1000 + i) travel_time = (i * 0.05) + missile_t if min_travel_time == 0 or min_travel_time > travel_time: min_travel_time = travel_time if travel_time > max_travel_time: max_travel_time = travel_time # scroll focus over to the target area halfway through the travel time target_area = Board.board_to_layer(target_unit.col, target_unit.row) # show damage floater after the travel time of the first projectile to hit floater = floaters.TextFloater("%i" % attack_damage) floater.visible = False floater.position = real_x, real_y + target_sprite.get_height() // 3 battle.board.add(floater, z=2000) action = Delay(min_travel_time / 2) + CallFunc(battle.scroller.set_focus, *target_area) \ + Delay(min_travel_time / 2) + ToggleVisibility() \ + Delay(0.25) + MoveBy((0, Board.TILE_SIZE), 1.0) \ + FadeOut(1.0) + CallFunc(floater.kill) floater.do(action) if action.duration > max_travel_time: max_travel_time = action.duration stats_action = Delay(min_travel_time) + CallFunc(target_sprite.updateStatsIndicators) \ + CallFunc(Interface.UI.updateTargetUnitStats, target_unit) target_sprite.do(stats_action) if attack_remainder > 0: print("Overkill by %i!" % attack_remainder) if target_unit.structure > 0: print("Remaining %i/%i" % (target_unit.armor, target_unit.structure)) else: print("Target destroyed!") # show destroyed floater after the travel time of the first projectile to hit destroyed = floaters.TextFloater("DESTROYED") destroyed.visible = False destroyed.position = real_x, real_y + target_sprite.get_height() // 3 battle.board.add(destroyed, z=5000) # get another sound channel to use just for the explosions explosion_channel = pygame.mixer.find_channel() if explosion_channel is None: explosion_channel = pygame.mixer.Channel(1) explosion_sound = Resources.explosion_multiple_sound action = Delay(max_travel_time) + ToggleVisibility() \ + CallFunc(explosion_channel.play, explosion_sound) \ + (MoveBy((0, Board.TILE_SIZE), 1.0) | CallFunc(create_destruction_explosions, battle.board, target_unit)) \ + Delay(0.5) + CallFunc(target_sprite.destroy) + FadeOut(2.0) + CallFunc(destroyed.kill) destroyed.do(action) # give a bit of extra time to explode max_travel_time = action.duration return max_travel_time
elif len(sys.argv) == 2: poke = Pokemon(sys.stdin) # começa a bataha r = requests.post('http://localhost:5000/battle/', data=poke.to_XML('<battle_state></battle_state>')) while r.status_code != 200: print('status code: ', r.status_code) arq = input('Digite um nome de arquivo valido: ') poke = Pokemon(arq) r = requests.post('http://localhost:5000/battle/', data=poke.to_XML('<battle_state></battle_state>')) battle = Battle() poke = Pokemon(r.text, xml=True) battle_state = etree.fromstring(r.text) poke1 = battle_state[0] battle_state.remove(poke1) pkmn = etree.tostring(battle_state, encoding='unicode') poke2 = Pokemon(pkmn, xml=True) while battle.all_alive(poke, poke2): atk_id = battle.make_choice(poke, poke2, ai) + 1 r = requests.post('http://localhost:5000/battle/attack/' + str(atk_id))
def __init__(self): self.screen = pygame.display.set_mode(screen_size) self.key_repeater = self.construct_key_repeater() self.battle = Battle()
def __init__(self, reset=False, preset=False): self.model = { 'army': Army, 'battle': Battle, 'culture': Culture, 'land': Land, 'person': Person, 'player': Player, 'province': Province, 'title': Title, 'war': War, } connect('histemul') self.orders = {} if reset: client = MongoClient() db = client.histemul Player.drop_collection() Person.drop_collection() Army.drop_collection() Battle.drop_collection() War.drop_collection() Province.drop_collection() #collection = db.province_vo db.command('aggregate', 'province_vo', pipeline=[{'$match':{}}, {'$out': "province"}], allowDiskUse=True, cursor={}) if preset: Matthieu = self.new_player('Matthieu', division='fess', tinctures=['green', 'orange']) Pierre = self.new_player('Pierre', division='pale', tinctures=['blue', 'red']) Robert = self.new_person('Robert', True, datetime.date(975, 1, 1), Matthieu, 1) Jean = self.new_person('Jean', True, datetime.date(981, 1, 1), Pierre, 14) Philippe = self.new_person('Philippe', True, datetime.date(965, 1, 1), Pierre, 39) Matthieu.leader = Robert Matthieu.save() Pierre.leader = Jean Pierre.save() Berquinais = Title.objects.get(pk='Berquinais') Berquinais.holder = Robert Berquinais.name_number = {'Robert': 1} Berquinais.save() Orvence = Title.objects.get(pk='Orvence') Orvence.holder = Jean Orvence.name_number = {'Jean': 1} Orvence.save() Bourquige = Title.objects.get(pk='Bourquige') Bourquige.holder = Philippe Bourquige.name_number = {'Philippe': 1} Bourquige.save() Berquinais_province = Province.objects.get(name='Berquinais') Berquinais_province.controller = Robert Berquinais_province.save() Orvence_province = Province.objects.get(name='Orvence') Orvence_province.controller = Jean Orvence_province.save() Bourquige_province = Province.objects.get(name='Bourquige') Bourquige_province.controller = Philippe Bourquige_province.save() Army_Orvence = self.rally_troops(Pierre, Orvence_province, 'execute')
def test__conduct_combat(self): t1 = Army() t2 = Army() t3 = Army() t4 = Army() battle = Battle() formation = 1 # Test if combat is conducted correctly and if it returns # appropriate result for all Archer p1 army and empty p2 army # Assumes __assign_army is working correctly t1._Army__assign_army("", 0, 10, 0, formation) t2._Army__assign_army("", 0, 0, 0, formation) t3._Army__assign_army("", 0, 4, 0, formation) t4._Army__assign_army("", 0, 0, 0, formation) try: self.assertTrue( battle._Battle__conduct_combat(t1, t2, formation) == 1, "Fairer 0,10,0 0,0,0 failed") except AssertionError as e: self.verificationErrors.append(str(e)) # Tests combat is conducted correctly and if it # returns appropriate result for 1 Soldier p1 army and 1 Archer p2 army # Assumes __assign_army is working correctly t1._Army__assign_army("", 1, 0, 0, formation) t2._Army__assign_army("", 0, 1, 0, formation) try: self.assertTrue( battle._Battle__conduct_combat(t1, t2, formation) == 0, "Fairer 1,0,0 0,1,0 failed") except AssertionError as e: self.verificationErrors.append(str(e)) try: self.assertEqual(str(t1.force), "", msg="Army 1 wrong for Fairer 1,0,0 0,1,0") except AssertionError as e: self.verificationErrors.append(str(e)) try: self.assertEqual(str(t2.force), "", msg="Army 2 wrong for Fairer 1,0,0 0") except AssertionError as e: self.verificationErrors.append(str(e)) # Checking if t1 is an instance of Army try: self.assertEqual(isinstance(t3, Army), True, msg="Object is not an instance of Army") except AssertionError as e: self.verificationErrors.append(str(e)) # Testing __conduct_combat method try: self.assertTrue( battle._Battle__conduct_combat(t3, t4, formation) == 1, "Fairer 0,4,0 0,0,0 failed") except AssertionError as e: self.verificationErrors.append(str(e))
artigo = ['uma', 'sua'] helpers.separador() print( f'''Durante uma tempestade de gafanhotos, {j1.name} procurava um lugar para se abrigar, ouviu um chamado abaixo de uma ponte que cruzava um córrego um velho homem fedorento que tinha com ele algumas trouxas, umas de roupas e outras de sabe-se Odin lá o que. Após um diálogo breve, o mendigo, ausente de suas faculdades mentais, te entrega {artigo[0]} {arma}, você segue seu caminho após a tempestade de gafanhotos e, ao final da ponte, você encontra um Goblin sedento por sangue. Prepare-se para usar {artigo[1]} {arma}!''') helpers.separador10s() helpers.separador() while j1.alive: Battle(j1, mon) if (j1.alive): monkilled += 1 goblinhp += 10 mon.hp = goblinhp baseAtk += 5 maxAtk += 5 mon.atk = randint(baseAtk, maxAtk) baseArm += 5 maxArm += 5 mon.arm = randint(baseArm, maxArm) mon.alive = goblinarm mon.alive = True
if event.key == pygame.K_a: movement = (-1, 0) elif event.key == pygame.K_d: movement = (1, 0) elif event.key == pygame.K_w: movement = (0, -1) elif event.key == pygame.K_s: movement = (0, 1) else: movement = (0, 0) if (boss.check_movement(movement, player.position)): if (map.check_movement(movement, player.position)): player.move_player(movement) else: battle = Battle(niespanier, paichu) gameState.changeMode() gui.proceed_input(event) else: screen.fill((0, 255, 0)) if gameState.battleType == 'boss': gui.draw_gui_battle(battle) if boss.speak(screen, gui): battle.drawBattle(screen) if battle.checkBattleState() == 'victory': gameState.changeMode() for event in pygame.event.get():
def setUp(self) -> None: self.first_army = Army(Side.Monsters) self.first_army.add(DragonSquad(self.first_army.side, 4)) self.battle = Battle(self.first_army)
poke = Pokemon(sys.stdin) # começa a bataha r = requests.post('http://localhost:5000/battle/', data = poke.to_XML( '<battle_state></battle_state>')) while r.status_code != 200: print('status code: ', r.status_code) arq = input('Digite um nome de arquivo valido: ') poke = Pokemon(arq) r = requests.post('http://localhost:5000/battle/', data = poke.to_XML( '<battle_state></battle_state>')) battle = Battle() poke = Pokemon(r.text, xml = True) battle_state = etree.fromstring(r.text) poke1 = battle_state[0] battle_state.remove(poke1) pkmn = etree.tostring(battle_state, encoding = 'unicode') poke2 = Pokemon(pkmn, xml = True) while battle.all_alive(poke, poke2): atk_id = battle.make_choice(poke, poke2, ai) + 1 r = requests.post('http://localhost:5000/battle/attack/' + str(atk_id))
if t == '1': mon = get_monster() # print(mon) print('当前有如下武将:', end='') for key in g_userdata['hero'].keys(): print(key) a = input('请输入您想要派出的武将,1.云天河') if a != '1': continue else: a = '云天河' # print(g_userdata['hero'][a]) fighter = Fighter(**g_userdata['hero'][a]) # 传入字典 # print(mon[1]) monster = Monster(**mon[1]) battle = Battle(monster, fighter) # 创建战斗对象 print( f'战斗开始,{a}({g_userdata["hero"][a]["level"]}级)对阵{mon[0]}({mon[1]["level"]}级)!' f'{a}剩余{battle.fighter.hp}精,剩余{battle.fighter.qi}气,' f'{mon[0]}剩余{battle.monster.hp}精,剩余{battle.monster.qi}气') # while not battle.done(): # battle.move() while battle.move(): # 如果返回False表明战斗结束 time.sleep(1) print( f'\t战斗进行中,{a}剩余{battle.fighter.hp if battle.fighter.hp > 0 else 0}精,剩余{battle.fighter.qi}气,' f'{mon[0]}剩余{battle.monster.hp if battle.monster.hp > 0 else 0}精,剩余{battle.monster.qi}气' ) # 战斗结束后获取战斗结果,进行加气、判断升级等操作 res = battle.res()
def __init__(self): self.core = Core() self.graphical_logic = Graphical_logic() self.battle = Battle('1')
class AutoE4: OK = 0 Pit = -1 Broke = -2 Error = -3 def __init__(self, game, shipNames, dismantleList = [ ]): self.game = game self.ships = [ game.findShip(name) for name in shipNames ] self.dismantleList = dismantleList self.fleet = None self.formerShips = None def isReady(self): return (self.fleet is not None) and (self.fleet.isReady()) def getReady(self, fleet): if self.fleet is not None and self.fleet != fleet: Log.i('Already has fleet') return False for i in range(len(self.ships)): if not self.ships[i].isIdle(): Log.i('%s is not idle' % self.ships[i].getName()) return False if self.ships[i].isBroken(): Log.i('%s is broken' % self.ships[i].getName()) return False self.fleet = fleet self.formerShips = fleet.ships.copy() for i in range(6): if self.ships[i] != self.fleet.ships[i]: fleet.changeShips(self.ships) fleet.fill() return True fleet.fill() return True def end(self): ret = self.fleet self.fleet.changeShips(self.formerShips) self.fleet = None self.formerShips = None return ret def run(self): if not self.fleet.isReady(): return AutoE4.Error self.battle = Battle(self.game, 9916, self.fleet) spot, enemy = self.battle.go() Log.i('Spot: ' + str(spot)) Log.i('Enemy fleet: ' + str(enemy)) if spot != 991602: return AutoE4.Pit self.newShips = [ None, None, None ] for i in range(3): if i != 0: self.battle.go() self.battle.engage(2) self.newShips[i], hp = self.battle.giveUp() Log.i('Got %s at spot %d' % (self.newShips[i].getName() if self.newShips[i] is not None else 'nothing', i)) Log.i(self.fleet.printHp()) for ship in self.fleet.ships: if ship.isBroken(): self.end() return AutoE4.Broke self.end() return AutoE4.OK def end(self): self.battle.quit() self.fleet.fill() for ship in self.newShips: if ship is not None: if ship.getName() in self.dismantleList: Log.i('Dismantle ' + ship.getName()) keepEquipt = (ship.getName() in [ '翡翠', '列克星敦' ]) ship.dismantle(keepEquipt) else: Log.i('Keep ship ' + ship.getName()) if '威廉' in ship.getName(): Log.e('Done')
def actOnCell(battle, col, row): if not isActionReady(): return # perform an action based on the given cell and/or its occupants turn_unit = battle.getTurnUnit() turn_player = turn_unit.getPlayer() if turn_unit is None: # TODO: make sure it is a player unit's turn or do something else return cell = battle.getCellAt(col, row) if cell is None: return # if the cell is not already selected, select it instead sel_pos = battle.getSelectedCellPosition() if sel_pos is None or col != sel_pos[0] or row != sel_pos[1]: moveSelectionTo(battle, col, row) return cell_unit = battle.getUnitAtCell(col, row) if col == turn_unit.col and row == turn_unit.row: setActionReady(False) # TODO: ask confirmation to end the turn without firing print("Skipping remainder of the turn!") battle.nextTurn() setActionReady(True) elif battle.isCellAvailable(col, row) and cell.range_to_display > 0: setActionReady(False) turn_unit.move -= cell.range_to_display for cell in battle.board.cellMap.itervalues(): cell.remove_indicators() animate_reverse = (turn_unit.col - col > 0) or (turn_unit.row - row > 0) def _ready_next_move(): turn_unit.sprite.sulk() for chk_cell in battle.board.cellMap.itervalues(): chk_cell.remove_indicators() battle.showRangeIndicators() battle.showUnitIndicators() battle.setSelectedCellPosition(turn_unit.col, turn_unit.row) turn_cell_pos = Board.board_to_layer(turn_unit.col, turn_unit.row) if turn_cell_pos is not None: turn_cell_pos = turn_cell_pos[ 0] + Board.TILE_SIZE // 2, turn_cell_pos[ 1] + Board.TILE_SIZE // 2 battle.scroller.set_focus(*turn_cell_pos) setActionReady(True) turn_unit.sprite.strut(reverse=animate_reverse) turn_unit.sprite.moveToCell(col, row, animate_reverse, _ready_next_move) elif Battle.isFriendlyUnit(turn_player, cell_unit): # TODO: interact with friendly unit somehow, like swap cells with it if it has move remaining? print("Friendly: " + str(cell_unit)) elif cell_unit is not None \ and not cell_unit.isDestroyed() \ and cell_unit is not turn_unit: setActionReady(False) print("Enemy: " + str(cell_unit)) battle.showUnitIndicators(visible=False) for chk_cell in battle.board.cellMap.itervalues(): chk_cell.remove_indicators() attack_time = performAttackOnUnit(battle, cell_unit) def _ready_next_turn(): setActionReady(False) battle.nextTurn() setActionReady(True) # start the next turn when the attack is completed battle.board.do(Delay(attack_time) + CallFunc(_ready_next_turn))
def characters_select(self): """ Displays the screen in which character select happens. """ errors = False error = None while True: for event in pygame.event.get(): if event.type == pygame.QUIT: self.game.quit_game() if event.type == pygame.KEYDOWN: if event.key == pygame.K_l: self.game.show_skills() if event.key == pygame.K_ESCAPE: self.game.player.skills = dict( self.original_player_skills) return True if event.key == pygame.K_RETURN: if len(self.warriors) == 0: errors = True error = self.no_chosed_warriors elif len(self.enemies) == 0: errors = True error = self.no_chosed_enemies else: # Flip warrir images self.change_image_direction() # Start battle battle = Battle(self.game, self.warriors, self.enemies) battle.start_battle() # Clear warriors and enemies self.clear() # Get character image and rects self.character_images, self.character_rects = self.get_rects_and_images( ) # Display bg and title self.window.blit(self.battle_bg, [0, 0]) self.window.blit(self.title, [self.game.center_text_x(self.title), 50]) # Draw unlocked characters for char, charimg, imgrect in zip(self.characters, self.character_images, self.character_rects): self.window.blit(charimg, [imgrect.x, imgrect.y]) # Check if clicked character try: clicked_char, pressed_btn = self.game.clicked_surface_rect( imgrect, True, True) print pressed_btn except TypeError: clicked_char = False # Add clicked to warriors or to enemies group if clicked_char and pressed_btn[0] and len(self.warriors) < 3: self.characters.remove(char) self.warriors.append(char) self.warrior_images.append(charimg) elif clicked_char and pressed_btn[2] and len(self.enemies) < 3: self.characters.remove(char) self.enemies.append(char) self.enemy_images.append(charimg) # Draw enemies self.window.blit( self.enemies_text, [self.game.WINDOW_WIDTH / 1.3, self.game.WINDOW_HEIGHT / 5]) enemy_rects = self.set_chosed_chars_rects( len(self.enemies), self.game.WINDOW_WIDTH / 1.7, self.game.WINDOW_HEIGHT / 4, 100) for enemy, enemyimg, enemyrect in zip(self.enemies, self.enemy_images, enemy_rects): self.window.blit(enemyimg, [enemyrect.x, enemyrect.y]) clicked_enemy = self.game.clicked_surface_rect(enemyrect) if clicked_enemy: # Remove from enemies and add to all characters self.enemies.remove(enemy) self.enemy_images.remove(enemyimg) self.characters.append(enemy) # Draw warriors self.window.blit( self.warriors_text, [self.game.WINDOW_WIDTH / 6, self.game.WINDOW_HEIGHT / 5]) warrior_rects = self.set_chosed_chars_rects( len(self.warriors), 20, self.game.WINDOW_HEIGHT / 4, 100) for warrior, warriorimg, warriorect in zip(self.warriors, self.warrior_images, warrior_rects): self.window.blit(warriorimg, [warriorect.x, warriorect.y]) clicked_warrior = self.game.clicked_surface_rect(warriorect) if clicked_warrior: # Remove from warriors and add to all characters self.warriors.remove(warrior) self.warrior_images.remove(warriorimg) self.characters.append(warrior) # Draw errors if any if errors: self.window.blit(error, [20, self.game.WINDOW_HEIGHT / 1.1]) # Update everything and set clock pygame.display.update() self.game.clock.tick(self.game.FPS)
if mode == 'n': choice = cf.choose_input( "Who do you want to stand for?", ["t", "s"], "(T: Tony Starks / S: Steven Rogers)") # 若手动操作,询问操作哪一方 if choice == 't': tony_mode = 'user' else: steven_mode = 'user' # 初始化 settings = Settings() win = [0, 0, 0] for i in range(100): tony = Fighter("Tony Stark", settings) steven = Fighter("Steven Rogers", settings) battle = Battle(tony, steven, settings) while battle.round: # 获取战斗策略 tony_act = tony.fight_strategy(steven, tony_mode) steven_act = steven.fight_strategy(tony, steven_mode) # 进行战斗 fn.fight_function[tony_act](tony, steven, steven_act) fn.fight_function[steven_act](steven, tony, tony_act) # 键盘输出 cf.keyboard_output(settings, tony, steven, tony_act, steven_act) # 判断胜负 battle.round -= 1
def battleTest(self): battle = Battle(self.ph, self.eh) battle.battleLoop()
def _battle(self, battle): print('========== Found a battle: <', battle['user0'].encode('utf-8'), ',', battle['idOfUser0'], '> vs <', battle['user1'].encode('utf-8'), ', ', battle['idOfUser1'], '>') # Mark Running doc_rec = {'$set': {'status': 'Running', 'judger': const.SERVER_NAME}} self._updateDB('records', {'_id': battle['_id']}, doc_rec) # Run battle server = const.AI_SERVER_DIRECTORY ai0 = self._findOne('ais', { 'user': battle['user0'], 'idOfUser': battle['idOfUser0'] }) ai1 = self._findOne('ais', { 'user': battle['user1'], 'idOfUser': battle['idOfUser1'] }) updater = lambda step: self._updateDB( 'records', {'_id': battle['_id']}, {'$set': { 'step': step }}) text_uploader = lambda path: self._uploadText(path) # Ensure executable file self._ensureFile(str(ai0['_id']), 'ai', ai0['absPath']) self._ensureFile(str(ai1['_id']), 'ai', ai1['absPath']) # Run battle result = Battle(server, ai0, ai1, updater, text_uploader).Run() # Prepare documents doc_ai0 = {'$set': {'name': result['user'][0]}} doc_ai1 = {'$set': {'name': result['user'][1]}} doc_rec = { '$set': { 'name0': result['user'][0], 'name1': result['user'][1], 'step': result['total'], 'status': 'Finished', 'result': result['result'], 'log': result['json'], 'runDate': datetime.utcnow(), 'stdin0': result['stdin0'], 'stdout0': result['stdout0'], 'stderr0': result['stderr0'], 'stdin1': result['stdin1'], 'stdout1': result['stdout1'], 'stderr1': result['stderr1'], } } doc_user0 = {'$inc': dict()} doc_user1 = {'$inc': dict()} doc_contest_ai0 = {'$inc': dict()} doc_contest_ai1 = {'$inc': dict()} if result['result'] == 2: # if draw doc_ai0['$inc'] = {'draw': 1} doc_ai0['$set']['ratio'] = ( ai0['win']) / float(ai0['win'] + ai0['draw'] + ai0['lose'] + 1) doc_user0['$inc']['draw'] = 1 if ai0['user'] != ai1['user']: doc_user1['$inc']['draw'] = 1 doc_ai1['$set']['ratio'] = (ai1['win']) / float( ai1['win'] + ai1['draw'] + ai1['lose'] + 1) doc_ai1['$inc'] = {'draw': 1} else: doc_user1 = None doc_contest_ai0['$inc']['ais.$.draw'] = 1 doc_contest_ai1['$inc']['ais.$.draw'] = 1 elif result['result'] == 1: # if ai1 won: doc_ai0['$inc'] = {'lose': 1} doc_ai1['$inc'] = {'win': 1} if ai0['user'] != ai1['user']: cnt0 = float(ai0['win'] + ai0['draw'] + ai0['lose'] + 1) cnt1 = float(ai1['win'] + ai1['draw'] + ai1['lose'] + 1) else: cnt0 = float(ai0['win'] + ai0['draw'] + ai0['lose'] + 2) cnt1 = float(ai1['win'] + ai1['draw'] + ai1['lose'] + 2) doc_ai0['$set']['ratio'] = (ai0['win']) / cnt0 doc_ai1['$set']['ratio'] = (ai1['win'] + 1) / cnt1 doc_user0['$inc']['lose'] = 1 doc_user1['$inc']['win'] = 1 doc_rec['$set']['winnerId'] = ai1['_id'] doc_rec['$set']['loserId'] = ai0['_id'] doc_rec['$set']['winner'] = { 'name': result['user'][1], 'user': ai1['user'], 'idOfUser': ai1['idOfUser'] } doc_rec['$set']['loser'] = { 'name': result['user'][0], 'user': ai0['user'], 'idOfUser': ai0['idOfUser'] } doc_contest_ai0['$inc']['ais.$.lose'] = 1 doc_contest_ai1['$inc']['ais.$.win'] = 1 elif result['result'] == 0: # if ai0 won: doc_ai0['$inc'] = {'win': 1} doc_ai1['$inc'] = {'lose': 1} if ai0['user'] != ai1['user']: cnt0 = float(ai0['win'] + ai0['draw'] + ai0['lose'] + 1) cnt1 = float(ai1['win'] + ai1['draw'] + ai1['lose'] + 1) else: cnt0 = float(ai0['win'] + ai0['draw'] + ai0['lose'] + 2) cnt1 = float(ai1['win'] + ai1['draw'] + ai1['lose'] + 2) doc_ai0['$set']['ratio'] = (ai0['win'] + 1) / cnt0 doc_ai1['$set']['ratio'] = (ai1['win']) / cnt1 doc_user0['$inc']['win'] = 1 doc_user1['$inc']['lose'] = 1 doc_rec['$set']['winnerId'] = ai0['_id'] doc_rec['$set']['loserId'] = ai1['_id'] doc_rec['$set']['winner'] = { 'name': result['user'][0], 'user': ai0['user'], 'idOfUser': ai0['idOfUser'] } doc_rec['$set']['loser'] = { 'name': result['user'][1], 'user': ai1['user'], 'idOfUser': ai1['idOfUser'] } doc_contest_ai0['$inc']['ais.$.win'] = 1 doc_contest_ai1['$inc']['ais.$.lose'] = 1 else: print("!!!!!!!! UNKNOWN RESULT !!!!!!!!") # Update documents docs = {'ais': [], 'users': [], 'records': []} docs['ais'].append({'where': {'_id': ai0['_id']}, 'value': doc_ai0}) docs['ais'].append({'where': {'_id': ai1['_id']}, 'value': doc_ai1}) docs['users'].append({ 'where': { 'name': ai0['user'] }, 'value': doc_user0 }) if doc_user1: docs['users'].append({ 'where': { 'name': ai1['user'] }, 'value': doc_user1 }) docs['records'].append({ 'where': { '_id': battle['_id'] }, 'value': doc_rec }) if 'contestId' in battle and battle['contestId'] != ObjectId( '000000000000000000000000'): docs['contests'] = [] docs['contests'].append({ 'where': { '_id': battle['contestId'], "ais.ai_id": ai0['_id'] }, 'value': doc_contest_ai0 }) docs['contests'].append({ 'where': { '_id': battle['contestId'], "ais.ai_id": ai1['_id'] }, 'value': doc_contest_ai1 }) docs['contests'].append({ 'where': { '_id': battle['contestId'] }, 'value': { '$inc': { 'running': -1, 'finished': 1 } } }) self._updateDBs(docs) print(" Done!")
pokemon2.stats = { HP: 39, ATTACK: 52, DEFENSE: 43, SPATTACK: 80, SPDEFENSE: 65, SPEED: 65 } #Attacks pokemon1.attacks = [Attack("scratch", "normal", PHYSICAL, 10, 10, 100)] pokemon2.attacks = [Attack("scratch", "normal", PHYSICAL, 10, 10, 100)] #Start Battle! battle = Battle(pokemon1, pokemon2) def ask_command(pokemon): command = None while not command: # DO ATTACK -> attack 0 tmp_command = input("what should " + pokemon.name + " do?").split(" ") if len(tmp_command) == 2: try: if tmp_command[0] == DO_ATTACK and 0 <= int(tmp_command[1]): command = Command({DO_ATTACK: int(tmp_command[1])}) except Exception: pass return command
async def parse_response(ws, msg): msg_arr = msg.split('|') # ignore short messages if ( len(msg_arr) == 1 ): print("length 1 message: " + msg) # display error messages elif (msg_arr[1] == "error" or msg_arr[1] == "popup"): print(msg) # display PMs received, handle command messages from whitelisted users elif (msg_arr[1] == "pm"): print(msg) sender = msg_arr[2].strip().lower().replace(" ", "").replace("≧◡≦","") whitelist = [username.lower().strip() for username in bot_settings.bot_owners.split(",")] if (msg_arr[4][0] == "$" and sender in whitelist): await pm_commands.parse_command(ws, msg_arr[4], sender) # triggers when a battle ends, checks if bot won and sends appropriate message elif (msg_arr[0][0:7] == ">battle" and "win" in msg_arr): battletag = funcs.get_battletag(msg_arr) win_id = msg_arr.index("win") + 1 bot_won = (msg_arr[win_id].strip("\n").lower() == bot_settings.username.lower()) await funcs.on_battle_end(ws, battles, battletag, bot_won) # remove finished battle battle = funcs.get_battle(battles, battletag) battle.did_bot_win = bot_won #logging.record_battle(battle) remove_id = battles.index(battle) battles.pop(remove_id) # checks if challenges to be accepted elif (msg_arr[1] == "updatechallenges" and bot_settings.accept_challenges == True): #print(msg) await funcs.handle_challenges(ws, msg_arr) # triggers on any request message, adds team_data from it to battle elif (msg_arr[1] == "request"): battletag = funcs.get_battletag(msg_arr) battle = funcs.get_battle(battles, battletag) battle.next_team_data = msg_arr[2] # triggers when receive information about a battle elif (msg_arr[0][0:7] == ">battle" and msg_arr[1] == "\n"): battletag = funcs.get_battletag(msg_arr) battle = funcs.get_battle(battles, battletag) # read in information from message battlelog_parser.battlelog_parsing(battle, msg) # read data from previous request message, and prompt any needed switch/move await battle.load_team_data(ws) # login action elif (msg_arr[1] == "challstr"): await funcs.log_in(ws, msg_arr) # triggers when user first logs in elif (msg_arr[1] == 'updateuser' and msg_arr[2].lower().strip() == bot_settings.username.lower()): #print(msg) await funcs.startup_ops(ws, msg_arr) # triggers when battle initialises elif ('>battle' in msg_arr[0] and msg_arr[1] == 'init'): battletag = funcs.get_battletag(msg_arr) battles.append(Battle(battletag)) # instantiate battle object # triggers when get information at start of battle about either player elif ('>battle' in msg_arr[0] and msg_arr[1] == 'player'): battletag = funcs.get_battletag(msg_arr) battle = funcs.get_battle(battles, battletag) # note player's side if (msg_arr[3].lower() == bot_settings.username.lower()): battle.my_side = msg_arr[2] else: # note foe's name, side, and send greeting message battle.opponent_name = msg_arr[3] #battle.opponent_elo, battle.opponent_gxe = logging.get_rank(battle.opponent_name) #battle.my_elo, battle.my_gxe = logging.get_rank(bot_settings.username) battle.foe_side = msg_arr[2] await funcs.on_battle_start(ws, battles, battletag) # if message contains team preview, read in teams and prompt leads if ("teampreview\n" in msg_arr): battle.initialise_teams(msg_arr) await battle.load_team_data(ws)
class Event_Handler(): def __init__(self): self.core = Core() self.graphical_logic = Graphical_logic() self.battle = Battle('1') #Уровень шаманизма - 90! NE ПbTauTeCb ПОНЯТb БЕЗНОГNМ def stage_0(self,event,fraction,days,action_to_map_coords,action_to_minimap_coords,last_x,last_y,filename,x_start,y_start): if (event[0]=='map_coords'): try: x_start,y_start = action_to_minimap_coords(last_x,last_y)# ВОТ ТЫ ГДЕ, СЦУКА! except AttributeError: print 'lol' x_start,y_start = action_to_minimap_coords(event[2],event[3])# ВОТ ТЫ ГДЕ, СЦУКА! #print 'Coords = '+str(event[2])+' '+str(event[3]) stage, army_coords,id_army = action_to_map_coords(event[2],event[3],x_start,y_start) return stage,last_x,last_y,fraction,days, army_coords,id_army,x_start,y_start elif (event[0]=='minimap_coords'): x_start,y_start = action_to_minimap_coords(event[2],event[3])# ВОТ ТЫ ГДЕ, СЦУКА! stage = event[1] last_x = event[2] last_y = event[3] return stage,last_x,last_y,fraction,days, 0,0,x_start,y_start elif (event[0]=='save_mode'): stage = event[1] return stage,last_x,last_y,fraction,days, 0,0,x_start,y_start elif (event[0]=='load_mode'): stage = event[1] return stage,last_x,last_y,fraction,days, 0,0,x_start,y_start elif (event[0]=='end_of_army_steps'): print 'end_of_army_steps' return stage,last_x,last_y,fraction,days, 0,0,x_start,y_start elif (event[0]=='base_mode'): stage = event[1] return stage,last_x,last_y,fraction,days, 0,0,x_start,y_start elif (event[0]=='end_of_players_steps'): if fraction == 1: self.graphical_logic.add_resources_for_current_fraction(fraction, filename) self.graphical_logic.change_all_armies_steps_for_fraction(fraction, filename) if (days+2)%10 == 0: print ' pivo' self.graphical_logic.troops_generator(fraction, filename) fraction = 2 return 0,last_x,last_y,fraction,days, 0,0,x_start,y_start elif fraction == 2: self.graphical_logic.add_resources_for_current_fraction(fraction, filename) self.graphical_logic.change_all_armies_steps_for_fraction(fraction, filename) if (days+2)%10 == 0: print 'vodka' self.graphical_logic.troops_generator(fraction, filename) fraction = 1 days +=1 return 0,last_x,last_y,fraction,days, 0,0,x_start,y_start def stage_1(self,event,name_for_saving,filename,action_for_save,reload_window,last_x,last_y): action_for_save(name_for_saving) print 'Lol = '+str(len(event)) stage = event[1] if event[3] == 'continue': if len(name_for_saving) <10: name_for_saving += event[2] action_for_save(name_for_saving) if event[3] == 'backspace': if len(name_for_saving)>0: name_for_saving = name_for_saving[:-1] action_for_save(name_for_saving) if event[3] == 'save': if name_for_saving >2: self.core.save_file(name_for_saving,filename) name_for_saving = '' try: reload_window(last_x,last_y) except AttributeError: reload_window(0,0) if event[3] == 'cancel': name_for_saving = '' try: reload_window(last_x,last_y) except AttributeError: reload_window(0,0) return stage, name_for_saving def stage_2(self,event,name_for_loading,filename,action_for_load,reload_window,last_x,last_y): action_for_load(name_for_loading) print 'Lol = '+str(len(event)) stage = event[1] if event[3] == 'continue': if len(name_for_loading) <10: name_for_loading += event[2] action_for_load(name_for_loading) if event[3] == 'backspace': if len(name_for_loading)>0: name_for_loading = name_for_loading[:-1] action_for_load(name_for_loading) if event[3] == 'save': if name_for_loading >2: self.core.load_file(name_for_loading,filename) name_for_loading = '' try: reload_window(last_x,last_y) except AttributeError: reload_window(0,0) if event[3] == 'cancel': name_for_loading = '' try: reload_window(last_x,last_y) except AttributeError: reload_window(0,0) return stage, name_for_loading def stage_3(self,event,stage,moving_army,filename,id_army,last_x,last_y): armies_list = 0 if (event[0] == 'move_army'): current_steps = self.graphical_logic.get_current_steps(id_army, filename) if current_steps > 0: try: move, stage,last_x,last_y,armies_list = moving_army(event[1],event[2],last_x,last_y) except TypeError: move = False if move == True: self.graphical_logic.change_current_steps(id_army, filename, current_steps, -1) elif (event[0] == 'end_of_army_steps'): stage = event[1] armies_list = 0 return stage,last_x,last_y,armies_list def stage_6(self,event,battle_dialog,stage,reload_window,last_x,last_y,armies_lists): print event list = self.battle.auto_battle(armies_lists[0], armies_lists[1]) print list if event[0] == 'battle_mode': stage = event[1] print stage print event return stage else: stage = 6 return stage
import sys from pokemon import Pokemon from battle import Battle from ai import * poke2 = Pokemon("squirtle") poke1 = Pokemon("charmander") ai = AI() battle = Battle() active = battle.get_first(poke1, poke2) while battle.all_alive(poke1, poke2): if (active == poke2): AI_choice = battle.make_choice(poke2, poke1, ai) battle.attack(poke2, poke1, AI_choice) else : AI_choice = battle.make_choice(poke1, poke2, ai) battle.attack(poke1, poke2, AI_choice) if (active == poke1): active = poke2 else : active = poke1
def start_battle(self, attacking_squad): self.battle = Battle(self, attacking_squad) self.battle.persist() self.battle.start()
class Field(Persistent): """Player owned field logic.""" @classmethod def get(self, world, loc): w = get_world(world) if w is not None: return w.fields.get(tuple(loc)) def __init__(self, world, coord, element, owner=None, grid=None): self.world = world self.world_coord = Hex._make(coord) if grid is None: grid = Grid() self.grid = grid self.element = element self.clock = FieldClock() self.stronghold = Stronghold(self) self.queue = FieldQueue() self.plantings = {} self.battle = None self._owner = None if owner is None: owner = WorldPlayer.get() self.owner = owner def api_view(self, requester=None): if requester is not None: visible = requester.get_visible_fields(self.world.uid) if self.world_coord not in visible: return {} # TODO -- add factory etc stuff return dict(owner=self.owner.uid, element=self.element, coordinate=self.world_coord, state=self.state, clock=self.clock.api_view(), queue=self.queue.as_array(), battle=getattr(self.battle, 'uid', None)) @property def in_battle(self): return (self.battle is not None and not self.battle.state.game_over) @property def state(self): if self.in_battle: return FIELD_BATTLE else: return self.clock.state(self) @property def owner(self): return self._owner @owner.setter def owner(self, owner): self._owner = owner for s in self.stronghold.squads: s.owner = owner for u in self.stronghold.free: u.owner = owner def get_adjacent(self, direction): """ Returns the field adjacent to this one in a given direction. Returns None if at the border. """ t = self.world.grid.get_adjacent(self.world_coord, direction=direction) if t: return self.world.fields.get(tuple(tuple(t)[0])) def process_battle_and_movement(self): """ Starts a battle if an attacker is available, otherwise moves a friendly squad into the stronghold if available """ # First, check if there was a previous battle and if it is over if self.battle is not None and self.battle.state.game_over: # If the winner is not the owner, that means the stronghold was # still garrisoned, and we must start a new battle if self.battle.winner != self.owner: self.start_battle(self.battle.battlefield.atksquad) else: next_squad = self.queue.pop() if next_squad is not None: if next_squad.owner == self.owner: self.stronghold.move_squad_in(next_squad) else: self.start_battle(next_squad) def start_battle(self, attacking_squad): self.battle = Battle(self, attacking_squad) self.battle.persist() self.battle.start() def check_ungarrisoned(self): """ Reverts ownership to the WorldPlayer if unoccupied """ wp = WorldPlayer.get() if self.owner != wp and not self.stronghold.garrisoned: self.owner = wp def get_taken_over(self, atkr): """ Transfers a winning attacking squad to the field. Returns False if the stronghold is still controlled. """ if self.stronghold.garrisoned: return False self.owner = atkr.owner self.stronghold.move_squad_in(self.battlefield.atksquad) return True def place_scient(self, unit, location): if getattr(unit, 'type', '') != 'scient': raise ValueError('Unit {0} must be a scient'.format(unit)) location = Hex._make(location) # Placement can only be on one side of the field if location[0] <= 0: raise ValueError('First coordinate of location must be positive') # Unit must be in a squad if not isinstance(unit.container, Squad): raise ValueError('Unit must be in a squad to be placed on a field') # Location must fit on grid if not self.grid.in_bounds(location): msg = 'Location {0} does not fit on the field' raise ValueError(msg.format(location)) # Unit must not collide with other units placed in its squad for u in unit.container: if u != unit and u.chosen_location == location: msg = 'Location is already occupied by squad member {0}' raise ValueError(msg.format(u)) unit.chosen_location = location def rand_place_scient(self, unit): """Randomly place a unit on the grid.""" available = set(self.grid.placement_coords()) if not available: raise ValueError("Grid is full") taken = set([u.chosen_location for u in unit.container if not u.chosen_location.is_null()]) available = available - taken return self.place_scient(unit, random.choice(available)) def rand_place_squad(self, squad): """place the units in a squad randomly on the battlefield""" # Clear any previously chosen locations for u in squad: u.chosen_location = Hex.null available = set(self.grid.placement_coords()) positions = random.sample(available, len(squad)) for unit, pos in zip(squad, positions): self.place_scient(unit, pos) def get_tile_comps(self): """returns a list of stones 1/8th the value of the tile comps.""" stone_list = [] for tile in self.grid.iter_tiles(): stone = Stone() for suit, value in tile.comp.iteritems(): stone[suit] += value / 8 # this 8 will need to be tweaked. if stone.value() != 0: stone_list += [stone] return stone_list def set_silo_limit(self): """Sets the silo limit to 1 year's worth of stones.""" # this uses get_tile_comps so the / 8 is only maintained in one place. limit = {'Earth': 0, 'Fire': 0, 'Ice': 0, 'Wind': 0} for stone in self.get_tile_comps(): for element in limit.keys(): limit[element] += stone[element] return self.stronghold.silo.set_limit(limit) def add_planting(self, loc, comp): self.planting[loc] = comp, sum(comp.values()) def plant(self): """Plants from self.plantlings""" if self.stronghold.farm.produce(self.plantings): for loc, comp in self.plantings.iteritems(): stone = self.stronghold.silo.get(comp) self.grid.imbue_tile(loc, stone) self.grid.get(loc)._p_changed = 1 self.grid._p_changed = 1 self.element = get_element(self.grid.comp) self._p_changed = 1 self.set_silo_limit() def harvest(self): """returns set of stones generated at harvest""" # this needs to be more clever and relate to the units in # the stronghold somehow. # happens once a year. return self.stronghold.silo.imbue_list(self.get_tile_comps()) def battle_end_callback(self, atksquad, defsquad, winner, awards, prisoners): """ Triggered by Battle when it ends. Dead units/squads should have been disbanded before calling this. """ # Add awards to the silo self.stronghold.silo.imbue_list(awards) if winner == atksquad: # Attempt to capture the field. It will fail if the stronghold # is still garrisoned. if atksquad: self.get_taken_over(atksquad) else: # Prisoners must be transferred from attacker to defender's # stronghold's free units. # If prisoners cannot fit they return to where they came from. # Highest valued units are captured first, in case they don't fit. prisoners = sorted(prisoners, key=attrgetter('value'), reverse=True) for u in prisoners: try: self.stronghold.add_free_unit(u) except ValueError: # We've filled the stronghold break # Allow the world to take over if the defender is vacant self.check_ungarrisoned() """ Special """ def __eq__(self, other): if not isinstance(other, Field): return False return (other.world == self.world and other.world_coord == self.world_coord) def __ne__(self, other): return not self.__eq__(other)
__author__ = 'Policenaut' from battle import Battle import constants import pygame screen = pygame.display.set_mode((constants.windowWi, constants.windowHi)) # class Main(): fpsClock = pygame.time.Clock() battleInst = Battle() pygame.display.set_caption("Game Sampling!") # gameRunning = True # # while gameRunning: # battleInst.getInputSetValues() # battleInst.updateDisplay() # # Updates display and then sets FPS to 30 FPS. # #print str(fpsClock.get_fps()) # pygame.display.update() # fpsClock.tick(30) pygame.quit()
class Server(): _poke_cliente = None _poke_server = None _battle = None _ai = None @property def poke_cliente(self): return self._poke_cliente @property def poke_server(self): return self._poke_server @property def ai(self): return self._ai @property def battle(self): return self._battle @poke_cliente.setter def poke_cliente(self, value): self._poke_cliente = value @poke_server.setter def poke_server(self, value): self._poke_server = value @battle.setter def battle(self, value): self._battle = value @ai.setter def ai(self, value): self._ai = value def start_battle(self): try: self.poke_cliente = Pokemon(request.data, xml = True) except etree.XMLSyntaxError as e: print('Erro de sintaxe no XML: ', e) abort(422) if len(sys.argv) == 3: poke = Pokemon(sys.argv[2]) elif len(sys.argv) == 2: poke = Pokemon(sys.stdin) self.poke_server = poke self.battle = Battle() self.ai = AI() first = self.battle.get_first(self.poke_server, self.poke_cliente) if first is self.poke_server: choice = self.battle.make_choice(self.poke_server, self.poke_cliente, self.ai) self.battle.attack(self.poke_server, self.poke_cliente, choice) self.battle.all_alive(self.poke_server, self.poke_cliente) xml = self.poke_cliente.to_XML('<battle_state></battle_state>') xml = self.poke_server.to_XML(xml) else: xml = self.poke_server.to_XML(request.data) return xml, 200 def compute_attack(self, id): self.battle.attack(self.poke_cliente, self.poke_server, choice = id - 1) print('Oponente escolheu o ataque: ', self.poke_cliente.atks[id - 1].name) if self.battle.all_alive(self.poke_cliente, self.poke_server): choice = self.battle.make_choice(self.poke_server, self.poke_cliente, self.ai) self.battle.attack(self.poke_server, self.poke_cliente, choice) self.battle.all_alive(self.poke_cliente, self.poke_server) battle_state = self.poke_cliente.to_XML('<battle_state></battle_state>') battle_state = self.poke_server.to_XML(battle_state) return battle_state, 200 from flask import request def shutdown_server(self): func = request.environ.get('werkzeug.server.shutdown') if func is None: raise RuntimeError('Not running with the Werkzeug Server') func() def shutdown(self): self.shutdown_server() return 'You have been terminated'
class Control: def __init__(self): self.map = map_of_game.Game_Map() self.view = View() self.hero = character.Hero() self.boss = character.Boss() self.skeltons = character.Skeleton() self.view.display_map(self.map.board) self.boss_position() self.skeletons_position() self.battle = Battle(self.hero, self.boss) self.input_event() self.view.display_hero_down(72 + self.hero.x_pos * self.view.size, 72 + self.hero.y_pos * self.view.size) self.view.root.mainloop() ### BOSS POSITION ### ### IN THE FUTURE MOVE TO THE CHARACTERS ### def boss_position(self): x_pos = random.randint(0, 9) y_pos = random.randint(0, 8) while self.map.board[y_pos][x_pos] != 1: print("wall") print("y", y_pos) print("x", x_pos) x_pos += random.randint(-1, 1) y_pos += random.randint(-1, 1) # x_pos = random.randint(0,9) # y_pos = random.randint(0,10) self.view.display_boss(x_pos, y_pos) self.boss.x_pos = x_pos self.boss.y_pos = y_pos def boss_move(self): x_pos = self.boss.x_pos y_pos = self.boss.y_pos # while self.map.board[self.boss.y_pos][self.boss.x_pos] == 1 and (x_pos != self.boss.x_pos): self.korte = random.randint(1, 4) if self.korte == 1: self.boss.x_pos += 1 elif self.korte == 2: self.boss.y_pos += 1 elif self.korte == 3: self.boss.x_pos -= 1 elif self.korte == 4: self.boss.y_pos -= 1 if self.boss.x_pos < 0 or self.boss.y_pos < 0 or self.boss.x_pos > 9 or self.boss.y_pos > 10: self.boss.x_pos = x_pos self.boss.y_pos = y_pos self.boss_move() return if self.map.board[self.boss.y_pos][self.boss.x_pos] != 1: self.boss.x_pos = x_pos self.boss.y_pos = y_pos self.boss_move() return self.view.display_floor(72 + x_pos * self.view.size, 72 + y_pos * self.view.size) self.view.display_boss(self.boss.x_pos, self.boss.y_pos) print("BX", self.boss.x_pos) print("BY", self.boss.y_pos) ### SKELETON NUMBERS AND POSITION ### def skeletons_position(self): skeleton_numbers = random.randint(2, 5) for i in range(skeleton_numbers): x_pos = random.randint(0, 9) y_pos = random.randint(0, 8) while self.map.board[y_pos][x_pos] != 1: print("wall") print("y", y_pos) print("x", x_pos) x_pos += random.randint(-1, 1) y_pos += random.randint(-1, 1) self.view.display_skeleton(x_pos, y_pos) ### HERO MOVING ### def input_event(self): self.view.root.bind('<s>', self.move_down) self.view.root.bind('<w>', self.move_up) self.view.root.bind('<a>', self.move_left) self.view.root.bind('<d>', self.move_right) def move_down(self, event): if event.char == "s": if self.map.board[self.hero.y_pos + 1][ self.hero.x_pos] != 1 or self.hero.y_pos == 10: print("wall") else: self.view.display_floor(72 + self.hero.x_pos * self.view.size, 72 + self.hero.y_pos * self.view.size) self.hero.y_pos += 1 self.draw_game_map("down") self.battle.fight() self.boss_move() self.battle.fight() # self.finish_him() def move_up(self, event): if event.char == "w": if self.map.board[self.hero.y_pos - 1][self.hero.x_pos] != 1 or self.hero.y_pos == 0: print("wall") else: self.view.display_floor(72 + self.hero.x_pos * self.view.size, 72 + self.hero.y_pos * self.view.size) self.hero.y_pos -= 1 self.draw_game_map("up") self.battle.fight() self.boss_move() self.battle.fight() # self.finish_him() def move_left(self, event): if event.char == "a": if self.map.board[self.hero.y_pos][self.hero.x_pos - 1] != 1 or self.hero.x_pos == 0: print("wall") else: self.view.display_floor(72 + self.hero.x_pos * self.view.size, 72 + self.hero.y_pos * self.view.size) self.hero.x_pos -= 1 self.draw_game_map("left") self.battle.fight() self.boss_move() self.battle.fight() # self.finish_him() def move_right(self, event): if event.char == "d": if self.map.board[self.hero.y_pos][ self.hero.x_pos + 1] != 1 or self.hero.x_pos == 11: print("wall") else: self.view.display_floor(72 + self.hero.x_pos * self.view.size, 72 + self.hero.y_pos * self.view.size) self.hero.x_pos += 1 self.draw_game_map("right") self.battle.fight() self.boss_move() self.battle.fight() # self.finish_him() def draw_game_map(self, direction): if direction == "right": self.view.display_hero_right(72 + self.hero.x_pos * self.view.size, 72 + self.hero.y_pos * self.view.size) if direction == "down": self.view.display_hero_down(72 + self.hero.x_pos * self.view.size, 72 + self.hero.y_pos * self.view.size) if direction == "left": self.view.display_hero_left(72 + self.hero.x_pos * self.view.size, 72 + self.hero.y_pos * self.view.size) if direction == "up": self.view.display_hero_up(72 + self.hero.x_pos * self.view.size, 72 + self.hero.y_pos * self.view.size) ### END OF HERO MOVING ### ### FINISH HIM ### def finish_him(self): if self.boss.hp <= 0: self.view.display_finishhim()
def launch_battle(self): Battle(self).mainloop()
from random import randint from battle import Battle from models.army import Army if __name__ == '__main__': armies = [] try: calc_army = int( input('Enter how many armies are playing (min = 2): \n')) if calc_army < 2: print('You entered less then 2 armies') else: for i in range(calc_army): calc_squad = int( input('Enter how many squads for Army_{0} (min = 1):\n'. format(i))) army = Army(randint(2, calc_squad), i) army.create_army() army.damage_rank() armies.append(army) Game = Battle(armies) Game.battle_armies() print(Game) except ValueError: print('Wrong input, you must input only number')
import sys from pokemon import Pokemon from battle import Battle from ai import * poke2 = Pokemon("squirtle") poke1 = Pokemon("charmander") ai = AI() battle = Battle() active = battle.get_first(poke1, poke2) while battle.all_alive(poke1, poke2): if (active == poke2): AI_choice = battle.make_choice(poke2, poke1, ai) battle.attack(poke2, poke1, AI_choice) else: AI_choice = battle.make_choice(poke1, poke2, ai) battle.attack(poke1, poke2, AI_choice) if (active == poke1): active = poke2 else: active = poke1