async def attack(self, target_p, send_message, time): """initates the attack from one player onto another :param target_p: the player that gets attacked :param target_name: the name of the player that gets attacked :param send_message: a function that can send a message to discord :param time: the time the attack will take :param attacker_msg_func: a function to privately message the attacker :param target_msg_func: a function to privately message the target :return: """ target_p.messages.append( "**%s** made an aggressive move against you with these units:\n=============\n%s\n=============\nthey will need %s to arrive" % (self.owner_name, Unit.get_units_str(self.rallied_units), get_time_str(time * Player.unit_time_f()))) await send_message( "you send out your troops:\n====================\n%s\n====================\nagainst %s\nIt will take %s" % (Unit.get_units_str(self.rallied_units), target_p.owner_name, get_time_str(time * Player.unit_time_f()))) attack_units = self.rallied_units.copy( ) # self.rallied units will be reset while building the attack function and needs to be stored here # add an attack to the attack threads. Also give information about the attacking units for recovery and information printing self.attack_threads.append( Process(time, self.build_attack_function(target_p, time), "attack %s" % target_p.owner_name, units=attack_units))
def test_divide(self): # name of the method should be begin with test self.assertEqual(Unit.divide(10, 5), 2) self.assertEqual(Unit.divide(-1, 1), -1) self.assertEqual(Unit.divide(-1, -1), 1) with self.assertRaises(ValueError): Unit.divide(10, 0)
def test_player_creation(s): with s.assertRaises(ValueError): p = Unit.Player('Nome', Inventory.Inventory(), 0, -1, -3, -4, -5, 6, 7, 8) with s.assertRaises(ValueError): p = Unit.Player('Nome', Inventory.Inventory(), 1, 2, 3, 4, 5, 0, 7, -8) with s.assertRaises(ValueError): p = Unit.Player('Nome', Inventory.Inventory(), 1, 2, 3, 4, 5, 6, 8, 8) p = Unit.Player('Nome', Inventory.Inventory(), 1, 2, 3, 4, 5, 6, 7, 8) s.assertEqual(p.name, 'Nome') s.assertEqual(p.max_health, 1) # health tem que ser no máximo max_health s.assertEqual(p.health, 1) s.assertEqual(p.attack, 3) s.assertEqual(p.defense, 4) s.assertEqual(p.agility, 5) s.assertEqual(p.level, 6) s.assertEqual(p.exp, 7) s.assertEqual(p.exp_to_next, 8) s.assertFalse(p.max_health <= 0) s.assertFalse(p.health <= 0) s.assertFalse(p.attack <= 0) s.assertFalse(p.defense <= 0) s.assertFalse(p.agility <= 0) s.assertFalse(p.level <= 0) s.assertFalse(p.exp < 0) s.assertFalse(p.exp_to_next <= 0)
def counter_attack(self, enemy: Unit): if not self.owner.is_alive(): raise CantDoCauseDead(self.owner) if enemy.is_alive(): enemy.take_damage(self.owner.dmg // 2) else: raise TargetIsDead()
def loadFromDict(fields): countries = [createCountry(countryInfo) for countryInfo in fields["countries"]] territories = [createTerritory(tInfo, countries) for tInfo in fields["territories"]] for info in fields["territories"]: territory = Util.getByName(territories, info["name"]) territory.connections = [Util.getByName(territories, neighbour) for neighbour in info["connections"]] unitInfo = {unitType: UnitInfo(unitType, unitInfo) for unitType, unitInfo in fields["unitCatalogue"].items()} units = [] for unitDef in fields["units"]: newUnit = Unit.createUnitFromDict(unitDef, unitInfo, countries, territories) units.append(newUnit) boughtUnits = [] for unitDef in fields["buyList"]: newUnit = Unit.createBoughtUnitFromDict(unitDef, territories) boughtUnits.append(newUnit) board = Board(unitInfo, territories, units, countries, fields["currentPhase"], boughtUnits) for conflictInfo in fields["pastConflicts"]: conflict = Conflict.fromDict(conflictInfo, board) board.resolvedConflicts.append(conflict) board.currentCountry = Util.getByName(countries, fields["currentCountry"]) return board
def setUp(self): self.Side = Battle.Side() self.file_path = "./Adventures/CN/units.json" self.unit_cav = Unit.ImportUnit(self.file_path, abbrev="Cava", amount=100) self.unit_sol = Unit.ImportUnit(self.file_path, abbrev="S", amount=100) self.unit_arc = Unit.ImportUnit(self.file_path, abbrev="Arc", amount=100) self.Side.add_unit(self.unit_arc) self.Side.add_unit(self.unit_sol) self.Side.add_unit(self.unit_cav)
def createSettler(self, x, y): """ Adds a settler to be drawn on the screen at position x, y and returns a reference to this settler. """ unit = Unit(self.viewspace, self.settsurf, x, y) #unit.x = x #unit.y = y unit.configAnimation(True, 0, 24, 25) self.units.append(unit) return unit
def createSettler(self, x, y): """ Adds a settler to be drawn on the screen at position x, y and returns a reference to this settler. """ unit = Unit (self.viewspace, self.settsurf, x, y) #unit.x = x #unit.y = y unit.configAnimation (True, 0, 24, 25) self.units.append(unit) return unit
def attack(self, enemy: Unit): if enemy is self.owner: raise AttacksItself() if not self.owner.is_alive(): raise CantDoCauseDead(self.owner) if enemy.is_alive(): enemy.take_damage(self.owner.dmg) enemy.counter_attack(self.owner) else: raise TargetIsDead()
def AddUnitAndParentsToOrganization(unit, employees, organization): curUnitJson = unit curUnit = Unit.Unit(curUnitJson["Name"], curUnitJson["Id"], None, employees, []) while curUnitJson["Parent"] != None: prevUnitJson = curUnitJson curUnitJson = curUnitJson["Parent"] curUnit.ParentId = curUnitJson["Id"] newUnit = Unit.Unit(curUnitJson["Name"], curUnitJson["Id"],None, [], []) newUnit.AddChild(curUnit) curUnit = newUnit organization.AddChain(curUnit) return
def draw(self): """ use the values to set up the general frame and lines, fill particular zone with given colors """ A = [(75, 25, 0), (50, 50, 0), (25, 75, 0), (25, 0, 75), (18.75, 6.25, 75), (12.5, 12.5, 75), (6.25, 18.75, 75), (0, 25, 75), (10, 0, 90), (5, 5, 90), (0, 10, 90)] Unit.TriLine(Points=[A[0], A[4]], Sort='', Width=1, Color='black', Style="-", Alpha=0.7, Label='').show() Unit.TriLine(Points=[A[1], A[9]], Sort='', Width=1, Color='black', Style="-", Alpha=0.7, Label='').show() Unit.TriLine(Points=[A[2], A[6]], Sort='', Width=1, Color='black', Style="-", Alpha=0.7, Label='').show() Unit.TriLine(Points=[A[3], A[7]], Sort='', Width=1, Color='black', Style="-", Alpha=0.7, Label='').show() Unit.TriLine(Points=[A[8], A[10]], Sort='', Width=1, Color='black', Style="-", Alpha=0.7, Label='').show() plt.xticks([]) plt.yticks([])
def __init__(self, file_inst, file_data, file_reg, file_config, file_result): self.read_files(file_inst, file_data, file_reg, file_config) self.file_result = file_result self.all_inst_fetched = False self.current_inst = 0 self.result = dict() self.register_status = dict() self.flush = False self.inst_exec_list = {} self.IBUS = 'FREE' self.DBUS = 'FREE' self.dbus_first_word_ctr = 0 self.dbus_second_word_ctr = 0 # Create All Units self.IF = Unit('IF',1,False) self.ID = Unit('ID',1,True) self.EXMULT = Unit('EXMULT',self.EXMULT_cycles,self.EXMULT_pipelined) self.EXADD = Unit('EXADD',self.EXADD_cycles,self.EXADD_pipelined) self.EXDIV = Unit('EXDIV',self.EXDIV_cycles,self.EXDIV_pipelined) self.EXIU = Unit('EXIU',1,True) self.EXMEM = Unit('EXMEM',self.EXINT_cycles,False) self.WB = Unit('WB',1,True) self.icache = ICache(self.ICache_cycles,self.EXINT_cycles) self.dcache = DCache(256,self.data,self.DCache_cycles,self.EXINT_cycles) self.dbus_access = 0 self.bus_contention = False
def test_add_units(self): unit = Unit.ImportUnit(self.file_path, abbrev=self.abbrev, amount=200) units = [] units.append(unit) units.append(unit) self.Side.add_units(units) self.assertEqual(len(self.Side.units), 2)
def get_iteration(self, iteration): Side = Battle.Side() i = 0 for unit in self.allowed_units: unit = Unit.ImportUnit(self.file_units, name=self.allowed_units[i], amount=iteration[i]) Side.add_unit(unit) i += 1
def main(): pygame.init() Main.actors = Unit.Actor(Config.actors, Config.actorsx, Config.actorsy) Main.buildings = Building.Buildings(Config.actors, Config.actorsx, Config.actorsy) if Config.loadMap == 1: with open("Saves/Save.txt", "rb") as fp: Config.gameMap = pickle.load(fp) while Config.stop == 0: # Main loop, ends if Config.stop is changed # take keyboard input if Config.gameMode == 0: inputEditor() else: inputGame() if Config.pause == 0: Main.actors.allAct() drawAll() # call the draw map function pygame.display.update() # update map once updated # game time tempTime = time.time() * 1000 while tempTime < Config.frameTime + 90: tempTime = time.time() * 1000 pygame.time.wait(1) # pause for a short while Config.frameTime = tempTime # If loops exits pygame.quit() sys.exit()
def read(self): """ read the Excel, then use self.show() to show the frame, then Plot points, job done~ """ self.show() self.draw() if ("csv" in self.name): raw = pd.read_csv(self.name) elif ("xlsx" in self.name): raw = pd.read_excel(self.name) PointLabels = [] for i in range(len(raw)): if (raw.at[i, 'Label'] in PointLabels or raw.at[i, 'Label'] =='' ): TmpLabel ='' else: PointLabels.append(raw.at[i, 'Label']) print(raw.at[i, 'Label']) TmpLabel = raw.at[i, 'Label'] Unit.TriPoint((raw.at[i, 'F'], raw.at[i, 'L'], raw.at[i, 'Q']), Size=raw.at[i, 'Size'], Color=raw.at[i, 'Color'], Alpha=raw.at[i, 'Alpha'], Marker=raw.at[i, 'Marker'], Label=TmpLabel).show() self.SavePic(name= self.name)
def test_damage_multi(self): unit = Unit.ImportUnit(self.file_path, name=self.abbrev) expected = [20, 40, 60, 80, 100, 120, 140, 160, 180, 200] unit.set_amount(5) damage = unit.get_damage(total=True) print("Damage : " + str(damage)) self.assertIn(damage, expected)
def key_pressed(self, key): self.key_states[key] = True print("Key ", key, " pressed.") if key >= 49 and key <= 57: #numbers 1 through 9 if self.key_states[306] == True: #CTRL self.game.selection_controller.set_control_group(key - 48) else: self.game.selection_controller.get_control_group(key - 48) if key == 32: #space x = Unit(self.game.world, 50, 50) if key == 27: #escape self.game.selection_controller.clear_selection() if key == 113: #q self.game.mouse_controller.currently_building = "Structure" print("Started building a structure.") if key == 122: #z x = RandomMover(self.game.world, 100, 100) if key == 115: #s self.game.selection_controller.stop()
def crossover(self,pair): """ Given two individuals, the method will split their genetic code and generate an offspring which will inherit from both parents """ pivot = random.randint(0,len(pair[0].dna)-1) dna = np.concatenate((pair[0].dna[0:pivot], pair[1].dna[pivot:])) off = U.Unit(dna) return off
def __init__(self, scheme, popsize, mutation=0.01, iterations=1000): self.scheme = scheme self.population = [Unit(self.scheme) for i in range(popsize)] self.iterations = iterations self.popsize = popsize self.mutation = mutation self.lastFitness = None
def test_player_methods(s): p = Unit.Player('Nome', Inventory.Inventory(), 3, 1, 1, 4, 5, 6, 7, 8) s.assertEqual(p.health, 1) p.heal(1) s.assertEqual(p.health, 2) p.heal(10) s.assertEqual(p.health, p.max_health) with s.assertRaises(ValueError): p.heal(-45)
def test_add_unit(self): c_file = {} c_file["name"] = "1" c_file["file"] = "./Adventures/CN/2.json" camp = Adventure.ImportCamp("./Adventures/CN/units.json", c_file) unit = Unit.ImportUnit("./Adventures/CN/units.json", name="soldat") previous_len = len(camp.units) camp.add_unit(unit) self.assertEqual(len(camp.units), previous_len + 1)
async def print_units(self, author, channel): """prints all units a player has""" player = self.get_player(author) if not player.units: await self.send_message(channel, "you have no units") return units_list = Unit.get_units_str(player.units) await self.send_message( channel, "your units:\n================\n%s\n================" % units_list)
def __init__(self, name="qfl_MrMa.xlsx",Label=[u'Q', u'F', u'L:']): super().__init__() self.raw = '' self.Label = Label self.name=name for i in range(len(self.Labels)): self.Tags.append(Unit.Tag(Label=self.Labels[i], Location=self.TriToBin(self.Locations[i][0], self.Locations[i][1], self.Locations[i][2]), X_offset=self.Offset[i][0], Y_offset=self.Offset[i][1]))
def __from_json(jsonObject): if ('FirstName' in jsonObject): return Employee.Employee(jsonObject["FirstName"], jsonObject["LastName"], jsonObject["Id"], jsonObject["Documents"]) if ('ParentId' in jsonObject): return Unit.Unit(jsonObject["Name"], jsonObject["Id"], jsonObject["ParentId"], jsonObject["Employees"], jsonObject["Children"]) if ("root" in jsonObject): return Organization(jsonObject["root"])
def reset(self): """ Resets previous results """ self.collection = [] for unit in range(self.pop): self.collection.append(self.unit_gen(self.func_set, self.var_set)) self.generation = 0 self.fit_record = [] self.best = U.Unit(None)
def draw(self): """ use the values to set up the general frame and lines, fill particular zone with given colors """ Unit.TriLine(Points=[(85, 15, 0), (0, 3, 97)], Sort='', Width=1, Color='black', Style="-", Alpha=0.7, Label='').show() Unit.TriLine(Points=[(45, 0, 55), (0, 75, 25)], Sort='', Width=1, Color='black', Style="-", Alpha=0.7, Label='').show() Unit.TriLine(Points=[(50, 50, 0), (0, 75, 25)], Sort='', Width=1, Color='black', Style="--", Alpha=0.7, Label='').show() T0 = (85, 15, 0) T1 = (0, 3, 97) T2 = (87, 0, 13) T3 = (0, 63, 37) T4 = self.TriCross(A=[T0,T1] , B=[T2,T3]) T2 = (87, 0, 13) T3 = (0, 63, 37) T5 = (45, 0, 55) T6 = (0, 75, 25) T7 = self.TriCross(A=[T2,T3] , B=[T5,T6]) Unit.TriLine(Points=[T4, T7], Sort='', Width=1, Color='black', Style="--", Alpha=0.7, Label='').show() Unit.TriLine(Points=[T7, (0, 63, 37)], Sort='', Width=1, Color='black', Style=":", Alpha=0.7, Label='').show() y = 3 * np.sqrt(3) * (82 - 7.5 - np.sqrt(15)) / (18 * np.sqrt(3) - 1.5) z = 82 - np.power(15, 0.5) x = 100 - y - z p0 = (85, 15, 0) p1 = (0, 3, 97) p2 = (18, 0, 82) p3 = (0, 36, 64) p4 = self.TriCross(A=[p0, p1], B=[p2, p3]) Unit.TriLine(Points=[(18, 0, 82), p4], Sort='', Width=1, Color='black', Style="-", Alpha=0.7, Label='').show() self.TriFill(P=[(100, 0, 0), (85, 15, 0), (0, 3, 97), (0, 0, 100)], Color='blue', Alpha=0.13) ap0 = (85, 15, 0) ap1 = (0, 3, 97) ap2 = (0, 75, 25) ap3 = (45, 0, 55) ap4 = self.TriCross(A=[ap0, ap1], B=[ap2, ap3]) self.TriFill(P=[(0, 75, 25), (0, 3, 97), ap4], Color='red', Alpha=0.13) for i in self.Tags: i.show()
def crossover(self, pair): """ Given two individuals, the method will split their genetic code and generate an offspring which will inherit from both parents """ #pdb.set_trace() new_element = pair[0].dna.copy() p1 = random.choice(new_element.serialize()) p2_node = random.choice(pair[1].dna.serialize()) p2 = p2_node.copy() p1.replace(p2) offspring = U.Unit(new_element) return offspring
def onePointCross(parent1, parent2): index = random.randint(1, len(parent1.values) - 2) child1 = Unit([[x for x in row] for row in parent1.scheme]) child2 = Unit([[x for x in row] for row in parent1.scheme]) p1_values = [[x for x in row] for row in parent1.values] p2_values = [[x for x in row] for row in parent2.values] child1.values = p1_values[:index] + p2_values[index:] child2.values = p2_values[:index] + p1_values[index:] return (child1, child2)
def createUnit(self, gender): u = Unit.Unit(gender) self.equip(u) for stat in Class._allStats: base = self.__dict__[stat + "Base"] x = base / 20 y = (random.randint(0, 2 * x) + random.randint(0, 2 * x) - random.randint(0, 2 * x) - random.randint(0, 2 * x)) / 2 u.__dict__["_" + stat] = base + x + y growthMod = random.gauss(1, 0.1) growthMod = min(1.5, growthMod) growthMod = max(0.5, growthMod) u.__dict__["_" + stat + "GrowthMod"] = growthMod u.incrementClassLevel(self.name) self.addAbilities(u) return u
def __init__(self, fitness_func, gene_gen, unit_gen, pop_size, mut_rate, termination, func_set, var_set): """ Methods: -------- fitness_func: Calculates the problem's fitness value of an individual gene_gen: Generates genetic information unit_gen: Generates the initial population Params: ------- pop_size: Population size mut_rate: Mutation Rate (As the number of genes to be modified) termination: Termintion Condition func_set: Function Set for the internal nodes var_set: Concrete values for the leaves ---------------------------------------------------------------------------- Local Sets: ----------- collection: Set of individuals being simuated generation: Current generation being simulated best: Individual with the best fitness overall best_time: Generation in which the current best was generated fit_record: Record of the fitness score from the best, worst and average performers """ self.fitness = fitness_func self.gene_gen = gene_gen self.unit_gen = unit_gen self.pop = pop_size self.mut = mut_rate self.term = termination self.func_set = func_set self.var_set = var_set self.collection = [] self.generation = 0 for unit in range(pop_size): self.collection.append(self.unit_gen(self.func_set, self.var_set)) self.fit_record = [] self.best = U.Unit(None) self.best_time = 0
def __init__(self, name="MudStone.xlsx", Label=[u'Clay', u'Sand', u'Silt']): super().__init__() self.raw = '' self.Label = Label self.name = name for i in range(len(self.Labels)): self.Tags.append( Unit.Tag(Label=self.Labels[i], Location=self.TriToBin(self.Locations[i][0], self.Locations[i][1], self.Locations[i][2]), X_offset=self.Offset[i][0], Y_offset=self.Offset[i][1]))
def start_turn(self): # Resets all units for unit in self.units: unit.quantity_not_moved = unit.quantity unit.quantity_moved = 0 # Resets all cities for city in self.cities: city.selected = False city.done = False # Runs cities for city in self.cities: city.run_turn() # Checks if a unit was built and spawns it if city.soldiers >= 10: self.units.append( Unit.Unit(list(city.pos), int(city.soldiers / 10), city.owner)) city.soldiers %= 10
def calculateFinalKilledScore(self): score = 0 for u in self.units: score += u.getKilledCount() return score*50
def test_scirun_module_ids(self): Unit.check_scirun_python_script_input(__file__)
class Pipeline: #get all parameters from file and initialize particular pipeline def __init__(self, file_inst, file_data, file_reg, file_config, file_result): self.read_files(file_inst, file_data, file_reg, file_config) self.file_result = file_result self.all_inst_fetched = False self.current_inst = 0 self.result = dict() self.register_status = dict() self.flush = False self.inst_exec_list = {} self.IBUS = 'FREE' self.DBUS = 'FREE' self.dbus_first_word_ctr = 0 self.dbus_second_word_ctr = 0 # Create All Units self.IF = Unit('IF',1,False) self.ID = Unit('ID',1,True) self.EXMULT = Unit('EXMULT',self.EXMULT_cycles,self.EXMULT_pipelined) self.EXADD = Unit('EXADD',self.EXADD_cycles,self.EXADD_pipelined) self.EXDIV = Unit('EXDIV',self.EXDIV_cycles,self.EXDIV_pipelined) self.EXIU = Unit('EXIU',1,True) self.EXMEM = Unit('EXMEM',self.EXINT_cycles,False) self.WB = Unit('WB',1,True) self.icache = ICache(self.ICache_cycles,self.EXINT_cycles) self.dcache = DCache(256,self.data,self.DCache_cycles,self.EXINT_cycles) self.dbus_access = 0 self.bus_contention = False def __repr__(self): pipeline_state = "" for i in range(len(self.inst_exec_list.keys())): pipeline_state += '{0: <24}'.format( self.inst_exec_list[i].upper().strip())+"\t" pipeline_state += str(self.result[i][0]) + '\t' pipeline_state += str(self.result[i][1]) + '\t' pipeline_state += str(self.result[i][2]) + '\t' pipeline_state += str(self.result[i][3]) + '\t' if self.result[i][4]==0: pipeline_state += ' N\t' else: pipeline_state += ' Y\t' if self.result[i][5]==0: pipeline_state += ' N\t' else: pipeline_state += ' Y\t' if self.result[i][6]==0: pipeline_state += ' N\t' else: pipeline_state += ' Y\t' if self.result[i][7]==0: pipeline_state += ' N\t' else: pipeline_state += ' Y\t' pipeline_state += '\n' return pipeline_state def __str__(self): pipeline_state="" pipeline_state += self.IF.__str__()+"\n" pipeline_state += self.ID.__str__()+"\n" pipeline_state += self.EXIU.__str__()+"\n" pipeline_state += self.EXMEM.__str__()+"\n" pipeline_state += self.EXADD.__str__()+"\n" pipeline_state += self.EXMULT.__str__()+"\n" pipeline_state += self.EXDIV.__str__()+"\n" pipeline_state += self.WB.__str__()+"\n" return pipeline_state def read_files(self,file_inst, file_data, file_reg, file_config): # Read all instructions f = open(file_inst) self.set_of_instructions = f.readlines() f.close() # Read config file try: f = open(file_config) lines = f.readlines() EXADD_params = lines[0].split(':')[1].strip() EXMULT_params = lines[1].split(':')[1].strip() EXDIV_params = lines[2].split(':')[1].strip() EXINT_params = lines[3].split(':')[1].strip() ICache_params = lines[4].split(':')[1].strip() DCache_params = lines[5].split(':')[1].strip() self.EXADD_cycles = int(EXADD_params.split(',')[0].strip(',')) self.EXADD_pipelined = EXADD_params.split(',')[1].upper().strip()=='YES' self.EXMULT_cycles = int(EXMULT_params.split(',')[0].strip(',')) self.EXMULT_pipelined = EXMULT_params.split(',')[1].upper().strip()=='YES' self.EXDIV_cycles = int(EXDIV_params.split(',')[0].strip(',')) self.EXDIV_pipelined = EXDIV_params.split(',')[1].upper().strip()=='YES' self.EXINT_cycles = int(EXINT_params.split()[0].strip(',')) self.ICache_cycles = int(ICache_params.split()[0].strip(',')) self.DCache_cycles = int(DCache_params.split()[0].strip(',')) f.close() except Exception, e: print "Error: Invalid config file" exit() # Read register file file = open(file_reg, 'r') regs_string = file.readlines() self.registers = {'R'+str(i):int(regs_string[i].strip(),2) for i in range(len(regs_string))} self.registers['PC']=0 # Read data file self.word_size = 4 self.base_address = 256 file = open(file_data, 'r') data_string = file.readlines() self.data = {self.base_address+(i*self.word_size):int(data_string[i].strip(),2) for i in range(len(data_string))}
def __init__(self): self.unit = Unit()
class UnitManager: def __init__(self): self.unit = Unit() #Everything is shifted by 180 degrees logically because the top of the window is 0 and as your variable increases the entity moves down def moveNorth(self): y = self.unit.getYLoc() self.unit.setYLoc(y - 1) def moveEast(self): x = self.unit.getXLoc() self.unit.setXLoc(x + 1) def moveSouth(self): y = self.unit.getYLoc() self.unit.setYLoc(y + 1) def moveWest(self): x = self.unit.getXLoc() self.unit.setXLoc(x - 1) def ResizeImage(self, image, size): img = ImageTk.PhotoImage(Image.open(image)) return img #return image.resize((size,size), Image.ANTIALIAS)
def createUnits(unitInfoCollection): # Small issue - will create new instance of units that already exist return [Unit.createUnitFromDict(unitInfo, board.unitInfoDict, board.countries, board.territories) for unitInfo in unitInfoCollection]