def __init__(self, inventoryJson, owner): import EventHandlers.RoomInventory Inventory.__init__(self, inventoryJson, owner) self.attributes['hidden_items'] = [] self.attributes['permanent_items'] = [] if inventoryJson != None: if inventoryJson.has_key('hidden_items'): for itemJson in inventoryJson['hidden_items']: item = self.createItem(itemJson) if item != None: self.attributes['hidden_items'].append(item) if inventoryJson.has_key('permanent_items'): for itemJson in inventoryJson['permanent_items']: item = self.createItem(itemJson) if item != None: self.attributes['permanent_items'].append(item) self.addEventHandlerByNameWithAdjusters('Inventory.EventHandlers.RoomInventory.ItemDroppedHandler', None) self.addEventHandlerByNameWithAdjusters('Inventory.EventHandlers.RoomInventory.ActorAttemptedItemGrabHandler', None) self.addEventHandlerByNameWithAdjusters('Inventory.EventHandlers.RoomInventory.ActorGrabbedItemHandler', None) self.addEventHandlerByNameWithAdjusters('Inventory.EventHandlers.RoomInventory.WasObservedHandler', None)
def __init__(self): super().__init__() self.stage_level = 1 self.ended = False self.animation_update_time = 0.13 self.animation_update_time = 0.13 self.map = Map() self.player = Player("image/player.png", x_pos=0, y_pos=0, stat_hp=25, stat_str=5, stat_arm=1) self.staircase = Structure.Staircase(0, 0) self.player.position, self.staircase.position, character_list, object_list\ = self.map.generate_map(self.stage_level) self.character_list = [self.player] + character_list self.object_list = [self.staircase] + object_list self.draw = Draw() self.inventory = Inventory(self.draw.view) self.setWindowTitle("ADRogue") self.setStyleSheet("background-color: #B7A284") self.setCentralWidget(self.draw) self.map.set_object_map(self.object_list) self.map.set_character_map(self.character_list) self.draw.setFixedSize(QSize(1294, 810)) self.update_animation_thread = threading.Thread( target=self.update_animation) self.update_animation_thread.start()
def load_entities(self): grid = self.create_grid(self.map_file) entities = [] for row in range(grid.shape[0]): for col in range(grid.shape[1]): entity = None if grid[row][col] == 1: entity = Player(col, row, Inventory(2, 10)) elif grid[row][col] == 2: inventory = Inventory(3, 5) inventory.add_item(DamageItem()) entity = Enemy(col, row, inventory) elif grid[row][col] == 3: entity = Wall(col, row) elif grid[row][col] == 4: entity = Treasure(col, row, [DamageItem()]) elif grid[row][col] == 5: entity = EndLevel(col, row) if entity: entities.append(entity) return entities
class MenuState(GameState): def __init__(self): self.rect = pygame.Rect(5, 5, 5, 5) self.isMouseDown = False self.selection = SelectionRectangle() self.inventory = Inventory(0, 100, 200, 200, "Inventar") def handle_keyevents(self, event): if (self.isMouseDown == False): if (event.type == pygame.MOUSEBUTTONDOWN): self.isMouseDown = True self.selection.setStartPos(event.pos) self.selection.setEndPos(event.pos) elif (self.isMouseDown == True): if (event.type == pygame.MOUSEMOTION): self.selection.setEndPos(event.pos) elif (event.type == pygame.MOUSEBUTTONUP): self.isMouseDown = False self.selection.setEndPos(event.pos) elif (event.type == pygame.MOUSEBUTTONDOWN): self.selection.setStartPos(event.pos) def update(self): print("Selection Rect: " + str(self.selection.getRectangle())) def render(self, screen): myfont = pygame.font.SysFont("monospace", 15) label = myfont.render("Mouse is: NOT DOWN", 1, (255, 255, 0)) if (self.isMouseDown == True): self.selection.render(screen) label = myfont.render("Mouse is: DOWN", 1, (255, 255, 0)) screen.blit(label, (10, 10)) self.inventory.render(screen)
def run_tests(): """Test Store class.""" # Create Inventory item1 = Item("Blue Wool", "2 Stacks", 1) item2 = Item("Red Wool", "2 Stacks", 1) inv = Inventory() inv.add_item(item1) inv.add_item(item2) # Create Store store = Store("All Australian Wool", 300, 400, "All your wool Needs!", inv) print(store) # Test update_description store.update_description("Lots of wool Colours") print(store) # Test update Location store.update_location(509, 5002) print(store) # Test list Inventory for item in store.inventory.items: print(item)
def __init__(self): self.name = "Character" self.player_name = "Zorg" self.character_level = 1 self.hp = 100 self.location_x, self.location_y = (0, 0) self.inventory = Inventory() self.inventory.add_to_pouch("Gold", 15) self.inventory.add_to_inventory(Items.Fist(), 1) self.inventory.equip_main_hand("Fist") self.character_class = "No Class" self.strength = 10 self.dexterity = 10 self.constitution = 10 self.intellect = 10 self.attributes = { "Strength: ": self.strength, "Dexterity: ": self.dexterity, "Constitution: ": self.constitution, "Intellect: ": self.intellect } self.weapon = self.inventory.get_main_hand_equipped() self.dmg_mod = 2
def __init__(self, inventoryJson, owner): import EventHandlers.RoomInventory Inventory.__init__(self, inventoryJson, owner) self.attributes["hidden_items"] = [] self.attributes["permanent_items"] = [] if inventoryJson != None: if inventoryJson.has_key("hidden_items"): for itemJson in inventoryJson["hidden_items"]: item = self.createItem(itemJson) if item != None: self.attributes["hidden_items"].append(item) if inventoryJson.has_key("permanent_items"): for itemJson in inventoryJson["permanent_items"]: item = self.createItem(itemJson) if item != None: self.attributes["permanent_items"].append(item) self.addEventHandlerByNameWithAdjusters("Inventory.EventHandlers.RoomInventory.ItemDroppedHandler", None) self.addEventHandlerByNameWithAdjusters( "Inventory.EventHandlers.RoomInventory.ActorAttemptedItemGrabHandler", None ) self.addEventHandlerByNameWithAdjusters("Inventory.EventHandlers.RoomInventory.ActorGrabbedItemHandler", None) self.addEventHandlerByNameWithAdjusters("Inventory.EventHandlers.RoomInventory.WasObservedHandler", None)
def clone(self): newBoard = [] ants1 = [] ants2 = [] cons1 = [] cons2 = [] cons3 = [] food1 = self.inventories[PLAYER_ONE].foodCount food2 = self.inventories[PLAYER_TWO].foodCount for col in xrange(0,len(self.board)): newBoard.append([]) for row in xrange(0,len(self.board)): newLoc = self.board[col][row].clone() newBoard[col].append(newLoc) #Organize constructions into inventories if newLoc.constr != None and type(newLoc.constr) is Building and newLoc.constr.player == PLAYER_ONE: cons1.append(newLoc.constr) elif newLoc.constr != None and type(newLoc.constr) is Building and newLoc.constr.player == PLAYER_TWO: cons2.append(newLoc.constr) #Organize ants into inventories if newLoc.ant != None and newLoc.ant.player == PLAYER_ONE: ants1.append(newLoc.ant) elif newLoc.ant != None and newLoc.ant.player == PLAYER_TWO: ants2.append(newLoc.ant) for constr in self.inventories[NEUTRAL].constrs: cons3.append(constr.clone()) newInventories = [Inventory(PLAYER_ONE, ants1, cons1, food1), Inventory(PLAYER_TWO, ants2, cons2, food2), Inventory(NEUTRAL, [], cons3, 0) ] return GameState(newBoard, newInventories, self.phase, self.whoseTurn)
def toInventory(self, checked): if self.inventory_window is None: self.inventory_window = Inventory() self.inventory_window.show() else: self.inventory_window.close() self.inventory_window = None
def __init__(self): """ creates a new program """ self.input = Input() self.output = Output() self.inventory = Inventory() self.choice = None
def setup_state(self): board = [[Location((col, row)) for row in xrange(0, c.BOARD_LENGTH)] for col in xrange(0, c.BOARD_LENGTH)] p1Inventory = Inventory(c.PLAYER_ONE, [], [], 0) p2Inventory = Inventory(c.PLAYER_TWO, [], [], 0) neutralInventory = Inventory(c.NEUTRAL, [], [], 0) return GameState(board, [p1Inventory, p2Inventory, neutralInventory], c.SETUP_PHASE_1, c.PLAYER_ONE)
def __init__(self, inventoryJson, owner): Inventory.__init__(self, inventoryJson, owner) self.attributes['equipment'] = { 'Head': None, 'Ears': None, 'Eyes': None, 'Face': None, 'Neck': [None, None], 'Body': None, 'Arms': None, 'Wrist': [None, None], 'Hands': None, 'Finger': [None, None], 'Waist': None, 'Legs': None, 'Feet': None, 'Shield': None, 'Wielded': None, } if inventoryJson != None: if inventoryJson.has_key('equipment'): equipment = inventoryJson['equipment'] for key in equipment.keys(): self.attributes['equipment'][key] = self.createItem( equipment[key]) self.addEventHandlerByNameWithAdjusters( 'Inventory.EventHandlers.ActorInventory.ActorAttemptedDropHandler', None) self.addEventHandlerByNameWithAdjusters( 'Inventory.EventHandlers.ActorInventory.ItemDroppedHandler', None) self.addEventHandlerByNameWithAdjusters( 'Inventory.EventHandlers.ActorInventory.ActorInitiatedItemGrabHandler', None) self.addEventHandlerByNameWithAdjusters( 'Inventory.EventHandlers.ActorInventory.ActorGrabbedItemHandler', None) self.addEventHandlerByNameWithAdjusters( 'Inventory.EventHandlers.ActorInventory.ActorViewedEquipmentHandler', None) self.addEventHandlerByNameWithAdjusters( 'Inventory.EventHandlers.ActorInventory.ActorAttemptedItemEquipHandler', None) self.addEventHandlerByNameWithAdjusters( 'Inventory.EventHandlers.ActorInventory.ActorEquippedItemHandler', None) self.addEventHandlerByNameWithAdjusters( 'Inventory.EventHandlers.ActorInventory.ActorAttemptedItemRemovalHandler', None) self.addEventHandlerByNameWithAdjusters( 'Inventory.EventHandlers.ActorInventory.ActorRemovedItemHandler', None) self.addEventHandlerByNameWithAdjusters( 'Inventory.EventHandlers.ActorInventory.ActorObservedHandler', None)
def inventory_Item(self, pack, item): Inventory.inventory_Item(self, pack, item) self.available_Item = { "Bunny Slippers": 10, "Nerf-Gun": 100, "McMuffin": 1000 } self.inventory_Slot = self.available_Item return self.check_Inventory(self.available_Item)
def __init__(self, x, y): self.x = x self.y = y self.ammo = 10 self.healthPacks = 3 self.inventory = Inventory() self._current_weapon = None self._health = 20 self._maxHealth = self._health
class Character(): def __init__(self, name, hp=10, strength=5, toughness=1, inventory=None, equipment=None): self.name = name self.maxHp = hp self.hp = hp self.strength = strength self.toughness = toughness self.equipment = Equipment() if equipment is None else equipment self.inventory = Inventory([HealingPotion() ]) if inventory is None else inventory def attack(self): #Bare-hands attack dmg = self.strength if self.equipment.weapon: dmg = dmg + self.equipment.weapon.getDamages() return dmg def protect(self, dmg): if self.equipment.armor: dmg = self.equipment.armor.protect(dmg) dmg = dmg - self.toughness return max(dmg, 0) def pickup(self, item): def default(): self.inventory.addItem(item) def w(): self.equipment.weapon = item def a(): self.equipment.armor = item switch = { 'Weapon': w, 'Armor': a, } switch.get(type(item).__name__, default)() def isAlive(self): return self.hp > 0 def __str__(self): return self.name + (' is alive with %s HP'%self.hp if self.isAlive() else ' is dead ')\ + ', carrying ' + (str(self.equipment.armor) if self.equipment.armor else 'no armor')\ + ' and wielding ' + (str(self.equipment.weapon) if self.equipment.weapon else 'no weapon') + '.'
def getBlankState(): board = [] for y in range(10): tmp = [] for x in range(10): tmp.append(Location((x, y))) board.append(tmp) invents = [ Inventory(PLAYER_ONE, [], [], 0), Inventory(PLAYER_TWO, [], [], 0), Inventory(NEUTRAL, [], [], 0) ] return GameState(board, invents, SETUP_PHASE_1, PLAYER_ONE)
def test_get_median_for_category_simple(self): items = [ { "store": 1, "category": 1, "item_name": "The Item", "items": 4, "price": 200 }, ] inventory = Inventory(items) assert inventory.get_median_for_category(1) == 200
def new(self): """Game class method to start a new game. """ # start a new game # initialise sprite groups self.all_sprites = pygame.sprite.LayeredUpdates() self.walls = pygame.sprite.LayeredUpdates() self.gui = pygame.sprite.LayeredUpdates() self.enemies = pygame.sprite.LayeredUpdates() self.item_drops = pygame.sprite.LayeredUpdates() # instantiate dungeon self.dungeon = Dungeon(self, cfg.DUNGEON_SIZE) if self.loaded: self.dungeon.tileset = self.saveGame.data['tileset'] else: self.dungeon.create() self.WSign = self.imageLoader.WarnSign self.WSign2 = self.imageLoader.WarnSign2 self.inventory = Inventory(self) # spawn the player in the middle of the room self.player = Player(self, (cfg.WIDTH // 2, cfg.TILESIZE * 12)) self.currentpistol = Pistol(self, self.player) self.currentmachine = MachineGun(self, self.player) if self.pistolpick == True: self.player.itemA = self.currentpistol elif self.machinegunpick == True: self.player.itemA = self.currentmachine # load settings if self.loaded: self.loadSavefile() # spawn the new objects (invisible) self.prev_room = self.dungeon.current_room_index self.transitRoom(self, self.dungeon) # create a background image from the tileset for the current room self.background = self.tileRoom(self, self.imageLoader.tileset, self.dungeon.current_room_index) self.run()
def __init__(self): self.name = 'Richard' self.max_hp = 50 self.hp = self.max_hp self.lvl = 1 self.exp = 0 self._expForLvlUp = 30 self.damage = 10 self.defence = 0 self.atk = '' self.defend = '' self.inventory = Inventory() self.equipment = Equipment() self.gold = 0 self.rewards = Rewards()
def __init__(self, name, hp=10, strength=5, toughness=1, inventory=None, equipment=None): self.name = name self.maxHp = hp self.hp = hp self.strength = strength self.toughness = toughness self.equipment = Equipment() if equipment is None else equipment self.inventory = Inventory([HealingPotion() ]) if inventory is None else inventory
class WMIInventory(): _interval = 3600 def __init__(self): self._tmp_conf = OssimConf (Const.CONFIG_FILE) self.inv = Inventory() #Implement cache with timeout????? self.cache = [] #threading.Thread.__init__(self) def connectDB(self): self.db = OssimDB() self.db.connect (self._tmp_conf["ossim_host"], self._tmp_conf["ossim_base"], self._tmp_conf["ossim_user"], self._tmp_conf["ossim_pass"]) def closeDB(self): self.db.close() def run(self): while True: self.process() time.sleep(self._interval) def process(self): #We have to retrieve hosts with credentials or hosts that belong to a know AD #Check host with local credentials hosts = self.inv.getHostWithCredentials("WMI")
def main(): # Set up Rick's guitar inventory inventory = Inventory() initialize_inventory(inventory) what_erin_likes = Guitar("", 0, "fender", "Stratocastor", "electric", "Alder", "Alder") guitar = inventory.search(what_erin_likes) if guitar != None: print("Erin you might like this", guitar.builder, guitar.model, guitar.type, "guitar:\n", guitar.back_wood, "back and sides,\n", guitar.top_wood, "top.\n You can have it for only $", guitar.price, "!") else: print("Sorry, Erin, we have nothing for you.")
def _retrieveComponent(self, instance, componentName): facilityNames = self._cast(componentName) facilityOrder = [] dict = {} for index, facilityName in enumerate(facilityNames): # Strip leading and trailing whitespace from facility name facility = self.itemFactory(facilityName.strip()) attr = "item%05d" % index dict[attr] = facility facilityOrder.append(facilityName.strip()) from Inventory import Inventory from pyre.components.Component import Component Inventory = Inventory.__metaclass__("FacilityArray.Inventory", (Component.Inventory, ), dict) dict = {'Inventory': Inventory} FacilityArray = Component.__metaclass__("FacilityArray", (Component, ), dict) fa = FacilityArray(self.name) fa.Inventory._facilityOrder = facilityOrder import pyre.parsing.locators locator = pyre.parsing.locators.builtIn() return fa, locator
def __init__(self, name="Player", health=20, shield=10, dodge=0, parry=0, criticalHit=1, mana=10, damageMin=1, damageMax=2, armor=0, xp=0, inventory=Inventory()): Character.__init__(self, name, health, shield, dodge, parry, criticalHit, mana, damageMin, damageMax, armor, xp, inventory) self.statistics = Statistics() self.success = { "monster_hunter": Success(name="Monster hunter"), "commercial": Success(name="Commercial"), "lucky": Success(name="Lucky"), "compulsive_buyer": Success(name="Compulsive buyer"), "vendor": Success(name="Vendor on the run"), "consumer": Success(name="Consumer"), "the_end": Success(name="The End") }
def _retrieveComponent(self, instance, componentName): facilityNames = self._cast(componentName) facilityOrder = [] dict = {} for index, facilityName in enumerate(facilityNames): # Strip leading and trailing whitespace from facility name facility = self.itemFactory(facilityName.strip()) attr = "item%05d" % index dict[attr] = facility facilityOrder.append(facilityName.strip()) from Inventory import Inventory from pyre.components.Component import Component Inventory = Inventory.__metaclass__("FacilityArray.Inventory", (Component.Inventory,), dict) dict = {'Inventory': Inventory} FacilityArray = Component.__metaclass__("FacilityArray", (Component,), dict) fa = FacilityArray(self.name) fa.Inventory._facilityOrder = facilityOrder import pyre.parsing.locators locator = pyre.parsing.locators.builtIn() return fa, locator
class SSHInventory(): _interval = 3600 def __init__(self): self._tmp_conf = OssimConf (Const.CONFIG_FILE) self.inv = Inventory() #Implement cache with timeout????? self.cache = [] #threading.Thread.__init__(self) def connectDB(self): self.db = OssimDB() self.db.connect (self._tmp_conf["ossim_host"], self._tmp_conf["ossim_base"], self._tmp_conf["ossim_user"], self._tmp_conf["ossim_pass"]) def closeDB(self): self.db.close() def run(self): while True: self.process() time.sleep(self._interval) def process(self): ''' Check host with local credentials ''' hosts = self.inv.getHostWithCredentials("SSH")
def __init__(self, env): random.seed(5) self.clock = env # Create Instances of main components self.floor = Floor(env) self.inventory = Inventory(env, self.floor) self.robot_scheduler = RobotScheduler(env, self.floor) self.order_control = OrderControl(env, self.inventory)
def __init__(self): self.db = DB() self.__employees = Employees(self) self.__vendors = Vendors(self) self.__time_clock = TimeClock(self) self.__orders = Orders(self) self.__inventory = Inventory(self) self.__register = Register(self) self.account = Account()
def __init__(self): super().__init__() self._Health = 100 self._Armor = 0 self._MaxHealth = 100 self._MaxArmor = 100 self._Dead = False self._Inventory = Inventory() self._MoveAble = True
def __init__(self): self.heroRace = Race() self.heroClass = "" #Получаем Данные от пользователя self.getName() self.getClass() self.getRace() super().__init__(self.name, self.heroRace.stats, Elements(), 0) ## Инвентарь героя self.inventory = Inventory() ## Обмундирование героя self.equipment = Equipment() ## Карман с Лечебками героя self.potionsPocket = PotionsPocket()
class Test_Inventory: #filename = "$HOME/.futuregrid/cloudmesh-new.yaml" def setup(self): self.inventory = Inventory() def tearDown(self): self.inventory.disconnect() def test00_disconnect(self): HEADING("00 DISCONNECT") pass def test01_file(self): HEADING("01 FILE") self.inventory.load("example.json")
def __create_pending(self, num_sublots, arrival, today): # return pending_lst or None pending_q = self.product.get_sublot_quantity() pending_inv = [] for i in range(num_sublots): sell = today + timedelta(days=self.product.get_sell_by()) inv = Inventory(self.product.grp_id, 0, 0, pending_q, arrival, sell) pending_inv.append(inv) return pending_inv
class Program(): """ Creates a blueprint for a program """ def __init__(self): """ creates a new program """ self.input = Input() self.output = Output() self.inventory = Inventory() self.choice = None def run(self): """ runs the program """ print("\nWelcome!") while self.choice != 4: # Prints the main menu print(self.output.get_main_menu()) self.choice = self.input.get_choice_in_range(4) if self.choice == 1: new_product = self.inventory.create_product() self.input.set_product_properties(new_product) self.inventory.add_product(new_product) elif self.choice == 2: products = self.inventory.get_products() print(self.output.get_products_list(products)) elif self.choice == 3: product_name = self.input.get_input_as_str("Enter product name: ") product = self.inventory.get_product(product_name) print(self.output.get_product_information(product))
class Alchemist: def __init__(self, name): self.name = name self.icon = name[0] self.row = 0 self.column = 0 self.inventory = Inventory() def user_choice(self, choice, rows, columns): """ Moves the player according to user input :param choice: the direction moved (WASD) or inventory (E) :param rows: number of rows on the map :param columns: number of columns on the map :return: a boolean for if the player walked off the map (zoning) """ is_new_map = False if choice == 'E': self.inventory.print_inventory() elif choice == 'W' and self.row > 0: self.row -= 1 elif choice == 'W': self.row = rows - 1 is_new_map = True elif choice == 'A' and self.column > 0: self.column -= 1 elif choice == 'A': self.column = columns - 1 is_new_map = True elif choice == 'S' and self.row < rows - 1: self.row += 1 elif choice == 'S': self.row = 0 is_new_map = True elif choice == 'D' and self.column < columns - 1: self.column += 1 elif choice == 'D': self.column = 0 is_new_map = True return is_new_map
def testUse(self): dummy = Character('dummy', 20, 0, 0, Inventory([HealingPotion('normal')])) dummy.hp = 5 charController = CharacterController() charController.makeUse(dummy, dummy.inventory.items[0], dummy) self.assertEqual(dummy.hp, 15) self.assertFalse(dummy.inventory.items) dummy.pickup(self.potion) charController.makeUse(dummy, dummy.inventory.items[0], dummy) self.assertEqual(dummy.hp, 20)
def _start(self): self._pc.reset() self._currentmapname = self._startmap self._maps = {} self._maphistory = [self._startmap] self._inventory = Inventory() if '-mkey' in sys.argv: self._inventory.acquiremkey() if '-sword' in sys.argv: self._inventory.changesword(int(sys.argv[sys.argv.index('-sword')+1])) self._port(self._startport)
def __init__(self, pos, imageurl): super(Player, self).__init__(pos, imageurl) self.max_health = 20 self.health = 18 self.max_speed = 0.25 self.acceleration = 0.01 #fiddle with this until it seems good self.inventory = Inventory(5, 10) self.selected_slot = 0 #Temp items for testing self.inventory.insert(ItemStack.itemstack_from_name("magicStaff")) self.inventory.insert(ItemStack.itemstack_from_name("pickaxe"))
def __init__(self, inventoryJson, owner): Inventory.__init__(self, inventoryJson, owner) self.attributes['equipment'] = { 'Head' : None, 'Ears' : None, 'Eyes' : None, 'Face' : None, 'Neck' : [None, None], 'Body' : None, 'Arms' : None, 'Wrist' : [None, None], 'Hands' : None, 'Finger' : [None, None], 'Waist' : None, 'Legs' : None, 'Feet' : None, 'Shield' : None, 'Wielded' : None, } if inventoryJson != None: if inventoryJson.has_key('equipment'): equipment = inventoryJson['equipment'] for key in equipment.keys(): self.attributes['equipment'][key] = self.createItem(equipment[key]) self.addEventHandlerByNameWithAdjusters('Inventory.EventHandlers.ActorInventory.ActorAttemptedDropHandler', None) self.addEventHandlerByNameWithAdjusters('Inventory.EventHandlers.ActorInventory.ItemDroppedHandler', None) self.addEventHandlerByNameWithAdjusters('Inventory.EventHandlers.ActorInventory.ActorInitiatedItemGrabHandler', None) self.addEventHandlerByNameWithAdjusters('Inventory.EventHandlers.ActorInventory.ActorGrabbedItemHandler', None) self.addEventHandlerByNameWithAdjusters('Inventory.EventHandlers.ActorInventory.ActorViewedEquipmentHandler', None) self.addEventHandlerByNameWithAdjusters('Inventory.EventHandlers.ActorInventory.ActorAttemptedItemEquipHandler', None) self.addEventHandlerByNameWithAdjusters('Inventory.EventHandlers.ActorInventory.ActorEquippedItemHandler', None) self.addEventHandlerByNameWithAdjusters('Inventory.EventHandlers.ActorInventory.ActorAttemptedItemRemovalHandler', None) self.addEventHandlerByNameWithAdjusters('Inventory.EventHandlers.ActorInventory.ActorRemovedItemHandler', None) self.addEventHandlerByNameWithAdjusters('Inventory.EventHandlers.ActorInventory.ActorObservedHandler', None)
def __init__(self): self.heroRace = Race() self.heroClass = "" #Получаем Данные от пользователя self.getName() self.getClass() self.getRace() super().__init__(self.name,self.heroRace.stats,Elements(),0) ## Инвентарь героя self.inventory = Inventory() ## Обмундирование героя self.equipment = Equipment() ## Карман с Лечебками героя self.potionsPocket = PotionsPocket()
def __init__(self, info): ''' [name, currentHp, level, experience, statList, growthList, wepExpList, Inventory] ''' #TODO Add skills, mov and any other important statistics. . #Mov might be better in the stats array, depending how I do class changes or if I want #anyone to be able to gain mov on level-up. self.name = info[0] self.cHp = info[1] self.lvl, self.exp = info[2], info[3] self.stats = Character.StatsArray._make(info[4]) self.growths = Character.StatsArray._make(info[5]) self.WExps = Character.WepArray._make(info[6]) self.inv = Inventory(self, info[7])
def __init__(self, name): # does not try loading a family if name is not passed # ONLY do this during family creation if not name: return path = os.path.join("data", "actors", "families", name) familyini = Configuration(os.path.join("..", path, "family.ini")).family # family's last name, all members of the family will have this last name self.name = name # all the members in your party path = os.path.join("..", path) members = [n.split("/")[-1] for n in glob.glob(os.path.join(path, "*.ini"))] exclude = ["family.ini", "bestiary.ini", "inventory.ini"] for item in exclude: if item in members: members.remove(item) self.members = [Character(self, n.replace(".ini", "")) for n in members] # the party used in battle is the first 3 members you have ordered if len(self.members) >= 3: self.party = Party(self.members[0:3]) # party should only be 0 during character creation elif len(self.members) == 0: self.party = None else: self.party = Party(self.members[0 : len(self.members)]) # the items your family has self.inventory = Inventory(self) print self.inventory # amount of money your family possesses self.gold = familyini.__getattr__("gold", int) # gameplay difficulty (0 - easy, 1- normal, 2 - hard) self.difficulty = familyini.__getattr__("difficulty", int) # family bestiary self.bestiary = Bestiary(self)
def __init__(self, name): self.inv = Inventory() self.dim = Portal() self.ui = Interface() self.loader = BlockLoader() self.no_quest = Quest(desc="No quest.", name="None") self.you = Player(self.inv, name, self.no_quest) self.mob1 = Cow() self.mob2 = Gnu() self.mob3 = Zombie() self.mob4 = Grue() self.mob5 = Kitty() self.no_quest = Quest(desc="No quest.", name="None") self.hell_quest = Quest(desc="Conquer Hell!", name="Crusader") self.sky_quest = Quest(desc="Conquer the Sky Dimension!", name="Hostile Heavenly Takeover") self.magic_quest = Quest(desc="Magify something.", name="We Don't Have to Explain It") self. self.sk = SkyKing() self.satan = Lucifer()
def _retrieveComponent(self, instance, componentName): facilityNames = self._cast(componentName) dict = {} for index, facilityName in enumerate(facilityNames): facility = self.itemFactory(facilityName) attr = "item%d" % index dict[attr] = facility from Inventory import Inventory from pyre.components.Component import Component Inventory = Inventory.__metaclass__("FacilityArray.Inventory", (Component.Inventory,), dict) dict = {'Inventory': Inventory} FacilityArray = Component.__metaclass__("FacilityArray", (Component,), dict) fa = FacilityArray(self.name) import pyre.parsing.locators locator = pyre.parsing.locators.builtIn() return fa, locator
def __init__(self, pos, options): self.hair_color = options[0] self.hair_length = options[1] self.body_color = options[2] self.tail_color = options[3] super().__init__(pos, "", 20) self.max_speed = 0.25 self.acceleration = 0.01 self.inventory = Inventory(5, 10) self.selected_slot = 0 self.anim_timer = 0 self.anim_frame = False self.anim_state = 0 self.anim_dir = 0 #Temp items for testing self.inventory.insert(ItemStack.itemstack_from_name("magicStaff")) self.inventory.insert(ItemStack.itemstack_from_name("pickaxe")) self.inventory.insert(ItemStack.itemstack_from_name("sword"))
def __init__(self, name, locations, cash, products, days): self.maxDays = days self.locations = getLocations(locations, products) self.name = name; self.inventory = Inventory(cash) self.startingCash = cash
class Main: def __init__(self, name): self.inv = Inventory() self.dim = Portal() self.ui = Interface() self.loader = BlockLoader() self.no_quest = Quest(desc="No quest.", name="None") self.you = Player(self.inv, name, self.no_quest) self.mob1 = Cow() self.mob2 = Gnu() self.mob3 = Zombie() self.mob4 = Grue() self.mob5 = Kitty() self.no_quest = Quest(desc="No quest.", name="None") self.hell_quest = Quest(desc="Conquer Hell!", name="Crusader") self.sky_quest = Quest(desc="Conquer the Sky Dimension!", name="Hostile Heavenly Takeover") self.magic_quest = Quest(desc="Magify something.", name="We Don't Have to Explain It") self. self.sk = SkyKing() self.satan = Lucifer() def clear_screen(self): if sys.platform.startswith("win32") or sys.platform.startswith("os2"): system("cls") else: sys.stdout.write('\033[2J') sys.stdout.write('\033[H') sys.stdout.flush() def run(self): while True: self.you.day += 1 sleep(1) self.clear_screen() if self.you.dimension == "Hell": self.run_hell() elif self.you.dimension == "Sky Dimension": self.run_sd() elif self.you.dimension == "Base": pass else: print "ERR" cowspawn = self.mob1.x == None and self.mob1.y == None and self.mob1.z == None zomspawn = self.mob3.x == None and self.mob3.y == None and self.mob3.z == None gruespawn = self.mob4.x == None and self.mob4.y == None and self.mob4.z == None kittyspawn = self.mob5.x == None and self.mob5.y == None and self.mob5.z == None if cowspawn and zomspawn and gruespawn and kittyspawn: self.ui.load_peaceful_graphics(self.you) elif cowspawn and not zomspawn and gruespawn and kittyspawn: self.ui.load_zombie_graphics(self.you, self.mob3) elif cowspawn and zomspawn and not gruespawn and kittyspawn: self.ui.load_grue_graphics(self.you, self.mob4) elif not cowspawn and zomspawn and gruespawn and kittyspawn: self.ui.load_cow_graphics(self.you, self.mob1) elif cowspawn and zomspawn and gruespawn and not kittyspawn: self.ui.load_kitty_graphics(self.you, self.mob5) else: pass if not zomspawn: zomcheck1 = abs(self.mob3.y) - abs(self.you.y) == 1 and abs(self.mob3.x) - abs(self.you.x) == 0 else: zomcheck1 = False if not zomspawn: zomcheck2 = abs(self.mob3.x) - abs(self.you.x) == 1 and abs(self.mob3.y) - abs(self.you.y) == 0 else: zomcheck2 = False if zomcheck1 or zomcheck2: self.you.attack(self.mob3, self.inv) else: pass if not gruespawn: gruecheck1 = abs(self.mob4.y) - abs(self.you.y) == 1 and abs(self.mob4.x) - abs(self.you.x) == 0 else: gruecheck1 = False if not gruespawn: gruecheck2 = abs(self.mob4.x) - abs(self.you.x) == 1 and abs(self.mob4.y) - abs(self.you.y) == 0 else: gruecheck2 = False if gruecheck1 or gruecheck2: self.you.attack(self.mob4, self.inv) else: pass if not cowspawn: cowcheck1 = abs(self.mob1.y) - abs(self.you.y) == 1 and abs(self.mob1.x) - abs(self.you.x) == 0 else: cowcheck1 = False if not cowspawn: cowcheck2 = abs(self.mob1.x) - abs(self.you.x) == 1 and abs(self.mob1.y) - abs(self.you.y) == 0 else: cowcheck2 = False if cowcheck1 or cowcheck2: self.you.attack(self.mob1, self.inv) else: pass if self.inv.hellporterpartone == 1 and self.inv.hellporterparttwo == 1 and self.inv.hellporterpartthree == 1: print "You have created the Hell Teleporter!" self.inv.hell_teleporter = 1 else: pass if self.inv.skykeypartone == 1 and self.inv.skykeyparttwo == 1 and self.inv.skykeypartthree == 1: print "You have created the key to the Stairway to the Sky Dimension!" self.inv.sky_key = 1 self.mob1.check_spawn(self.you, randint(10, 15)) self.mob2.check_spawn(self.you, 35) self.mob3.check_spawn(self.you, randint(20, 40)) self.mob4.check_spawn(self.you, randint(30, 45)) self.mob5.check_spawn(self.you, randint(60,75)) command = str(raw_input("> ")) if command.startswith("dig "): self.you.move(command[4:].upper()) elif command == "inventory": self.clear_screen() self.inv.list_inv() sleep(3) self.clear_screen() elif command == "inv": self.clear_screen() self.inv.list_inv() sleep(3) elif command == "craft bow": if self.inv.wood >= 3: self.inv.bow = self.inv.UNMAGIC_HAD self.you.equipped = "L1" else: print "You don't have enough materials." elif command == "craft dagger": if self.inv.wood >= 3: self.inv.dagger = self.inv.UNMAGIC_HAD self.you.equipped = "L1" else: print "You don't have enough materials." elif command == "craft sword": if self.inv.wood >= 1 and self.inv.iron >= 2: self.inv.sword = self.inv.UNMAGIC_HAD self.you.equipped = "L2" else: print "You don't have enough materials." elif command == "craft crossbow": if self.inv.wood >= 2 and self.inv.iron >= 2: self.inv.crossbow = self.inv.UNMAGIC_HAD self.you.equipped = "L2" else: print "You don't have enough materials." elif command == "craft magifier": if self.inv.iron >= 3 and self.inv.gold >= 4 and self.inv.unobtainium >= 2: self.inv.magifier = self.inv.UNMAGIC_HAD print "You created the Magifier! You can now magify weaponry with 3 involatilium and the magifier!" else: print "You don't have enough materials." elif command.startswith("magify "): if self.inv.magifier == self.inv.UNMAGIC_HAD: self.inv.magify(command[7:]) else: print "You don't have the Magifier." elif command.startswith("teleport "): if command[9:].lower() == "hell" and self.you.dimension != "Hell": if self.inv.hell_teleporter == self.inv.UNMAGIC_HAD: self.dim.teleport(self.you, "Hell") else: print "You can't teleport to Hell without the Teleporter!" elif command[9:].lower() == "sky" and self.you.dimension != "Sky": if self.inv.skydim_key == self.inv.UNMAGIC_HAD: self.dim.teleport(self.you, "Sky") else: print "You can't teleport to the Sky Dimension without the key to the stairway!" elif command[9:].lower() == "base" and self.you.dimension != "Base": self.dim.teleport(self.you, "Sky") else: print "Either that dimension doesn't exist or it has not been implemented yet." elif command == "exit": temp = raw_input("Do you really want to exit?\n>") if temp.lower() == "yes" or temp.lower() == "y": exit("Goodbye, then.") else: pass elif command == "quests": self.questboard.display_board() else: print "Unrecognized command." def run_hell(self): while True: sleep(1) self.clear_screen() if self.you.dimension == "Hell": pass elif self.you.dimension == "Sky Dimension": self.run_sd() elif self.you.dimension == "Base": self.run() else: print "ERR" self.ui.load_peaceful_graphics(self.you) command = str(raw_input("> ")) if command.startswith("dig "): self.you.move_hell(command[4:].upper()) elif command == "inventory": self.clear_screen() self.inv.list_inv() sleep(2) self.clear_screen() elif command == "inv": self.clear_screen() self.inv.list_inv() sleep(2) elif command == "fight boss" or command == "boss fight": self.satan.boss_fight(self.you, self.inv) elif command.startswith("craft "): print "You can't craft in Hell." elif command.startswith("magify "): if self.inv.magifier == self.inv.UNMAGIC_HAD: self.inv.magify(command[7:]) else: print "You don't have the Magifier." elif command.startswith("teleport"): if command[9:].lower() == "base" and self.you.dimension != "Base": self.dim.teleport(self.you, "Base") else: print "You can't teleport anywhere other than back to the base dimension while in Hell." elif command == "exit": temp = raw_input("Do you really want to exit?\n>") if temp.lower() == "yes" or temp.lower() == "y": exit("Goodbye, then.") else: pass else: print "Unrecognized command." def run_sd(self): while True: sleep(1) self.clear_screen() if self.you.dimension == "Hell": self.run_hell() elif self.you.dimension == "Sky Dimension": pass elif self.you.dimension == "Base": self.run() else: print "ERR" if command.startswith("dig "): self.you.move_sd(command[4:].upper()) elif command == "inventory": self.clear_screen() self.inv.list_inv() sleep(3) self.clear_screen() elif command == "inv": self.inv.list_inv() elif command == "boss fight": self.sk.boss_fight(self.you, self.inv) elif command.startswith("craft "): print "You can't craft in the Sky Dimension." elif command.startswith("magify "): if self.inv.magifier == self.inv.UNMAGIC_HAD: self.inv.magify(command[7:]) else: print "You don't have the Magifier." elif command == "boss fight" or command == "fight boss": print "Are you /sure/ you want to fight the Sky King? (y|n)" tmp = raw_input("> ") if tmp.lower() == "y" or tmp.lower() == "yes": sk.boss_fight(self.you, self.inv) else: pass elif command.startswith("teleport"): if command[9:].lower() == "base" and self.you.dimension != "Base": self.dim.teleport(self.you, "Base") else: print "You can't teleport anywhere other than back to the base dimension while in the Sky Dimension." elif command == "exit": temp = raw_input("Do you really want to exit?\n>") if temp.lower() == "yes" or temp.lower() == "y": exit("Goodbye, then.") else: pass else: print "Unrecognized command."
class Player(Entity): def __init__(self, pos, imageurl): super(Player, self).__init__(pos, imageurl) self.max_health = 20 self.health = 18 self.max_speed = 0.25 self.acceleration = 0.01 #fiddle with this until it seems good self.inventory = Inventory(5, 10) self.selected_slot = 0 #Temp items for testing self.inventory.insert(ItemStack.itemstack_from_name("magicStaff")) self.inventory.insert(ItemStack.itemstack_from_name("pickaxe")) def update(self, world): old_chunk = Convert.world_to_chunk(self.pos[0])[1] hspeed = min(abs(self.vel[0] + self.acceleration * self.dir[0]), self.max_speed) * self.dir[0] vspeed = min(abs(self.vel[1] + self.acceleration * self.dir[1]), self.max_speed) * self.dir[1] self.vel = [hspeed, vspeed] super(Player, self).update(world) new_chunk = Convert.world_to_chunk(self.pos[0])[1] if new_chunk != old_chunk: world.load_chunks(new_chunk) entities = self.get_nearby_entities(world) for entity in entities: if(self.bounding_box.colliderect(entity.bounding_box)): if isinstance(entity, ItemDrop): if self.inventory.insert(entity.get_itemstack()) == None: world.loaded_chunks.get(entity.get_chunk()).entities.remove(entity) def get_nearby_entities(self, world): entities = list(world.loaded_chunks.get(Convert.world_to_chunk(self.pos[0])[1]).entities) entities += world.loaded_chunks.get(Convert.world_to_chunk(self.pos[0])[1] - 1).entities entities += world.loaded_chunks.get(Convert.world_to_chunk(self.pos[0])[1] + 1).entities return entities def right_click_continuous(self, world, mouse_pos, viewport, background): item = self.inventory[0][self.selected_slot] block_pos = self.find_angle_pos(mouse_pos, viewport) if item is None: return item.use_continuous(world, self, mouse_pos, viewport) if item.can_place: #try to place the block #don't want to place a solid block over an entity if not background: entities = self.get_nearby_entities(world) entities.append(self) #check against player too for entity in entities: if entity.collides(block_pos) and entity.background == background and World.get_block(item.name)["solid"]: return if world.get_block_at(block_pos, False) == "water" and \ (not background or world.get_block_at(block_pos, True) == "water"): world.set_block_at(block_pos, World.get_block(item.name), background) blockentity = item.data if blockentity is not None: blockentity.load_image() blockentity.set_pos(block_pos) blockentity.background = background world.create_entity(blockentity) item.count -= 1 if item.count == 0: self.inventory[0][self.selected_slot] = None def right_click_discrete(self, world, mouse_pos, viewport, background): item = self.inventory[0][self.selected_slot] block_pos = self.find_angle_pos(mouse_pos, viewport) entities = self.get_nearby_entities(world) for entity in entities: if entity.collides(block_pos) and entity.background == background: if entity.interact(self, item): return if item is None: return item.use_discrete(world, self, mouse_pos, viewport) def get_break_distance(self): #extend with certain items? return BREAK_DIST def find_angle(self, mouse_pos, viewport): #find nearest breakable block based on angle from player pos to mouse pos (raycasting?) x_diff = Convert.viewport_to_pixel(mouse_pos[0], viewport, 0) - self.bounding_box.centerx y_diff = Convert.viewport_to_pixel(mouse_pos[1], viewport, 1) - self.bounding_box.centery angle = math.atan2(y_diff, x_diff) return angle def find_pos(self, angle, offset, close_pos, max_dist): #in pixels dist = math.hypot(close_pos[0] - offset[0], close_pos[1] - offset[1]) capped_dist = min(dist, max_dist) return [offset[0] + capped_dist * math.cos(angle), offset[1] + capped_dist * math.sin(angle)] def find_angle_pos(self, mouse_pos, viewport): angle = self.find_angle(mouse_pos, viewport) return Convert.pixels_to_world(self.find_pos(angle, self.pixel_pos(True), Convert.viewport_to_pixels(mouse_pos, viewport), self.get_break_distance())) def break_block(self, world, mouse_pos, viewport, background): block_pos = self.find_angle_pos(mouse_pos, viewport) chunk = world.loaded_chunks.get(Convert.world_to_chunk(block_pos[0])[1]) #if there's a foreground block covering the background, don't break anything if background and world.get_block_at(block_pos, False) != "water": return block = World.get_block(world.get_block_at(block_pos, background)) held_item = self.inventory[0][self.selected_slot] if held_item is None: harvest_level = 0 break_speed = 1 else: harvest_level = held_item.get_harvest_level() break_speed = held_item.get_break_speed() if (not block["breakable"]) or (block["harvestlevel"] > harvest_level): return block_to_break = None breaking_blocks = world.breaking_blocks[background] for breaking_block in breaking_blocks: if breaking_block["pos"] == block_pos: block_to_break = breaking_block if block_to_break is None: block_to_break = {"pos": block_pos, "name": block["name"], "progress": 0, "breaktime": block["breaktime"]} breaking_blocks.append(block_to_break) block_to_break["progress"] += 2 * break_speed if block_to_break["progress"] >= block_to_break["breaktime"]: #remove the block breaking_blocks.remove(block_to_break) chunk.set_block_at(Convert.world_to_chunk(block_pos[0])[0], block_pos[1], World.get_block("water"), background) blockentity = None if block["entity"] != "": #remove the associated entity for entity in chunk.entities: if type(entity).__name__ == block["entity"] and [int(entity.pos[0]), int(entity.pos[1])] == block_pos: chunk.entities.remove(entity) blockentity = entity break chunk.entities.append(ItemDrop(block_pos, block["name"], block["image"], blockentity)) def get_color(self, background): if background: return (192, 192, 192, 128) else: return (255, 255, 255, 128) def render_break_preview(self, background, world, block, block_pos, screen, viewport): blockimg = world.get_block_render(World.get_block_id(block["name"]), block_pos, block["connectedTexture"], background, background).copy() mask = pygame.mask.from_surface(blockimg) olist = mask.outline() polysurface = pygame.Surface((Game.BLOCK_SIZE * Game.SCALE, Game.BLOCK_SIZE * Game.SCALE), pygame.SRCALPHA) color = self.get_color(background) pygame.draw.polygon(polysurface, color, olist, 0) screen.blit(polysurface, Convert.world_to_viewport(block_pos, viewport)) def render_block_preview(self, background, held_item, world, block_pos, screen, viewport): held_block = World.get_block(held_item.name) blockimg = world.get_block_render(World.get_block_id(held_block["name"]), block_pos, held_block["connectedTexture"], background, background).copy() mask = pygame.mask.from_surface(blockimg) olist = mask.outline() polysurface = pygame.Surface((Game.BLOCK_SIZE * Game.SCALE, Game.BLOCK_SIZE * Game.SCALE), pygame.SRCALPHA) screen.blit(polysurface, Convert.world_to_viewport(block_pos, viewport)) collides = False entities = self.get_nearby_entities(world) entities.append(self) for entity in entities: if entity.collides(block_pos) and entity.background == background: collides = True color = self.get_color(background) if collides and World.get_block(held_block["name"])["solid"]: color = (color[0], 0, 0, color[3]) pygame.draw.polygon(polysurface, color, olist, 0) blockimg.blit(polysurface, (0, 0), special_flags=pygame.BLEND_RGBA_MULT) screen.blit(blockimg, Convert.world_to_viewport(block_pos, viewport)) def draw_block_highlight(self, world, mouse_pos, viewport, screen, shift): #if player can break the block at the position, highlight it #if player is holding a block and can place it, render a preview block_pos = self.find_angle_pos(mouse_pos, viewport) held_item = self.inventory[0][self.selected_slot] if held_item is None: harvest_level = 0 else: harvest_level = held_item.get_harvest_level() block = World.get_block(world.get_block_at(block_pos, shift)) samewater = block["name"] == "water" fgwater = World.get_block(world.get_block_at(block_pos, False))["name"] == "water" if block["breakable"] and block["harvestlevel"] <= harvest_level and (not shift or fgwater): self.render_break_preview(shift, world, block, block_pos, screen, viewport) elif held_item is not None and held_item.can_place and samewater: self.render_block_preview(shift, held_item, world, block_pos, screen, viewport) def render(self, screen, pos): #TODO: fancy animations here screen.blit(self.img, pos) item = self.inventory[0][self.selected_slot] if item is not None: screen.blit(item.img, [pos[0] - (Game.BLOCK_SIZE * Game.SCALE * 5 / 8), pos[1] + (Game.BLOCK_SIZE * Game.SCALE / 16)]) def change_slot(self, direction): if direction: self.selected_slot += 1 if self.selected_slot >= len(self.inventory[0]): self.selected_slot -= len(self.inventory[0]) else: self.selected_slot -= 1 if self.selected_slot < 0: self.selected_slot += len(self.inventory[0])
class Play(object): def __init__(self): self._cache = [] self._deathanims = [] self._debugging = False if '-aabbdebug' in sys.argv: self._debugging = True self._startmap = 'ow8-8.map' if '-startm' in sys.argv: self._startmap = sys.argv[sys.argv.index('-startm')+1] self._starthearts = 3 if '-hearts' in sys.argv: self._starthearts = int(sys.argv[sys.argv.index('-hearts')+1]) random.seed() self._SCREENW=256 self._SCREENH=240 self._MAPW=256 self._MAPH=176 self._OFFSET=self._SCREENH-self._MAPH self._UBOUND = pygame.Rect(0, 0, self._MAPW, 8) self._RBOUND = pygame.Rect(self._MAPW, 0, 8, self._MAPH) self._BBOUND = pygame.Rect(0, self._MAPH, self._MAPW, 8) self._LBOUND = pygame.Rect(-8, 0, 8, self._MAPH) self._TEXTSPEED=4 self._sword = None self._haabb = pygame.Rect(0, Tile.HALF, Tile.SIZE, Tile.HALF) self._vaabb = pygame.Rect(2, Tile.HALF, Tile.SIZE-4, Tile.HALF) self._spelunking = 0 self._zoning = None self._zoom = 2 pygame.init() size = width, height = self._SCREENW*self._zoom, self._SCREENH*self._zoom self._screen = pygame.display.set_mode(size) linkpalette = (((0,0,0),(0,0,0)),((128,128,128),(200,76,12)),((192,192,192),(128,208,16)),((255,255,255),(252,152,56))) wss = Spritesheet(bmpres('weapons.bmp')) self._swordsprite = colorReplace(wss.image_at((0,0,8,16), colorkey=(0,0,0)), linkpalette) ssprite = self._swordsprite lssprite = pygame.transform.rotate(ssprite,90) self._swordsprites = {x:y for x,y in zip(DIRECTIONS, (ssprite, pygame.transform.flip(ssprite,False,True), lssprite, pygame.transform.flip(lssprite,True,False)))} self._lifetxt = Text.get('-LIFE-', (216,40,0)) self._btxt = Text.get('Z')[0] self._atxt = Text.get('X')[0] iss = Spritesheet(bmpres('icons.bmp')) heart = iss.image_at((0,0,8,8), colorkey=(0,0,0)) self._fullheart = colorReplace(heart, (((128,128,128), (216,40,0)),)) self._halfheart = colorReplace(iss.image_at((8,0,8,8), colorkey=(0,0,0)), (((128,128,128),(216,40,0)),((255,255,255),(255,227,171)))) self._emptyheart = colorReplace(heart, (((128,128,128),(255,227,171)),)) self._uibox = {} self._uibox['ul'] = colorReplace(iss.image_at((0,8,8,8), colorkey=(0,0,0)), (((128,128,128),(0,89,250)),)) self._uibox['v'] = colorReplace(iss.image_at((8,8,8,8), colorkey=(0,0,0)), (((128,128,128),(0,89,250)),)) self._uibox['h'] = pygame.transform.rotate(self._uibox['v'], 90) self._uibox['ur'] = pygame.transform.flip(self._uibox['ul'], True, False) self._uibox['br'] = pygame.transform.flip(self._uibox['ur'], False, True) self._uibox['bl'] = pygame.transform.flip(self._uibox['ul'], False, True) self._uirupee, self._uikey, self._uibomb = iss.images_at(((0,16,8,8), (8,16,8,8), (16,16,8,8)), colorkey=(0,0,0)) self._uirupee = colorReplace(self._uirupee, (((128,128,128),(255,161,68)),((255,255,255),(255,227,171)))) self._uikey = colorReplace(self._uikey, (((128,128,128),(255,161,68)),)) self._uibomb = colorReplace(self._uibomb, (((192,192,192),(0,89,250)),)) ss = Spritesheet(bmpres('link.bmp')) s = {} s[Direction.UP] = [colorReplace(sp, (((0,0,0),(0,0,0)),((128,128,128),(200,76,12)),((192,192,192),(128,208,16)),((255,255,255),(252,152,56)))) for sp in ss.images_at(((16,0,16,16),(16,16,16,16)), colorkey=(0,0,0))] s[Direction.DOWN] = [colorReplace(sp, (((0,0,0),(0,0,0)),((128,128,128),(200,76,12)),((192,192,192),(128,208,16)),((255,255,255),(252,152,56)))) for sp in ss.images_at(((0,0,16,16),(0,16,16,16)), colorkey=(0,0,0))] s[Direction.LEFT] = [colorReplace(sp, (((0,0,0),(0,0,0)),((128,128,128),(200,76,12)),((192,192,192),(128,208,16)),((255,255,255),(252,152,56)))) for sp in ss.images_at(((32,0,16,16),(32,16,16,16)), colorkey=(0,0,0))] atks = {} atks[Direction.UP] = colorReplace(ss.image_at((16,32,16,16), colorkey=(0,0,0)), linkpalette) atks[Direction.DOWN] = colorReplace(ss.image_at((0,32,16,16), colorkey=(0,0,0)), linkpalette) atks[Direction.LEFT] = colorReplace(ss.image_at((32,32,16,16), colorkey=(0,0,0)), linkpalette) self._pc = Actor(15*8,11*8,2,self._starthearts*16,8,self._vaabb,True,s,atksprites=atks) self._pc.sethitaabb(pygame.Rect(0,0,16,16)) self._pc.addtriumphs((colorReplace(ss.image_at((48,0,16,16), colorkey=(0,0,0)), linkpalette),colorReplace(ss.image_at((48,16,16,16), colorkey=(0,0,0)), linkpalette))) self._pcweapons = [] self._temps = [] self._startport = Portal(self._startmap, 15*8, 10*8, PortalType.Magic) self._start() def _getHeartCollectible(self): return parseCollectible(defres('collectibles.col'), 'heart') def _getRupeeCollectible(self): return parseCollectible(defres('collectibles.col'), 'rupee') def _getBlueRupeeCollectible(self): return parseCollectible(defres('collectibles.col'), 'brupee') def _start(self): self._pc.reset() self._currentmapname = self._startmap self._maps = {} self._maphistory = [self._startmap] self._inventory = Inventory() if '-mkey' in sys.argv: self._inventory.acquiremkey() if '-sword' in sys.argv: self._inventory.changesword(int(sys.argv[sys.argv.index('-sword')+1])) self._port(self._startport) @property def inventory(self): return self._inventory @property def _actors(self): return self._monsters + self._pcweapons + [self._pc] @property def _bounders(self): return [actor for actor in self._actors if actor.wallcollisions] @property def _updaters(self): return self._actors+self._decos+self._collectibles @property def _currentmap(self): return self._maps[self._currentmapname] @property def _tiles(self): return self._currentmap.tiles @_tiles.setter def _tiles(self, value): self._currentmap.tiles = value @property def _monsters(self): return self._currentmap.monsters @_monsters.setter def _monsters(self, value): self._currentmap.monsters = value @property def _decos(self): return self._currentmap.decorations @property def _portals(self): return self._currentmap.portals @property def _textlist(self): return self._currentmap.text @_textlist.setter def _textlist(self, value): self._currentmap.textlist = value @property def _collectibles(self): return self._currentmap.collectibles @_collectibles.setter def _collectibles(self, value): self._currentmap.collectibles = value def _loadmap(self, m): p = Parser(m) self._currentmapname = m if m in self._maps: self._maphistory.remove(m) else: self._maps[m] = p.parse() if len(self._maphistory) == 4: self._maphistory = self._maphistory[1:] self._maphistory.append(m) self._maps = {k: v for k, v in self._maps.items() if k in self._maphistory} g = globals() l = locals() self._tiles = [tile if eval(tile.condition) else tile.alt for tile in self._tiles] self._maskedTiles = [tile for tile in self._tiles if tile.mask] self._unmaskedTiles = [tile for tile in self._tiles if not tile.mask] self._collectibles = [coll for coll in self._collectibles if eval(coll.condition,g,l)] self._textlist = [text for text in self._textlist if eval(text.condition,g,l)] self._texttimer = 0 self._zonetimer = 0 self._texttimermax = len(self._textlist)*self._TEXTSPEED self._pc.stop() self._pc.loseControl(self._texttimermax) def setzoom(self, val): self._zoom = val size = width, height = self._SCREENW*self._zoom, self._SCREENH*self._zoom self._screen = pygame.display.set_mode(size) def _attacks(self): if self._pc.isAttacking and self._sword is None: atk = self._inventory.sword*16 sprite = {Direction.UP: [self._swordsprite]} w=3 l=11 if self._pc.direction == Direction.UP: x,y,r = self._pc.x+3, self._pc.y-1-l, pygame.Rect(2, 0, w, l) elif self._pc.direction == Direction.RIGHT: x,y,r = self._pc.x+12, self._pc.y+5, pygame.Rect(5, 3, l, w) elif self._pc.direction == Direction.DOWN: x,y,r = self._pc.x+5, self._pc.y+12, pygame.Rect(2, 5, w, l) else:# self._pc.direction == Direction.LEFT: x,y,r = self._pc.x-12, self._pc.y+5, pygame.Rect(0, 3, l, w) self._sword = Actor(x,y,0,0,atk,r,False,sprite) self._sword.direction = self._pc.direction self._pcweapons.append(self._sword) elif not self._pc.isAttacking and self._sword is not None: self._pcweapons.remove(self._sword) self._sword = None def _deaths(self): if self._pc.hp == 0: self._pc.heal(self._pc.maxhp) self._start() deads = [monster for monster in self._monsters if monster.hp == 0] self._monsters = [monster for monster in self._monsters if monster.hp > 0] for monster in deads: self._deathanims.append(type('DeathAnim', (), {'x': monster.x, 'y': monster.y, 't': 8})) @property def _porting(self): return self._spelunking != 0 or self._zoning != None def _timers(self): drops = [d for d in self._deathanims if d.t == 0] for d in drops: roll = random.randint(1,20) if roll > 10 and roll < 15: c = self._getHeartCollectible() elif roll > 14 and roll < 19: c = self._getRupeeCollectible() elif roll == 19: c = self._getBlueRupeeCollectible() elif roll == 20: c = None #print 'fairy' else: c = None if c is not None: c.x = d.x c.y = d.y self._collectibles.append(c) self._deathanims = [d for d in self._deathanims if d > 0] for d in self._deathanims: d.t -= 1 for temp in self._temps: temp[1] -= 1 self._temps = [[s,t] for [s,t] in self._temps if t > 0] if self._zonetimer > 0: self._zonetimer -= 1 else: self._zoning = None if self._texttimer < self._texttimermax: self._texttimer += 1 s = self._spelunking if s != 0: if self._cavetimer % 3 == 0: self._pc.y -= s if self._cavetimer > 0: self._cavetimer -= 1 self._pc.incframe() else: self._spelunking = 0 if s == -1: self._port(self._currentport) def _update(self): self._attacks() self._deaths() self._timers() [updater.update() for updater in self._updaters] self._input() self._physics() def _render(self): self._screen.fill((0,0,0)) if self._spelunking != 0: for tile in [tile for tile in self._tiles if tile.portal is not None]: self._screen.blit(self._getzoom(tile.img), ((tile.x)*self._zoom, (tile.y+self._OFFSET)*self._zoom)) self._screen.blit(self._getzoom(self._pc.sprite), ((self._pc.x)*self._zoom, (self._pc.y+self._OFFSET)*self._zoom)) for tile in [tile for tile in self._tiles if tile.portal is None]: self._screen.blit(self._getzoom(tile.img), ((tile.x)*self._zoom, (tile.y+self._OFFSET)*self._zoom)) for deco in self._decos: self._screen.blit(self._getzoom(deco.sprite), (deco.x*self._zoom, (deco.y+self._OFFSET)*self._zoom)) elif self._zoning is not None: if self._zoning == Direction.UP: dxo = 0 dxn = 0 dyo = 4*(44-self._zonetimer) dyn = -4*(self._zonetimer) if self._zoning == Direction.RIGHT: dxo = -4*(64-self._zonetimer) dxn = 4*self._zonetimer dyo = 0 dyn = 0 if self._zoning == Direction.DOWN: dxo = 0 dxn = 0 dyo = -4*(44-self._zonetimer) dyn = 4*(self._zonetimer) if self._zoning == Direction.LEFT: dxo = 4*(64-self._zonetimer) dxn = -4*self._zonetimer dyo = 0 dyn = 0 for tile in self._unmaskedTiles: self._screen.blit(self._getzoom(tile.img), ((tile.x+dxn)*self._zoom, (tile.y+dyn+self._OFFSET)*self._zoom)) for tile in [tile for tile in self._oldmap.tiles if not tile.mask]: self._screen.blit(self._getzoom(tile.img), ((tile.x+dxo)*self._zoom, (tile.y+dyo+self._OFFSET)*self._zoom)) self._screen.blit(self._getzoom(self._pc.sprite), ((self._pc.x)*self._zoom, (self._pc.y+self._OFFSET)*self._zoom)) for tile in self._maskedTiles: self._screen.blit(self._getzoom(tile.img), ((tile.x+dxn)*self._zoom, (tile.y+dyn+self._OFFSET)*self._zoom)) for tile in [tile for tile in self._oldmap.tiles if tile.mask]: self._screen.blit(self._getzoom(tile.img), ((tile.x+dxo)*self._zoom, (tile.y+dyo+self._OFFSET)*self._zoom)) else: for tile in self._unmaskedTiles: self._screen.blit(self._getzoom(tile.img), ((tile.x)*self._zoom, (tile.y+self._OFFSET)*self._zoom)) for deco in self._decos: self._screen.blit(self._getzoom(deco.sprite), (deco.x*self._zoom, (deco.y+self._OFFSET)*self._zoom)) for coll in self._collectibles: self._screen.blit(self._getzoom(coll.sprite), (coll.x*self._zoom, (coll.y+self._OFFSET)*self._zoom)) for tile in self._textlist[:self._texttimer/self._TEXTSPEED]: self._screen.blit(self._getzoom(tile.img), (tile.x*self._zoom, (tile.y+self._OFFSET)*self._zoom)) if self._debugging: self._renderaabbdebug() for actor in self._actors: self._screen.blit(self._getzoom(actor.sprite), ((actor.x)*self._zoom, (actor.y+self._OFFSET)*self._zoom)) for [s,t] in self._temps: self._screen.blit(self._getzoom(s.img), ((s.x)*self._zoom, (s.y+self._OFFSET)*self._zoom)) for tile in self._maskedTiles: self._screen.blit(self._getzoom(tile.img), ((tile.x)*self._zoom, (tile.y+self._OFFSET)*self._zoom)) self._renderui() pygame.display.flip() def _renderaabbdebug(self): for aabb in [actor.hitaabb for actor in self._actors]: r = self._getzoom(pygame.Surface((aabb.w, aabb.h))) r.fill((255,255,0)) self._screen.blit(r, (aabb.x*self._zoom, (aabb.y+self._OFFSET)*self._zoom)) for aabb in [actor.collaabb for actor in self._actors]: r = self._getzoom(pygame.Surface((aabb.w, aabb.h))) r.fill((255,0,255)) self._screen.blit(r, (aabb.x*self._zoom, (aabb.y+self._OFFSET)*self._zoom)) for aabb in [coll.aabb for coll in self._collectibles]: r = self._getzoom(pygame.Surface((aabb.w, aabb.h))) r.fill((255,0,255)) self._screen.blit(r, (aabb.x*self._zoom, (aabb.y+self._OFFSET)*self._zoom)) def _renderui(self): black = pygame.Surface((256,64)) self._screen.blit(self._getzoom(black), (0,0)) for i in range(len(self._lifetxt)): self._screen.blit(self._getzoom(self._lifetxt[i]), ((23+i)*8*self._zoom, 16*self._zoom)) self._screen.blit(self._getzoom(self._atxt), ((19)*8*self._zoom, 16*self._zoom)) self._screen.blit(self._getzoom(self._btxt), ((16)*8*self._zoom, 16*self._zoom)) ul = self._getzoom(self._uibox['ul']) ur = self._getzoom(self._uibox['ur']) br = self._getzoom(self._uibox['br']) bl = self._getzoom(self._uibox['bl']) v = self._getzoom(self._uibox['v']) h = self._getzoom(self._uibox['h']) for i in range(2): self._screen.blit(ul, ((3*i+15)*8*self._zoom, 2*8*self._zoom)) self._screen.blit(ur, ((3*i+17)*8*self._zoom, 2*8*self._zoom)) self._screen.blit(br, ((3*i+17)*8*self._zoom, 5*8*self._zoom)) self._screen.blit(bl, ((3*i+15)*8*self._zoom, 5*8*self._zoom)) self._screen.blit(h, ((3*i+16)*8*self._zoom, 5*8*self._zoom)) for j in range(4): self._screen.blit(v, ((3*i+2*(j%2)+15)*8*self._zoom, (j/2+3)*8*self._zoom)) if self._inventory.sword > 0: self._screen.blit(self._getzoom(self._swordsprite), (19*8*self._zoom, 3*8*self._zoom)) self._screen.blit(self._getzoom(self._uirupee), (11*8*self._zoom, 2*8*self._zoom)) self._screen.blit(self._getzoom(self._uikey), (11*8*self._zoom, 4*8*self._zoom)) self._screen.blit(self._getzoom(self._uibomb), (11*8*self._zoom, 5*8*self._zoom)) rupees = Text.get(('X' if self._inventory.rupees < 100 else '')+str(self._inventory.rupees)) for i in range(len(rupees)): self._screen.blit(self._getzoom(rupees[i]), ((i+12)*8*self._zoom,(2)*8*self._zoom)) keys = Text.get('X'+self._inventory.keystr) for i in range(len(keys)): self._screen.blit(self._getzoom(keys[i]), ((i+12)*8*self._zoom,(4)*8*self._zoom)) bombs = Text.get('X'+str(self._inventory.bombs)) for i in range(len(bombs)): self._screen.blit(self._getzoom(bombs[i]), ((i+12)*8*self._zoom,(5)*8*self._zoom)) maprect = pygame.Surface((8*8, 8*4)) maprect.fill((100,100,100)) self._screen.blit(self._getzoom(maprect), (2*8*self._zoom, 2*8*self._zoom)) for i in range(self._pc.maxhp/16): heart = self._fullheart if self._pc.hp > i*16 and self._pc.hp <= i*16+8: heart = self._halfheart elif self._pc.hp <= i*16: heart = self._emptyheart self._screen.blit(self._getzoom(heart), ((22+i%8)*8*self._zoom, (6-i/8)*8*self._zoom)) def _getzoom(self, surf): return pygame.transform.scale(surf, (surf.get_width()*self._zoom, surf.get_height()*self._zoom)) def _input(self): keys = pygame.key.get_pressed() if keys[pygame.K_1]: self.setzoom(1) if keys[pygame.K_2]: self.setzoom(2) if keys[pygame.K_3]: self.setzoom(3) if keys[pygame.K_4]: self.setzoom(4) if self._pc.isControllable: dx = 0 dy = 0 if keys[pygame.K_UP] or keys[pygame.K_DOWN] or keys[pygame.K_LEFT] or keys[pygame.K_RIGHT]: self._pc.incframe() if keys[pygame.K_DOWN] or keys[pygame.K_UP]: if keys[pygame.K_DOWN]: if self._pc.x % 8 == 0: dy += self._pc.speed self._pc.direction = Direction.DOWN self._pc.setcollaabb(self._vaabb) elif self._pc.direction == Direction.LEFT: dx -= self._pc.speed elif self._pc.direction == Direction.RIGHT: dx += self._pc.speed if keys[pygame.K_UP]: if self._pc.x % 8 == 0: dy -= self._pc.speed self._pc.direction = Direction.UP self._pc.setcollaabb(self._vaabb) elif self._pc.direction == Direction.LEFT: dx -= self._pc.speed elif self._pc.direction == Direction.RIGHT: dx += self._pc.speed else: if keys[pygame.K_LEFT]: if self._pc.y % 8 == 0: dx -= self._pc.speed self._pc.direction = Direction.LEFT self._pc.setcollaabb(self._haabb) elif self._pc.direction == Direction.UP: dy -= self._pc.speed elif self._pc.direction == Direction.DOWN: dy += self._pc.speed if keys[pygame.K_RIGHT]: if self._pc.y % 8 == 0: dx += self._pc.speed self._pc.direction = Direction.RIGHT self._pc.setcollaabb(self._haabb) elif self._pc.direction == Direction.UP: dy -= self._pc.speed elif self._pc.direction == Direction.DOWN: dy += self._pc.speed self._pc.dx = dx self._pc.dy = dy if keys[pygame.K_x]: if self._pc.canAttack and self._inventory.sword > 0: self._pc.doAttack(8) self._pc.loseControl(8) self._pc.stop() else: self._pc.releaseAttack() for monster in self._monsters: monster.incframe() if monster.isControllable: if monster.ai == 'random': if random.randint(1,20) == 20: dx = 0 dy = 0 if (monster.dx != 0 and monster.x % 8 == 0) or (monster.dy != 0 and monster.y % 8 == 0) or (monster.dx == 0 and monster.dy == 0): d = (None, Direction.UP, Direction.DOWN, Direction.LEFT, Direction.RIGHT)[random.randint(0,4)] if d is not None: monster.direction = d if d == Direction.UP: dy -= monster.speed if d == Direction.DOWN: dy += monster.speed if d == Direction.LEFT: dx -= monster.speed if d == Direction.RIGHT: dx += monster.speed monster.dx = dx monster.dy = dy def _physics(self): if not self._porting: for actor in self._bounders: d = None if actor.collaabb.colliderect(self._UBOUND): d = Direction.UP actor.y = self._UBOUND.y+self._UBOUND.h-actor.collyoffset if actor.collaabb.colliderect(self._RBOUND): d = Direction.RIGHT actor.x = self._RBOUND.x-actor.collaabb.w-actor.collxoffset if actor.collaabb.colliderect(self._BBOUND): d = Direction.DOWN actor.y = self._BBOUND.y-actor.collaabb.h-actor.collyoffset if actor.collaabb.colliderect(self._LBOUND): d = Direction.LEFT actor.x = self._LBOUND.x+self._LBOUND.w-actor.collxoffset if d is not None and self._portals[d] is not None and actor is self._pc: if self._portals[d].type == PortalType.CaveExit: self._spelunking = 1 self._cavetimer = 47 self._pc.loseControl(47) self._port(self._portals[d]) elif self._portals[d] is not None: self._zone(d) else: colls = [] actor.x += actor.dx for tile in self._tiles: for wall in tile.aabbs: if actor.collaabb.colliderect(wall): colls.append(tile) if actor.dx < 0: actor.x = wall.x+wall.w-actor.collxoffset else: actor.x = wall.x-actor.collaabb.w-actor.collxoffset actor.y += actor.dy for tile in self._tiles: for wall in tile.aabbs: if actor.collaabb.colliderect(wall): colls.append(tile) if actor.dy < 0: actor.y = wall.y+wall.h-actor.collyoffset else: actor.y = wall.y-actor.collaabb.h-actor.collyoffset if actor is self._pc and tile.isPortal: if tile.portal.type == PortalType.CaveEntrance: self._spelunking = -1 self._currentport = tile.portal self._cavetimer = 47 self._pc.loseControl(47) for tile in colls: for wall in tile.aabbs: if actor is self._pc and tile.action is not None: exec tile.action if not self._porting: for monster in self._monsters: for weapon in self._pcweapons: if monster.hitaabb.colliderect(weapon.hitaabb) and not monster.isInvincible: monster.hurt(weapon.attack) monster.becomeInvincible(30) monster.loseControl(8) monster.stop() speed = self._pc.speed*2 if self._pc.direction == Direction.UP: monster.dy = -speed if self._pc.direction == Direction.DOWN: monster.dy = speed if self._pc.direction == Direction.LEFT: monster.dx = -speed if self._pc.direction == Direction.RIGHT: monster.dx = speed if self._pc.hitaabb.colliderect(monster.hitaabb) and not self._pc.isInvincible: self._pc.hurt(monster.attack) self._pc.becomeInvincible(30) self._pc.loseControl(8) self._pc.stop() if not self._pc.isAttacking: speed = self._pc.speed*2 if monster.direction == Direction.UP: self._pc.dy = -speed if monster.direction == Direction.DOWN: self._pc.dy = speed if monster.direction == Direction.LEFT: self._pc.dx = -speed if monster.direction == Direction.RIGHT: self._pc.dx = speed removes = [] for collectible in self._collectibles: for actor in [actor for actor in [self._pc]+self._pcweapons]: if collectible.aabb.colliderect(actor.collaabb): exec collectible.action removes.append(collectible) if collectible.triumph: self._pc.x = collectible.x-(collectible.x%8) self._pc.y = collectible.y+(-collectible.y%8) self._pc.triumph(48) self._temps.append([Tile.Tile(self._pc.x,self._pc.y-16,collectible.sprite),48]) self._collectibles = [c for c in self._collectibles if c not in removes] elif self._zoning is not None: self._pc.incframe() if self._zoning == Direction.UP: self._pc.y += 4 if self._pc.collaabb.colliderect(self._BBOUND): self._pc.y = self._BBOUND.y-self._pc.collaabb.h-self._pc.collyoffset if self._zoning == Direction.RIGHT: self._pc.x -= 4 if self._pc.collaabb.colliderect(self._LBOUND): self._pc.x = self._LBOUND.x+self._LBOUND.w-self._pc.collxoffset if self._zoning == Direction.DOWN: self._pc.y -= 4 if self._pc.collaabb.colliderect(self._UBOUND): self._pc.y = self._UBOUND.y+self._UBOUND.h-self._pc.collyoffset if self._zoning == Direction.LEFT: self._pc.x += 4 if self._pc.collaabb.colliderect(self._RBOUND): self._pc.x = self._RBOUND.x-self._pc.collaabb.w-self._pc.collxoffset def _zone(self, direction): if self._portals[direction] is None: return self._zoning = direction self._oldmap = self._currentmap self._loadmap(mapres(self._portals[direction].destfile)) if direction == Direction.UP or direction == Direction.DOWN: n = 44 else: n = 64 self._pc.loseControl(n) self._zonetimer = n def _port(self, portal): self._currentport = None self._loadmap(mapres(portal.destfile)) if portal.destx != -1: self._pc.x = portal.destx if portal.desty != -1: self._pc.y = portal.desty
class Family: def __init__(self, name): # does not try loading a family if name is not passed # ONLY do this during family creation if not name: return path = os.path.join("data", "actors", "families", name) familyini = Configuration(os.path.join("..", path, "family.ini")).family # family's last name, all members of the family will have this last name self.name = name # all the members in your party path = os.path.join("..", path) members = [n.split("/")[-1] for n in glob.glob(os.path.join(path, "*.ini"))] exclude = ["family.ini", "bestiary.ini", "inventory.ini"] for item in exclude: if item in members: members.remove(item) self.members = [Character(self, n.replace(".ini", "")) for n in members] # the party used in battle is the first 3 members you have ordered if len(self.members) >= 3: self.party = Party(self.members[0:3]) # party should only be 0 during character creation elif len(self.members) == 0: self.party = None else: self.party = Party(self.members[0 : len(self.members)]) # the items your family has self.inventory = Inventory(self) print self.inventory # amount of money your family possesses self.gold = familyini.__getattr__("gold", int) # gameplay difficulty (0 - easy, 1- normal, 2 - hard) self.difficulty = familyini.__getattr__("difficulty", int) # family bestiary self.bestiary = Bestiary(self) # creates a new family .ini # by default a family starts with 100 gold and five potions and 1 ether def create(self, name, difficulty, gold=100): path = os.path.join("..", "data", "actors", "families", name) if not os.path.exists(path): os.mkdir(path) Configuration(os.path.join(path, "family.ini")).save() familyini = Configuration(os.path.join(path, "family.ini")) familyini.family.__setattr__("difficulty", difficulty) familyini.family.__setattr__("gold", int(gold)) familyini.save() # this updates the family's .ini file def update(self): self.create(self.name, self.difficulty, self.gold) self.inventory.update() self.bestiary.update() def refresh(self): self.__init__(self.name)
def setup(self): self.inventory = Inventory()
class Hero(Entity): def __init__(self): self.heroRace = Race() self.heroClass = "" #Получаем Данные от пользователя self.getName() self.getClass() self.getRace() super().__init__(self.name,self.heroRace.stats,Elements(),0) ## Инвентарь героя self.inventory = Inventory() ## Обмундирование героя self.equipment = Equipment() ## Карман с Лечебками героя self.potionsPocket = PotionsPocket() ## Получает имя Персонажа def getName(self): #TODO! Не получать пустую строку , и чтобы ввод был норм. while True: self.name = input("Input you name:") if self.name: # Если что-то было введено - прекратить цикл break ## Получает Рассу def getRace(self): #Получаем Расу self.heroRace = utils.getChoice("Choose your Race:",races) #TODOlater Сделать вывод по горизонтали ## Получает Класс def getClass(self): #TODO Сдлеать сразу содание класса, при выборе одного из классов(вызывается создание класса) http://stackoverflow.com/questions/8141165/how-to-dynamically-select-a-method-call-in-python self.heroClass = utils.getChoice("Choose Your Class:",[ "Warrior", "Ranger", "Mage" ]) ## Выводит полный перечень Того что есть у Персонажа: ## Уровень Опыт Класс Рассу ## Статистики (stats, hp, mp, money) ## Урон ## Вещи в inventory (инвентаре) ## Вещи в equipment (обмундировании) ## Лечебки в potionsPocket ## Резисты Персонажа ## Квесты в QuestJournal ## Заклинания в SpellBook def showStats(self): #TODO showStats() в hero делать с переносом на новую строку при выводе каждого объекта. При этом с использованием \n и дальше на новой строке код # -Level exp # +Race Class # +Stats # +Damage # +inventory # +equipment # +potionsPocket # +resists # -questJournal # -spellbook # pass ## восстанавливает hp и mp def heal(self): self.stats.hp = self.stats.maxHp self.stats.mp = self.stats.maxMp ## Кастует Заклинание def castSpell(self, spell): #TODOlater Сделать когда будет готов класс Spell и SpellBook pass #TODO Переименовать на action? или еще что-то def castSpellChoice(self, hero, enemies): pass def usePotionChoice(self, hero, enemies): choosedPotion = utils.getChoice("What potion to use?", self.potionsPocket.items(), cancel=True) if choosedPotion: # Если было выбрано одно из зелий self.use(choosedPotion) else: #TODO! Выбрали отмену return False #вызывает simpleAttack для выбранного монстра def attackChoice(self, hero, enemies): if len(enemies) > 1: choosedEnemy = utils.getChoice("Choose your target:", enemies, cancel=True) if choosedEnemy == 0: #TODO! Выбрана отмена return False else: # Если один противник - его бьёт автоматически choosedEnemy = enemies[0] self.simpleAttack(choosedEnemy) def doTurn(self, hero, enemies): availableBattleChoices = self.getAvailableBattleChoices() selectedBattleChoice = utils.getChoice("What would you do?", list(availableBattleChoices.keys())) availableBattleChoices[selectedBattleChoice](hero, enemies) ## Возвращает Словарь с возможными вариантами хода и методом за них отвечающим def getAvailableBattleChoices(self): battleChoices = {} # Simple attack is always available battleChoices["Attack with \"{0}\"".format(self.equipment.weapon())] = self.attackChoice #if not self.spellBook.isEmpty(): # battleChoices["Cast Spell"] = self.castSpellChoice if not self.potionsPocket.isEmpty(): battleChoices["Use Potion"] = self.usePotionChoice return battleChoices ## Одевает item в equipment и убирает из inventory def equip(self, item): if self.equipment.equipment[item.piece] != "empty":#if there is an item self.unequip(self.equipment.equipment[item.piece]) #now the slot is empty self.equipment.equipment[item.piece]=item #Если вещь в инвентаре - убрать её оттуда self.inventory.removeItem(item) #give items Stats bonus and damage/defence self.stats.addStats(item.bonusStats) if item.isWeapon(): self.stats.damage.addDamage(item.damage) if item.isArmor(): self.defence+=item.defence #Think Нужен ли equipList() - который будет просто вызывать equip для каждой вещи ## Снимает item из equipment и кладёт в inventory def unequip(self, item): #remove Stats that this item added self.stats.removeStats(self.equipment.equipment[item.piece].bonusStats) if item.isWeapon(): self.stats.damage.removeDamage(item.damage) if item.isArmor(): self.defence-=item.defence #add it to inventory self.inventory.addItem(self.equipment.equipment[item.piece]) #make this slot empty self.equipment.equipment[item.piece] = "empty" ## Использует вещь на героя (например Зелье) def use(self, item): item.use(self) ## Возвращает true Если герой может использовать это (Spell, weapon, armor и т.п.) def canUse(self, object): return object.canUse(hero) def __str__(self): #return '"{0}" Health: {1}/{2} Mana: {3}/{4} {5} Defence: {6}'.format(self.name,self.hp,self.maxHp,self.mp,self.maxMp,self.stats.damage,self.defence) return '"{0}" Health: {1.hp}/{1.maxHp} Mana: {1.mp}/{1.maxMp} {1.damage} Defence: {2}'.format(self.name, self.stats, self.defence)
class Player(EntityLiving): def __init__(self, pos, options): self.hair_color = options[0] self.hair_length = options[1] self.body_color = options[2] self.tail_color = options[3] super().__init__(pos, "", 20) self.max_speed = 0.25 self.acceleration = 0.01 self.inventory = Inventory(5, 10) self.selected_slot = 0 self.anim_timer = 0 self.anim_frame = False self.anim_state = 0 self.anim_dir = 0 #Temp items for testing self.inventory.insert(ItemStack.itemstack_from_name("magicStaff")) self.inventory.insert(ItemStack.itemstack_from_name("pickaxe")) self.inventory.insert(ItemStack.itemstack_from_name("sword")) def load_images_for(self, directory): img_idle_l = Images.load_imageurl("img/player/" + directory + "/idle.png") img_idle_r = Images.flip_horizontal(img_idle_l) imgs_idle = (img_idle_l, img_idle_r) img_swim_1_l = Images.load_imageurl("img/player/" + directory + "/swim1.png") img_swim_1_u = Images.rotate(img_swim_1_l, -90) img_swim_1_r = Images.flip_horizontal(img_swim_1_l) img_swim_1_d = Images.rotate(img_swim_1_l, 90) imgs_swim_1 = (img_swim_1_l, img_swim_1_u, img_swim_1_r, img_swim_1_d) img_swim_2_l = Images.load_imageurl("img/player/" + directory + "/swim2.png") img_swim_2_u = Images.rotate(img_swim_2_l, -90) img_swim_2_r = Images.flip_horizontal(img_swim_2_l) img_swim_2_d = Images.rotate(img_swim_2_l, 90) imgs_swim_2 = (img_swim_2_l, img_swim_2_u, img_swim_2_r, img_swim_2_d) return (imgs_idle, imgs_swim_1, imgs_swim_2) def load_image(self): self.hair_images = self.load_images_for("hair/" + HAIR_COLORS[self.hair_color] + "/" + HAIR_LENGTHS[self.hair_length]) self.body_images = self.load_images_for("body/" + BODY_COLORS[self.body_color]) self.tail_images = self.load_images_for("tail/" + TAIL_COLORS[self.tail_color]) self.img = self.body_images[0][0] self.hair_img = self.hair_images[0][0] self.tail_img = self.tail_images[0][0] def update(self, world): old_chunk = self.get_chunk() hspeed = min(abs(self.vel[0] + self.acceleration * self.move_dir[0]), self.max_speed) * self.move_dir[0] vspeed = min(abs(self.vel[1] + self.acceleration * self.move_dir[1]), self.max_speed) * self.move_dir[1] self.vel = [hspeed, vspeed] super().update(world) self.update_image(world) #should this be before the super update? new_chunk = self.get_chunk() if new_chunk != old_chunk: world.load_chunks(new_chunk) def transition_to_anim_state(self, anim_state, world): self.transition_to_anim(anim_state, self.anim_dir, world) def transition_to_anim_dir(self, anim_dir, world): if self.anim_state == 0: #this isn't right- we want to go to anim_state 1 or 2 print("CLIPPY") anim_dir = anim_dir // 2 self.transition_to_anim(self.anim_state, anim_dir, world) def transition_to_anim(self, anim_state, anim_dir, world): new_img = self.body_images[anim_state][anim_dir] new_width = new_img.get_width() new_height = new_img.get_height() old_pos = [self.pos[0], self.pos[1]] old_width = self.bounding_box.width old_height = self.bounding_box.height self.bounding_box.width = new_width self.bounding_box.height = new_height width_shift = (new_width - old_width) / Game.BLOCK_SIZE / Game.SCALE height_shift = (new_height - old_height) / Game.BLOCK_SIZE / Game.SCALE #try aligning to each corner #top left if not self.check_collisions(world): self.set_anim(anim_state, anim_dir, new_img) return True """ #top right self.update_pos([self.pos[0] + width_shift, self.pos[1]]) if not self.check_collisions(world): self.set_anim(anim_state, anim_dir, new_img) return True #bottom left self.update_pos([self.pos[0], self.pos[1] + height_shift]) if not self.check_collisions(world): self.set_anim(anim_state, anim_dir, new_img) return True #bottom right self.update_pos([self.pos[0] + width_shift, self.pos[1] + height_shift]) if not self.check_collisions(world): self.set_anim(anim_state, anim_dir, new_img) return True """ #transition failed- don't change anything self.update_pos(old_pos) self.bounding_box.width = old_width self.bounding_box.height = old_height #print("FAIL", old_height, new_height, anim_state, anim_dir, self.anim_state, self.anim_dir) return False def set_anim(self, anim_state, anim_dir, new_img): #succeeded- actually set the animation self.anim_state = anim_state self.anim_dir = anim_dir if self.anim_state == 0: self.anim_timer = 0 def update_anim_timer(self, moving, world): max_time = ANIM_TIME_MOVING if moving else ANIM_TIME_STOPPED self.anim_timer += 1 if self.anim_timer >= max_time: self.anim_timer = 0 self.anim_frame = not self.anim_frame if self.anim_frame: self.transition_to_anim_state(2, world) else: self.transition_to_anim_state(1, world) def update_image(self, world): xvel = Game.cutoff(self.vel[0], 0.01) yvel = Game.cutoff(self.vel[1], 0.01) if xvel != 0 or yvel != 0: self.update_anim_timer(True, world) if xvel < 0: self.transition_to_anim_dir(0, world) elif xvel > 0: self.transition_to_anim_dir(2, world) elif yvel < 0: self.transition_to_anim_dir(1, world) elif yvel > 0: self.transition_to_anim_dir(3, world) else: if self.facing == Game.LEFT: anim_dir = 0 else: anim_dir = 1 self.transition_to_anim(0, anim_dir, world) if self.anim_state != 0: self.update_anim_timer(False, world) self.img = self.body_images[self.anim_state][self.anim_dir] self.hair_img = self.hair_images[self.anim_state][self.anim_dir] self.tail_img = self.tail_images[self.anim_state][self.anim_dir] def render(self, screen, pos): screen.blit(self.tail_img, pos) super().render(screen, pos) screen.blit(self.hair_img, pos) if self.attack is None: item = self.get_held_item() if item is not None: self.render_held_item(screen, pos, item) else: self.attack.render_actual(screen) def render_held_item(self, screen, pos, item): #calculate position of held item in player's hand based on animation state # as well as whether it's a placeable block if self.anim_state == 0: offset_y = Game.BLOCK_SIZE * Game.SCALE * 1 / 16 if self.anim_dir == 0: #left offset_x = Game.BLOCK_SIZE * Game.SCALE * -12 / 16 if item.can_place: offset_x += Game.BLOCK_SIZE * Game.SCALE * 2 / 16 else: img = item.imgs[0] else: #right offset_x = Game.BLOCK_SIZE * Game.SCALE * 20 / 16 if item.can_place: offset_x += Game.BLOCK_SIZE * Game.SCALE * -2 / 16 else: img = item.imgs[1] else: if self.anim_dir == 0: #left offset_x = Game.BLOCK_SIZE * Game.SCALE * 0 / 16 offset_y = Game.BLOCK_SIZE * Game.SCALE * 12 / 16 if self.anim_state == 2: offset_x += Game.BLOCK_SIZE * Game.SCALE * 1 / 16 if item.can_place: offset_y += Game.BLOCK_SIZE * Game.SCALE * -2 / 16 else: img = item.imgs[2] elif self.anim_dir == 1: #up offset_x = Game.BLOCK_SIZE * Game.SCALE * -12 / 16 offset_y = Game.BLOCK_SIZE * Game.SCALE * 0 / 16 if self.anim_state == 2: offset_y += Game.BLOCK_SIZE * Game.SCALE * 1 / 16 if item.can_place: offset_x += Game.BLOCK_SIZE * Game.SCALE * 2 / 16 else: img = item.imgs[0] elif self.anim_dir == 2: #right offset_x = Game.BLOCK_SIZE * Game.SCALE * 27 / 16 offset_y = Game.BLOCK_SIZE * Game.SCALE * 12 / 16 if self.anim_state == 2: offset_x -= Game.BLOCK_SIZE * Game.SCALE * 1 / 16 if item.can_place: offset_y += Game.BLOCK_SIZE * Game.SCALE * -2 / 16 else: img = item.imgs[3] else: #down offset_x = Game.BLOCK_SIZE * Game.SCALE * 12 / 16 offset_y = Game.BLOCK_SIZE * Game.SCALE * 27 / 16 if self.anim_state == 2: offset_y -= Game.BLOCK_SIZE * Game.SCALE * 1 / 16 if item.can_place: offset_x += Game.BLOCK_SIZE * Game.SCALE * -2 / 16 else: img = item.imgs[4] if item.can_place: img = item.imgs[0] offset_x += Game.BLOCK_SIZE * Game.SCALE * 1 / 4 offset_y += Game.BLOCK_SIZE * Game.SCALE * 1 / 4 screen.blit(img, [pos[0] + offset_x, pos[1] + offset_y]) def collide_with(self, entity, world): super().collide_with(entity, world) if isinstance(entity, ItemDrop): if self.inventory.insert(entity.get_itemstack()) == None: world.remove_entity(entity) def left_click_continuous(self, world, mouse_pos, viewport, background): self.break_block(world, pygame.mouse.get_pos(), viewport, background) self.do_attack(world, mouse_pos, viewport) def right_click_continuous(self, world, mouse_pos, viewport, background): item = self.get_held_item() block_pos = self.find_angle_pos(mouse_pos, viewport) if item is None: return item.use_continuous(world, self, mouse_pos, viewport) if item.can_place: #try to place the block #don't want to place a solid block over an entity if not background: entities = world.get_nearby_entities(self.get_chunk()) entities.append(self) #check against player too for entity in entities: if entity.collides(block_pos) and entity.background == background and World.get_block(item.name)["solid"]: return if world.get_block_at(block_pos, False) == "water" and \ (not background or world.get_block_at(block_pos, True) == "water"): world.set_block_at(block_pos, World.get_block(item.name), background) blockentity = item.data if blockentity is not None: blockentity.load_image() blockentity.set_pos(block_pos) blockentity.background = background world.create_entity(blockentity) self.remove_held_item() def right_click_discrete(self, world, mouse_pos, viewport, background): item = self.get_held_item() block_pos = self.find_angle_pos(mouse_pos, viewport) entities = world.get_nearby_entities(self.get_chunk()) for entity in entities: if entity.collides(block_pos) and entity.background == background: if entity.interact(self, item): return if item is None: return item.use_discrete(world, self, mouse_pos, viewport) def left_click_discrete(self, world, mouse_pos, viewport, background): pass def do_attack(self, world, mouse_pos, viewport): if self.attack is not None: return held_item = self.get_held_item() if held_item is not None: damage = held_item.get_attack_damage() knockback = held_item.get_knockback() reach = ent.DamageSourceSweep.DEFAULT_REACH #TODO else: damage = ent.DamageSource.DEFAULT_ATTACK knockback = ent.DamageSource.DEFAULT_KNOCKBACK reach = ent.DamageSourceSweep.DEFAULT_REACH pos = self.pos[:] angle = self.find_angle(mouse_pos, viewport) self.attack = DamageSourceSweep(pos, damage, knockback, reach, angle, held_item, self, 30) world.create_entity(self.attack) def get_held_item(self): return self.inventory[0][self.selected_slot] def remove_held_item(self): item = self.get_held_item() item.count -= 1 if item.count == 0: self.inventory[0][self.selected_slot] = None def get_break_distance(self): #extend with certain items? return BREAK_DIST def find_angle(self, mouse_pos, viewport): #find nearest breakable block based on angle from player pos to mouse pos (raycasting?) x_diff = Convert.viewport_to_pixel(mouse_pos[0], viewport, 0) - self.bounding_box.centerx y_diff = Convert.viewport_to_pixel(mouse_pos[1], viewport, 1) - self.bounding_box.centery angle = math.atan2(y_diff, x_diff) return angle def find_pos(self, angle, offset, close_pos, max_dist): #in pixels dist = math.hypot(close_pos[0] - offset[0], close_pos[1] - offset[1]) capped_dist = min(dist, max_dist) return [offset[0] + capped_dist * math.cos(angle), offset[1] + capped_dist * math.sin(angle)] def find_angle_pos(self, mouse_pos, viewport): angle = self.find_angle(mouse_pos, viewport) return Convert.pixels_to_world(self.find_pos(angle, self.pixel_pos(True), Convert.viewport_to_pixels(mouse_pos, viewport), self.get_break_distance())) def break_block(self, world, mouse_pos, viewport, background): block_pos = self.find_angle_pos(mouse_pos, viewport) chunk = world.loaded_chunks.get(Convert.world_to_chunk(block_pos[0])[1]) #if there's a foreground block covering the background, don't break anything if background and world.get_block_at(block_pos, False) != "water": return block = World.get_block(world.get_block_at(block_pos, background)) held_item = self.get_held_item() if held_item is None: harvest_level = 0 break_speed = 1 else: harvest_level = held_item.get_harvest_level() break_speed = held_item.get_break_speed() if (not block["breakable"]) or (block["harvestlevel"] > harvest_level): return block_to_break = None breaking_blocks = world.breaking_blocks[background] for breaking_block in breaking_blocks: if breaking_block["pos"] == block_pos: block_to_break = breaking_block if block_to_break is None: block_to_break = {"pos": block_pos, "name": block["name"], "progress": 0, "breaktime": block["breaktime"]} breaking_blocks.append(block_to_break) block_to_break["progress"] += 2 * break_speed if block_to_break["progress"] >= block_to_break["breaktime"]: #remove the block breaking_blocks.remove(block_to_break) chunk.set_block_at(Convert.world_to_chunk(block_pos[0])[0], block_pos[1], World.get_block("water"), background) blockentity = None if block["entity"] != "": #remove the associated entity for entity in chunk.entities: if type(entity).__name__ == block["entity"] and [int(entity.pos[0]), int(entity.pos[1])] == block_pos: chunk.entities.remove(entity) blockentity = entity break chunk.entities.append(ItemDrop(block_pos, block["name"], blockentity)) def get_color(self, background): if background: return (192, 192, 192, 128) else: return (255, 255, 255, 128) def render_break_preview(self, background, world, block, block_pos, screen, viewport): chunk = world.loaded_chunks.get(Convert.world_to_chunk(block_pos[0])[1]) blockimg = world.get_block_render(World.get_block_id(block["name"]), block_pos, block["connectedTexture"], background, chunk, background).copy() mask = pygame.mask.from_surface(blockimg) olist = mask.outline() polysurface = pygame.Surface((Game.BLOCK_SIZE * Game.SCALE, Game.BLOCK_SIZE * Game.SCALE), pygame.SRCALPHA) color = self.get_color(background) pygame.draw.polygon(polysurface, color, olist, 0) screen.blit(polysurface, Convert.world_to_viewport(block_pos, viewport)) def render_block_preview(self, background, held_item, world, block_pos, screen, viewport): held_block = World.get_block(held_item.name) chunk = world.loaded_chunks.get(Convert.world_to_chunk(block_pos[0])[1]) blockimg = world.get_block_render(World.get_block_id(held_block["name"]), block_pos, held_block["connectedTexture"], background, chunk, background).copy() mask = pygame.mask.from_surface(blockimg) olist = mask.outline() polysurface = pygame.Surface((Game.BLOCK_SIZE * Game.SCALE, Game.BLOCK_SIZE * Game.SCALE), pygame.SRCALPHA) screen.blit(polysurface, Convert.world_to_viewport(block_pos, viewport)) collides = False entities = world.get_nearby_entities(self.get_chunk()) entities.append(self) for entity in entities: if entity.collides(block_pos) and entity.background == background: collides = True color = self.get_color(background) if collides and World.get_block(held_block["name"])["solid"]: color = (color[0], 0, 0, color[3]) pygame.draw.polygon(polysurface, color, olist, 0) blockimg.blit(polysurface, (0, 0), special_flags=pygame.BLEND_RGBA_MULT) screen.blit(blockimg, Convert.world_to_viewport(block_pos, viewport)) def draw_block_highlight(self, world, mouse_pos, viewport, screen, shift): #if player can break the block at the position, highlight it #if player is holding a block and can place it, render a preview block_pos = self.find_angle_pos(mouse_pos, viewport) held_item = self.get_held_item() if held_item is None: harvest_level = 0 else: harvest_level = held_item.get_harvest_level() block = World.get_block(world.get_block_at(block_pos, shift)) samewater = block["name"] == "water" fgwater = World.get_block(world.get_block_at(block_pos, False))["name"] == "water" if block["breakable"] and block["harvestlevel"] <= harvest_level and (not shift or fgwater): self.render_break_preview(shift, world, block, block_pos, screen, viewport) elif held_item is not None and held_item.can_place and samewater: self.render_block_preview(shift, held_item, world, block_pos, screen, viewport) def change_slot(self, direction): if direction: self.selected_slot += 1 if self.selected_slot >= len(self.inventory[0]): self.selected_slot -= len(self.inventory[0]) else: self.selected_slot -= 1 if self.selected_slot < 0: self.selected_slot += len(self.inventory[0]) def die(self, world): self.health = self.max_health #TODO: only create grave at nearest empty foreground space world.set_block_at([int(self.pos[0]), int(self.pos[1])], World.get_block("grave"), False) #TODO: fill it up with items and clear inventory #TODO: respawn
""" version = "0.1" ###################################################################### # INVENTORY ###################################################################### from Inventory import Inventory from Inventory import FabricService from Inventory import FabricServer inventory_db = server_config.get("mongo", "dbname") if server_config.has_option("mongo", "host"): inventory = Inventory(inventory_db, server_config.get("mongo", "host"), server_config.getint("mongo", "port"), server_config.get("mongo", "user"), server_config.get("mongo", "pass")) else: inventory = Inventory(inventory_db) inventory.clean() inventory.create_cluster("brave", "101.102.203.[11-26]", "b{0:03d}", 1, "b001", "b") #inventory.create_cluster("delta", "102.202.204.[1-16]", "d-{0:03d}", 1, "d-001", "d") #inventory.create_cluster("gamma", "302.202.204.[1-16]", "g-{0:03d}", 1, "g-001", "g") #inventory.create_cluster("india", "402.202.204.[1-128]", "i-{0:03d}", 1, "i-001", "i") #inventory.create_cluster("sierra", "502.202.204.[1-128]", "s-{0:03d}", 1, "s-001", "s") centos = FabricImage( name = "centos6", osimage = '/path/to/centos0602v1-2013-06-11.squashfs',
class Game: currentDay = 0 currentLocation = 0 def __init__(self, name, locations, cash, products, days): self.maxDays = days self.locations = getLocations(locations, products) self.name = name; self.inventory = Inventory(cash) self.startingCash = cash def start(self): self.currentDay += 1 location = self.getLocation() location.update() os.system('clear') print 'Oh hai {0}!'.format(self.name) print '{0} days left!'.format(self.maxDays - self.currentDay) print 'Location: {0}'.format(location.name) if(self.currentDay >= self.maxDays): return self.gameOver() self.mainLoop() def mainLoop(self): self.inventory.display() self.getLocation().display() self.getTradeOptions() def gameOver(self): print 'Game Over!' print 'You finished with £{0}'.format(self.inventory.cash) print 'Minus the £{0} you have to repay your mum, that\'s £{1}!'.format(self.startingCash, self.inventory.cash - self.startingCash) def getLocation(self): return self.locations[self.currentLocation] def getTradeOptions(self): code = 0 options = [] location = self.getLocation() for product in location.market: option = {'code': str(code), 'description':'buy {0}'.format(product['name']), 'callback':self.getPurchaseClosure(product)} options.append(option) code += 1 for product in self.inventory.items: option = {'code': str(code), 'description':'sell {0}'.format(product['name']), 'callback':self.getSaleClosure(product)} options.append(option) code += 1 options.append({'code':'m', 'description':'check out a different area', 'callback':self.travel}) options.append({'code':'q', 'description':'quit', 'callback':self.exit}) ask('Would you like to trade?', options) def getPurchaseClosure(self, product): def cb(): qty = raw_input('how many? ({0} available)\n'.format(product['quantity'])) if qty.isdigit(): self.purchase(product, int(qty)) else: cb() return cb def getSaleClosure(self, product): def cb(): qty = raw_input('how many? ({0} available)\n'.format(product['quantity'])) if qty.isdigit(): self.sell(product, int(qty)) else: cb() return cb def exit(self): print 'goodbye!' os._exit(0) def travel(self): code = 0 options = [] for location in self.locations: if location is self.getLocation(): continue option = {'code': str(code), 'description':location.name, 'callback':self.getMovementClosure(location)} options.append(option) code += 1 options.append({'code':'q', 'description':'quit', 'callback':self.exit}) ask('Where would you like to go?', options) def getMovementClosure(self, location): def cb(): self.moveTo(location) return cb def moveTo(self, location): self.currentLocation = self.locations.index(location) self.start() def purchase(self, product, qty): os.system('clear') price = product['price'] * qty if(self.inventory.cash >= price and product['quantity'] >= qty): self.inventory.cash -= price self.inventory.add(product['name'], qty) product['quantity'] -= qty print 'you bought {0} units of {1} at a cost of £{2}'.format(qty, product['name'], price) elif(self.inventory.cash < price): print 'insufficient funds' print 'you only have £{0}, but transaction costs £{1}'.format(self.inventory.cash, price) else: print 'not that many available' print 'you want {0}, but there are only {1} units'.format(qty, product['quantity']) self.mainLoop() def sell(self, product, qty): os.system('clear') location = self.getLocation() productPrice = 0 for lProduct in location.market: if product['name'] == lProduct['name']: selectedProduct = lProduct productPrice = lProduct['price'] break price = productPrice * qty if(product['quantity'] >= qty): selectedProduct['quantity'] += qty product['quantity'] -= qty self.inventory.cash += price if product['quantity'] < 1: self.inventory.items.remove(product) print 'you sold {0} units of {1} for £{2}'.format(qty, product['name'], price) else: print 'you don\'t have that many units of {0}'.format(product['name']) self.mainLoop()
class Character: StatsArray = namedtuple("StatsArray", ["Hp", "Str", "Mag", "Skl", "Spd", "Lck", "Res", "Def"]) WepArray = namedtuple("WepArray", ["Swd", "Axe", "Lnc", "Bow", "Knf", "Fir", "Thu", "Wnd", "Lgt", "Drk", "Stf"]) def __init__(self, info): ''' [name, currentHp, level, experience, statList, growthList, wepExpList, Inventory] ''' #TODO Add skills, mov and any other important statistics. . #Mov might be better in the stats array, depending how I do class changes or if I want #anyone to be able to gain mov on level-up. self.name = info[0] self.cHp = info[1] self.lvl, self.exp = info[2], info[3] self.stats = Character.StatsArray._make(info[4]) self.growths = Character.StatsArray._make(info[5]) self.WExps = Character.WepArray._make(info[6]) self.inv = Inventory(self, info[7]) def cmbtWindow(self, defend): ''' Prints out an info sheet on the selected combat, with self as the aggressor. Also initiates the fight. ''' #Print " Name1 Name2" print("\t" + self.name + "\t" + defend.name) #Print " dmg1 dmg2" dmgA = self.stats.Str - defend.stats.Def + self.inv.wep.mt dmgB = defend.stats.Str - self.stats.Def + defend.inv.wep.mt if dmgA < 0: dmgA = 0 if dmgB < 0: dmgB = 0 print("Dmg\t" + str(dmgA) + "\t" + str(dmgB)) #Print " atks1 atks2" if self.stats.Spd - 7 >= defend.stats.Spd: atksA = 3 atksB = 1 elif self.stats.Spd - 4 >= defend.stats.Spd: atksA = 2 atksB = 1 elif defend.stats.Spd - 7 >= self.stats.Spd: atksA = 1 atksB = 3 elif defend.stats.Spd - 4 >= self.stats.Spd: atksA = 1 atksB = 2 else: atksA = 1 atksB = 1 print("Attacks\t" + str(atksA) + "\t" + str(atksB)) #Print " hit1 hit2" hitA = 2 * self.stats.Skl - 2 * defend.stats.Spd + self.stats.Lck - defend.stats.Lck + self.inv.wep.hit hitB = 2 * defend.stats.Skl - 2 * self.stats.Spd + defend.stats.Lck - self.stats.Lck + defend.inv.wep.hit if hitA < 0: hitA = 0 if hitB < 0: hitB = 0 print("Hit\t" + str(hitA) + "\t" + str(hitB)) #Print " crit1 crit2" critA = self.stats.Skl/2 - defend.stats.Lck + self.inv.wep.crit critB = defend.stats.Skl/2 - self.stats.Lck + defend.inv.wep.crit if critA < 0: critA = 0 if critB < 0: critB = 0 print("Crit\t" + str(critA) + "\t" + str(critB)) #TODO Ask for input from user to fight or not. print("Would you like " + self.name + " to attack " + defend.name + "? (Y or N)") i = "x" #Loop until a y or n answer is obtained. while (True): i = raw_input() if (i == "n" or i == "N"): return if(i == "Y" or i == "y"): self.cmbt(defend) return print("Invalid input. Try Again.") def cmbt(self, defend): self.fight(defend) self.reequip() defend.reequip() def reequip(self): if ((self.inv.wep is None) and self.inv.equipped == True): self.inv.equipFirst() def fight(self, defend): ''' TODO Add the option for Mag vs Def and Str vs Res or others? Skills instead? ''' dmgTotalA = 0 dmgTotalB = 0 baseExpA = (21 + defend.lvl - self.lvl)/2 baseExpB = (21 + self.lvl - defend.lvl)/2 #Always x = self.attack(defend) dmgTotalA += x if x == -1: self.getExp(baseExpA + defend.lvl - self.lvl + 20) return #Always x= defend.attack(self) dmgTotalB+=x if x == -1: defend.getExp(baseExpB + self.lvl - defend.lvl + 20) return #When attacker has 2x or 3x if self.stats.Spd - 4 >= defend.stats.Spd: x= self.attack(defend) dmgTotalA+=x if x == -1: self.getExp(baseExpA + defend.lvl - self.lvl + 20) return #When attacker has 3x if self.stats.Spd - 7 >= defend.stats.Spd: x= self.attack(defend) dmgTotalA+=x if x == -1: self.getExp(baseExpA + defend.lvl - self.lvl + 20) return #When defender has 2x or 3x if defend.stats.Spd - 4 >= self.stats.Spd: x= defend.attack(self) dmgTotalB+=x if x == -1: defend.getExp(baseExpB + self.lvl - defend.lvl + 20) return #When defender has 3x if defend.stats.Spd - 7 >= self.stats.Spd: x= defend.attack(self) dmgTotalB+=x if x == -1: defend.getExp(baseExpB + self.lvl - defend.lvl + 20) return if dmgTotalA >= 1: self.getExp(baseExpA) else: self.getExp(1) if dmgTotalB >= 1: defend.getExp(baseExpB) else: defend.getExp(1) def attack(self, defend): ''' self performs a Str vs Def or Mag vs Res attack on defend. Checks for crits and skill activations. ''' if (self.inv.wep is None): return 0 hit = 2 * self.stats.Skl - 2 * defend.stats.Spd + self.stats.Lck - defend.stats.Lck + self.inv.wep.hit # Plus other bonuses hit = hit * 2 r = randint(0, 99) + randint(0, 99) if hit > r: spec = self.specCheck(defend) if spec > 1: return self.specExe(defend, spec) if ((self.inv.wep.type >= 0 and self.inv.wep.type <= 4) or self.inv.wep.type == 10): dmg = self.stats.Str - defend.stats.Def + self.inv.wep.mt #TODO Add other Bonuses if (self.inv.wep.type > 5 and self.inv.wep.type <= 9): dmg = self.stats.Mag - defend.stats.Res + self.inv.wep.mt if (self.inv.wep is None): dmg = 0 if (dmg < 0): dmg = 0 if spec == 1: print("Critical!") dmg *= 3 print(defend.name + " takes " + str(dmg) + " damage.") defend.cHp -= dmg if defend.cHp <= 0: self.inv.useWep() print(defend.name + " has died.") #TODO fetch death quotes from somewhere. return -1 if dmg > 0: self.inv.useWep() return dmg print("Miss") return 0 def specCheck(self, defend): ''' Uses RNG to check for skill activations, crits, etc. ''' #TODO Add checks for skills that would proc before checking for crit #RAW crit is Skl/2 vs Lck crit = self.stats.Lck + self.stats.Skl/2 - 2 * defend.stats.Lck r = randint(0, 99) if crit > r: return 1 #TODO Add checks for skills that would proc if a crit did not return 0 def getExp(self, x): ''' Adds experience gain, then checks to see if enough experience to level up. ''' if x > 0: self.exp += x while (self.exp >= 100): self.levelUp() def levelUp(self): ''' Called by getExp. Gives self the benefits of a level-up and increments their level ''' self.exp -= 100 self.lvl += 1 s = list(self.stats) x = 0 for i in range(8): r = randint(0, 99) if r < self.growths[i]: s[i] += 1 x += 1 self.stats = Character.StatsArray._make(s) #TODO Add class change and class skill learning return x def specExe(self, defend, spec): ''' Replaces a normal hit (or crit). Executes skill #(spec) skill and returns damage done. Hit has already succeeded. ''' #TODO Add skills. Also, should probably throw an exception if skill not found. print("Skill not found.") return
def __init__(self): self._tmp_conf = OssimConf (Const.CONFIG_FILE) self.inv = Inventory() #Implement cache with timeout????? self.cache = []
class Test_Inventory: #filename = "$HOME/.futuregrid/cloudmesh-new.yaml" def setup(self): self.inventory = Inventory("nosetest") def tearDown(self): pass #self.inventory.disconnect() def test00_disconnect(self): HEADING("00 DISCONNECT") print "NOT YET IMPLEMENTED" def test01_clean(self): HEADING("test01_clean") self.inventory.clean() def test02_add_Service(self): HEADING("test02_add_Service") now = datetime.now() service = FabricService( name='Euca', date_start=now, date_update=now, date_stop=now ) self.inventory.save(service) def test03_add_Server(self): HEADING("test03_add_Server") now = datetime.now() service = FabricService( name='OpenStack', date_start=now, date_update=now, date_stop=now ) self.inventory.save(service) server = FabricServer( name='Hallo4', date_start=now, date_update=now, date_stop=now, services = [service] ) self.inventory.save(server) def test05_create(self): HEADING("test05_create") self.inventory.create("server","dynamic", "india[9-11].futuregrid.org,india[01-02].futuregrid.org") print self.inventory.pprint() assert self.inventory.exists("server", "india01.futuregrid.org") def test06_loop_print(self): HEADING("test06_loop_print") for server in self.inventory.servers: print server.data def test07_exists(self): HEADING("test07_exists") assert self.inventory.exists("server", "india01.futuregrid.org") == True def test08_print(self): HEADING("test08_print") self.inventory.pprint() def test09_count(self): HEADING("test09_count") print self.inventory.servers.count(), self.inventory.services.count() assert (self.inventory.servers.count() == 6) and (self.inventory.services.count() == 2) def test10_set(self): HEADING("test10_set") self.inventory.clean() self.inventory.create( "server", "dynamic", "india01.futuregrid.org") print self.inventory.pprint() print self.inventory.exists("server", "india01.futuregrid.org") self.inventory.set_service( "india01-opensatck", "india01.futuregrid.org", "openstack") self.inventory.pprint() def test11_add(self): HEADING("test11_add") self.inventory.clean() self.inventory.create( "server", "dynamic", "india01.futuregrid.org") print self.inventory.pprint() print self.inventory.exists("server", "india01.futuregrid.org") self.inventory.add_service( "india01-opensatck", "india01.futuregrid.org", "openstack") self.inventory.pprint() def test12_logging(self): self.test11_add() HEADING("test12_logging") s = self.inventory.get("server","india01.futuregrid.org")[0] print s.data s.stop() s.start() s.start()
def setup(self): self.inventory = Inventory("nosetest")