class Player: """The Player""" def __init__(self): self.inventory = Inventory() self.life = 100 self.alive = True self.damage = 25 def take_damage(self, amount): self.life -= amount if self.life <= 0: self.die() def die(self): print "You died!" exit(0) def add_item(self, item): self.inventory.add(item) def add_weapon(self, weapon): self.inventory.add(weapon) self.damage += weapon.damage def check_inventory(self): return(self.inventory) def equip_weapon(self, weapon): for item in inventory: if item.name == weapon: self.weapon = item else: return(False)
def decodeInventoryEntry_level1(document): """ Decodes a basic entry such as: '6 lobster cake' or '6' cakes @param document : NLP Doc object :return: Status if decoded correctly (true, false), and Inventory object """ count = Inventory(str(document)) for token in document: if token.pos_ == (u'NOUN' or u'NNS' or u'NN'): item = str(token) for child in token.children: if child.dep_ == u'compound' or child.dep_ == u'ad': item = str(child) + str(item) elif child.dep_ == u'nummod': count.amount = str(child).strip() for numerical_child in child.children: # this isn't arithmetic rather than treating it such as a string count.amount = str(numerical_child) + str(count.amount).strip() else: print "WARNING: unknown child: " + str(child) + ':'+str(child.dep_) count.item = item count.unit = item return count
def main(args): try: intry = Inventory() server_name = str(args[1]).strip() print(intry.getFloatingIpFromServerForNetwork(server_name)) except IndexError: print("Usage: get_floating_ip <server_name>")
class Game(): def __init__(self, gru_file=None): self.compiler = Compiler() if gru_file: self.stream = self.compiler.decompile(gru_file) else: self.stream = self.compiler.compile(None) self.metadata = self.stream.metadata self.flags = Flags(self.stream) self.wheel = Wheel(config) self.title = Title(config) self.inventory = Inventory(self.stream, self.flags, config) self.combiner = Combiner(self.stream, self.flags, self.inventory) self.page = Page(config, self.flags, self.combiner, self.inventory) self.state = State(self.stream, self.flags, self.inventory, self.wheel, self.combiner, self.title, self.page) if self.metadata.has_key("start"): start = self.metadata["start"] self.state.update(start) else: self.state.update("start") def draw(self, tick): self.inventory.draw() self.wheel.draw() self.title.draw() self.page.draw(tick)
class TestInventory(unittest.TestCase): """ A test class for the Inventory module. """ def setUp(self): """ set up data used in the tests. setUp is called before each test function execution. """ self.inv = Inventory() self.weapon = Weapon("Canon", 20) self.inv.addWeapon(self.weapon) def testInitialized(self): """ Test if init goes good """ self.assertEqual(self.weapon.name, "Canon") self.assertEqual(self.weapon.power, 20) self.assertEqual(len(self.inv.weapons), 1) self.assertEqual(self.inv.weapons[0], self.weapon)
def __init__(self, position=(0,0,0), rotation=(-20, 0), flying=False, game_mode=G.GAME_MODE, username="", local_player=True): super(Player, self).__init__(position, rotation, health=7, max_health=10, attack_power=2.0 / 3, attack_range=4) self.inventory = Inventory(27) self.quick_slots = Inventory(9) self.armor = Inventory(4) self.flying = flying self.game_mode = game_mode self.strafe = [0, 0] self.dy = 0 self.current_density = 1 # Current density of the block we're colliding with self._position = position self.last_sector = None self.last_damage_block = 0, 100, 0 # dummy temp value self.username = username self.local_player = local_player # for debug initial_items = [cake_block, torch_block, bed_item] for item in initial_items: self.inventory.add_item(item.id, item.max_stack_size) if not local_player: self.model = PlayerModel(position) self.momentum = (0,0,0)
def __init__(self, g, player_new, dimentions, p = 0): LevelBase.__init__(self, g, player_new, dimentions) self.prevlevel = p self.title = 'Jail' # current level TW,TH = 32,32 # load tile set g.tga_load_tiles(os.path.join("textures", "tiles5.png"), (TW,TH), self.tdata) g.tga_load_level(os.path.join("levels", "level19.tga"), 1) g.bounds = pygame.Rect(TW,TH,(len(g.tlayer[0])-2)*TW,(len(g.tlayer)-2)*TH) g.code_events(self.edata) # and an odd object called flutter box. flutter shutter (37, 13) self.terrorist = Character("terrorist.png","faceterrorist.tga", g) self.terrorist.pos((3, 20)) self.terrorist.direction = 0 self.terrorist.faceup = 1 self.flutterbox = Inventory(g, 'flutterbox') self.flutterbox.pos((37, 13)) self.flutterswitch = Inventory(g, 'flutterswitch') self.flutterswitch.pos((37, 20)) g.run_codes(self.cdata,(0,0,g.dimentions[0],g.dimentions[1]))
def test_fetch_remote_stock_real_server(): client = HTTPConnection('localhost', 44332) inv = Inventory(client=client) inv.fetch_remote_stock('Pants') assert inv.items['Pants']['price'] == 50.00 assert inv.items['Pants']['quantity'] == 10 assert inv.total_stock() == 10
def __init__(self, name, formation_type): self.name = name self.common_image_dir = constant.BATTLE_COMMON_IMAGE_DIR self.war_dir = os.path.join(constant.WARS_DIR, self.name) self.war_image_dir = os.path.join(self.war_dir, 'image') self.inventory = Inventory() self.restore = Restore() self.formation = Formation(formation_type)
def reset(self): self.cam = Camera() self.world = World(self.cam) self.ui = UI(self.world) self.player = Player(self.world, self.onPlayerDead) self.world.player = self.player self.inventory = Inventory() self.inventory.player = self.player
def test_010_validate_inventory(self): i = Inventory() config = configparser.ConfigParser() config.read_file(open('./ansible.cfg')) box_list = [['local', '127.0.0.1', 'USER_NAME', 'USER_PASSWORD']] codes = {'local':'test'} ret, msg = i.generateInventory(config,box_list, "./test.hosts", codes, "") self.assertEqual(ret,True)
def runEveryTwoSeconds(self): self.labelLookupsPerSecond.setText( _translate( "networkstatus", "Inventory lookups per second: %1").arg( str(Inventory().numberOfInventoryLookupsPerformed / 2))) Inventory().numberOfInventoryLookupsPerformed = 0 self.updateNumberOfBytes() self.updateNumberOfObjectsToBeSynced()
def __init__(self, name, maxhp=1, damage=1, weight_capacity=20): self.name = name self.maxhp = maxhp self.hp = maxhp self.damage = damage self.weight_capacity = weight_capacity self.inventory = Inventory()
def __init__(self, product_code, description, market_price, rental_price, material, size): # Creates common instance variables from the parent class Inventory.__init__(self, product_code, description, market_price, rental_price) self.material = material self.size = size
def __init__(self, product_code, description, market_price, rental_price, brand, voltage): """Initializes an inventory""" # Creates common instance variables from the parent class Inventory.__init__(self, product_code, description, market_price, rental_price) self.brand = brand self.voltage = voltage
class Player: """ Main character class """ def __init__(self, name, starting_room, starting_items=[]): # Player info self.name = name self.current_room = starting_room self.previous_room = None # Player inventory self.inventory = Inventory(starting_items) # Movement text for easier printing later self.directions = {"n": "north", "s": "south", "e": "east", "w": "west"} def move(self, direction): """ Moves player in provided direction to next room """ # Get all exits for the current room possible_paths = self.current_room.get_exits() # Get exit in provided direction next_room = possible_paths[direction] if next_room: # Exit is a valid room self.previous_room = self.current_room self.current_room = next_room else: print(f"There is no exit to the {self.directions[direction]}\n") def take_item(self, item_to_take): """ Take item from a room and move it into player inventory """ for loot_item in self.current_room.get_loot(): if loot_item.name == item_to_take: # The item we are searching for was found self.inventory.add(loot_item) self.current_room.withdraw_loot_item(loot_item) # Fire item take event loot_item.on_take() # Leave the loop because we're done break def drop_item(self, item_to_drop): """ Drop inventory item onto floor """ for item in self.inventory.get(): if item.name == item_to_drop: self.inventory.remove(item) self.current_room.deposit_loot_item(item) # Fire item drop event item.on_drop() break
def load(self, state, seed): self.seed = seed self.x = state['x'] self.y = state['y'] self.tile = Tile(self.x, self.y, self.seed) self.turns = state['turns'] self.days = state['days'] self.tiredness = state['tiredness'] self.inventory = Inventory(inventory=state['inventory'])
def get_products(): products = Inventory.list_products() if Inventory.products_exist(products): return jsonify(products) else: # Create Products for our Stripe store if we haven't already. setup.create_data() products = Inventory.list_products() return jsonify(products)
def __init__(self, name): #self.game = game self.name = name self.health = 0 self.attack = 0 self.effects = [] self.inventory = Inventory() self.party = 0 self.cluster = Cluster()
def __init__(self, name, description): self.name = name self.description = description self.n_to = None self.e_to = None self.s_to = None self.w_to = None self.points = None Inventory.__init__(self, self.name)
def bm_command_object(self): objectOffset = self.payloadOffset nonce, expiresTime, objectType, version, streamNumber = self.decode_payload_content( "QQIvv") self.object = BMObject(nonce, expiresTime, objectType, version, streamNumber, self.payload, self.payloadOffset) if len(self.payload ) - self.payloadOffset > BMProto.maxObjectPayloadSize: logger.info( 'The payload length of this object is too large (%d bytes). Ignoring it.' % (len(self.payload) - self.payloadOffset)) raise BMProtoExcessiveDataError() try: self.object.checkProofOfWorkSufficient() self.object.checkEOLSanity() self.object.checkAlreadyHave() except (BMObjectExpiredError, BMObjectAlreadyHaveError, BMObjectInsufficientPOWError) as e: BMProto.stopDownloadingObject(self.object.inventoryHash) raise e try: self.object.checkStream() except (BMObjectUnwantedStreamError, ) as e: BMProto.stopDownloadingObject( self.object.inventoryHash, BMConfigParser().get("inventory", "acceptmismatch")) if not BMConfigParser().get("inventory", "acceptmismatch"): raise e try: self.object.checkObjectByType() objectProcessorQueue.put( (self.object.objectType, buffer(self.object.data))) except BMObjectInvalidError as e: BMProto.stopDownloadingObject(self.object.inventoryHash, True) else: try: del state.missingObjects[self.object.inventoryHash] except KeyError: pass if self.object.inventoryHash in Inventory() and Dandelion().hasHash( self.object.inventoryHash): Dandelion().removeHash(self.object.inventoryHash, "cycle detection") Inventory()[self.object.inventoryHash] = ( self.object.objectType, self.object.streamNumber, buffer(self.payload[objectOffset:]), self.object.expiresTime, buffer(self.object.tag)) self.handleReceivedObject(self.object.streamNumber, self.object.inventoryHash) invQueue.put((self.object.streamNumber, self.object.inventoryHash, self.destination)) return True
def __init__(self): self.life = 100 self.max_life = self.life self.strength = 10 self.agility = 14 self.race = "creature" self.name = self.race self.inventory = Inventory() self.dead = False
def __init__(self): self._inventory_data = Inventory(G.res_mgr.get_item_config()) Inventory.on_mouse_changed = self._on_mouse_changed G.gui_mgr.set_inventory_cb(self._on_item_clicked, self._on_item_hover) self.refresh_mouse() self.refresh_inventory() self._timer_refresh = tween.Tween(duration=3.345, loop_type=tween.LoopType.Loop, on_complete=self._on_refresh)
def runEveryTwoSeconds(self): """Updates counters, runs every 2 seconds if the timer is running""" self.labelLookupsPerSecond.setText( _translate( "networkstatus", "Inventory lookups per second: %1").arg( str(Inventory().numberOfInventoryLookupsPerformed / 2))) Inventory().numberOfInventoryLookupsPerformed = 0 self.updateNumberOfBytes() self.updateNumberOfObjectsToBeSynced()
def setUp(self): self.item1 = Item(1, 'beer', 12.95) self.item2 = Item(2, 'chips', 4.75) self.item3 = Item(3, 'salsa', 2.75) #add items self.inven = Inventory() self.inven.addItem(self.item1) self.inven.addItem(self.item2) self.inven.addItem(self.item3)
def __init__(self): pyxel.init(256, 256, fps=60) pyxel.mouse(True) pyxel.load("./assets.pyxres") self.entities = [Enemy(0, 6 * 8)] for _ in range(15): self.entities.append(Enemy(0, 0)) self.inventory = Inventory(1, 28, 30, 3, pyxel.COLOR_WHITE) pyxel.run(update=self.update, draw=self.draw)
def __init__(self, ): self.invent = Inventory() self.choices = { "1": self.add_to_cart, "2": self.view_cart, "3": self.remove_cartitems, "4": self.empty_cart, "5": self.replace_items, "6": self.quit }
def update_payment_intent(id): data = json.loads(request.data) amount = Inventory.calculate_payment_amount(items=data['items']) amount += Inventory.get_shipping_cost(data['shippingOption']['id']) try: payment_intent = stripe.PaymentIntent.modify(id, amount=amount) return jsonify({'paymentIntent': payment_intent}) except Exception as e: return jsonify(e), 403
def to_JSON(self): # JSON serializability del self.inv.c del self.inv.conn print( json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)) self.inv = Inventory()
def __init__(self, game, *args, **kwargs): self.game = game self.inventory = Inventory(self) self.name = 'character' self.x = 0 self.y = 0 self.orientation = 0 self.actions = {} self.last_action = None self.cell = self.get_map_cell()
def setUp(self): self.item1 = Item(4206, 'Green Onion', 0.89) self.item2 = Item(4131, 'Fuji Apple', 1.99) self.item3 = Item(4011, 'Banana', 0.79) #add items self.inven = Inventory() self.inven.addItem(self.item1) self.inven.addItem(self.item2) self.inven.addItem(self.item3)
class Character(object): def __init__(self): self.name = 'Unnamed' self.attack = 0 self.max_health = 0 self.health = 0 self.defence = 0 self.magic = 0 self.description = "" self.weapon = "" self.inventory = Inventory() self.inventory.add(Item('gold'), 10) self.commands = self.getCommands() def hasMagic(self): if self.magic > 0: return True return False def showInventory(self): return_value = "" inventory = self.inventory.inventory for thing in inventory.keys(): item = inventory[thing] return_value += ("%s %s \n" % (item.name.capitalize(), item.quantity)) return return_value def showStats(self): return_value = "%s You are armed with a %s.\n" return_value += "Your attack is %s, defence is %s and health is %s\n" return return_value % ( self.description, self.weapon, self.attack, self.defence, self.health ) + self.showInventory() def showHealth(self): return "Health: %s\n" % (self.health) def injure(self, amount=10): self.health -= amount if self.health <= 0: self.health = 0 def getCommands(self): return { 'health': self.showHealth, 'h': self.showHealth, 'hurt': self.injure, }
def test_inventory(self): """Tests for Inventory dictionary output""" my_inv = Inventory(product_code=12, description='an apple', market_price=2, rental_price=1.5) inv_dict = my_inv.return_as_dictionary() assert inv_dict['product_code'] == 12 assert inv_dict['description'] == 'an apple' assert inv_dict['market_price'] == 2 assert inv_dict['rental_price'] == 1.5
def __init__(self, game): """ Create rooms and items for the appropriate 'game' version. """ self.rooms = self.load_rooms(f"data/{game}Rooms.txt") self.items = self.load_items(f"data/{game}Items.txt") self.inventory = Inventory() self.current_room = self.rooms[1] self.win = 0
def __init__(self): self.transactionNum = 0 self.inventory = Inventory() self.cart = Cart() self.todayDate = date.today() self._customerOption = "" self._menuOption = 0 self._transactionOption = 0 self._addInput = [] self._cashAmount = 0.0 self._rmvOption = 0
def new(self, seed): self.seed = seed random.seed(a=seed) self.x = 0 self.y = 0 self.tile = Tile(self.x, self.y, self.seed) self.turns = 0 self.days = 0 self.tiredness = 0 # 0.05 self.inventory = Inventory()
def get_choices_main(self): chosen_option, index = pick(self.options_main, self.title) if index == 0: self.inventory = Inventory(Connection.connect(self.settings_list)) self.get_choices_inventory() elif index == 1: settings = Settings() settings.reset() self.get_choices_inventory() elif index == 2: exit(0)
class Level(LevelBase): prevlevel = 0 dialog = 0 pdialog = 0 timer = 0 oldPos = (0, 0) dialog = 0 btimer = 0 def __init__(self, g, player_new, dimentions, p=0): LevelBase.__init__(self, g, player_new, dimentions) self.prevlevel = p self.title = "Jail" # current level TW, TH = 32, 32 # load tile set g.tga_load_tiles(os.path.join("textures", "tiles5.png"), (TW, TH), self.tdata) g.tga_load_level(os.path.join("levels", "level17.tga"), 1) g.bounds = pygame.Rect(TW, TH, (len(g.tlayer[0]) - 2) * TW, (len(g.tlayer) - 2) * TH) g.code_events(self.edata) self.vats = Inventory(g, "clonevat") self.vats.pos((18, 13)) g.run_codes(self.cdata, (0, 0, g.dimentions[0], g.dimentions[1])) # ugly, ugly monsters def add_monster(self, g, r, a): # e = Enemy(self.g, (r.rect.x, r.rect.y), 'monster1') e = Monster1(self.g, (r.rect.x, r.rect.y)) # upon moving def playerMove(self, g, r, a): if self.prevlevel == 18: g.player.rect.x, g.player.rect.y = r.rect.x, r.rect.y g.view.x = r.rect.x g.view.y = r.rect.y # when you're over a change level tile def change_level(self, g, r, a): if a.__class__.__name__ != "Player": return if g.player.pos[0] == 38: g.currentLevel = 18 if g.player.pos[0] == 1: g.currentLevel = 16 # level events def level_loop(self): g = self.g
def from_disk(self,path,url_prefix,inventory=None): """Create or extend inventory with resources from disk scan Assumes very simple disk path to URL mapping: chop path and replace with url_path. Returns the new or extended Inventory object. If a inventory is specified then items are added to that rather than creating a new one. mb = InventoryBuilder() m = inventory_from_disk('/path/to/files','http://example.org/path') """ num=0 # Either use inventory passed in or make a new one if (inventory is None): inventory = Inventory() # for each file: create Resource object, add, increment counter for dirpath, dirs, files in os.walk(path,topdown=True): for file_in_dirpath in files: try: if self.exclude_file(file_in_dirpath): continue # get abs filename and also URL file = os.path.join(dirpath,file_in_dirpath) if (not os.path.isfile(file) or not (self.include_symlinks or not os.path.islink(file))): continue rel_path=os.path.relpath(file,start=path) if (os.sep != '/'): # if directory path sep isn't / then translate for URI rel_path=rel_path.replace(os.sep,'/') url = url_prefix+'/'+rel_path file_stat=os.stat(file) except OSError as e: sys.stderr.write("Ignoring file %s (error: %s)" % (file,str(e))) continue mtime = file_stat.st_mtime lastmod = datetime.fromtimestamp(mtime).isoformat() r = Resource(uri=url,lastmod=lastmod) if (self.do_md5): # add md5 r.md5=compute_md5_for_file(file) if (self.do_size): # add size r.size=file_stat.st_size inventory.add(r) # prune list of dirs based on self.exclude_dirs for exclude in self.exclude_dirs: if exclude in dirs: dirs.remove(exclude) return(inventory)
def __init__(self, name): """ Constructor to create a team of snails @param name: The name of the team, which will displayed in various locations @return: Team object. """ pygame.sprite.Group.__init__(self) self.name = name """ The name of the team""" self.hasTurn = False self.isAlive = True self.orderedSnailList = [] self.gravity_direction = None self.inventory = Inventory(self.name) cannon = Cannon("Cannon", 20) balloonLauncher = BalloonLauncher("Balloon", 30) self.inventory.addWeapon(balloonLauncher) self.inventory.addWeapon(cannon) self.active_weapon = cannon self.colorIndex = None
def __init__(self, wnd, w, h): """ """ Database.init() self.hexa_size = 80 self.width = w self.height = h self.canvas = Canvas( wnd, width=self.width, height=self.height, bg='#0080FF', highlightthickness=0, bd=0) self.canvas.pack() wnd.resizable(False, False) self.player = Player(1) self.inventory = Inventory() self.hexagons = [] self.defaultBoardArgs = (2, 3, True) self.canvas.tag_bind('hexagon', "<Button-1>", self.hexAction) # TODO : Remove these tests self.player.debug() Database.debug_items() self.inventory.addItem(0) self.inventory.addItem(1) self.inventory.addItem(0) self.inventory.addItem(2) self.inventory.addItem(0) self.inventory.debug() Database.debug_enemies()
def __init__(self, g, player_new, dimentions, p = 0): LevelBase.__init__(self, g, player_new, dimentions) self.prevlevel = p self.title = 'Office Complex Top' # current level TW,TH = 32,32 # load tile set g.tga_load_tiles(os.path.join("textures", "tiles6.png"), (TW,TH), self.tdata) g.tga_load_level(os.path.join("levels", "level31.tga"), 1) g.bounds = pygame.Rect(TW,TH,(len(g.tlayer[0])-2)*TW,(len(g.tlayer)-2)*TH) g.code_events(self.edata) self.initBack('bg1.png', 730) self.backuptape = Inventory(g, 'tape', (37, 22)) self.backuptape.pos((37, 22)) self.backup = Character('backup.png', 'facebackup.png', g, 'backup') self.backup.pos((28, 25)) self.backup.direction = 0 if 'scene21' in g.saveData: self.backup.hidden = 1 # coming back and saying high to the guy. if 'scene20' in g.saveData and not 'scene21' in g.saveData: del g.saveData['scene20'] g.run_codes(self.cdata,(0,0,g.dimentions[0],g.dimentions[1])) self.coins = 0
def __init__(self, reference=None, **custom): if reference: try: data = get_character_data(reference) except ValueError: raise UnexistingCharacterException( "The reference \"{}\" doesn't exist".format(reference)) else: for key in LIST_CARAC: if not key in data: data[key] = get_character_data("unknown")[key] else: data = get_character_data("unknown") self._health = 0 self._inventory = inventory.Inventory() self.name = self.operations(custom.get("name", data["name"])) self.maxhealth = self.operations(custom.get( "maxhealth", data["maxhealth"])) self.health = custom.get("health", self.maxhealth) self.range_attack = self.operations(custom.get( "range_attack", data["range_attack"])) self.attack = self.operations(custom.get( "attack", data["attack"])) self.defense = self.operations(custom.get( "defense", data["defense"])) self.initiative = self.operations(custom.get( "initiative", data["initiative"])) self.inventory = Inventory(custom.get("inventory", data.get("inventory", None))) self.abilities = self.operations(custom.get( "abilities", data["abilities"])) # Not used in this version self.ref = reference self.weapon = self.inventory.weapons[0] # Take the first
def __init__(self): self.map = Map(START_LEVEL) # Enforce that a path does exist in the map while self.map.findPath() == None: self.map = Map(START_LEVEL) self.player = Player() self.inventory = Inventory() self.enemy_factory = EnemyFactory() self.user = User() self.invuln_turns = 0 self.swap_weapon_to = None self.current_enemy = None self.level = START_LEVEL self.danger = 5 self.hide_danger = 5 self.escape_chance = 3 self.items_dropped = 0 # a counter so we make sure they get shield, sword and bow chances first self.steps_left = MAX_STEPS self.escapes_remaining = NUM_ESCAPES self.encounter_sdorf = False self.dangers = [] self.escape_chances = [] self.hide_dangers = [] self.seerdata = SeerData() self.init_dangers()
def __init__(self, class_name, id=None): # Each agent has a unique id... should probably get rid of this and just let logic handle it if not id: self.id = next(Agent.newid) else: self.id = id self.class_name = class_name self.price_beliefs = {} self.observed_trading_range = {} self.inventory = Inventory() # FIXME: Using preloaded test values, this should be changed later self.money = 100 self.price_beliefs = {key: {'min':.5, 'max':1.5} for key in self.inventory.goods} self.observed_trading_range = {key: [] for key in self.inventory.goods} # was keys self.lookback = 15 # Add two fake trades so range exists for trade_range in self.observed_trading_range.values(): trade_range.append(.5) trade_range.append(1.5) # This is temporary self.load_logic(manual_logic.agent_logic_data)
def start(): if self.startFrame.curSelectIdx == -1: tkMessageBox.showwarning('Invalid', 'Please choose a job.') return chosenJob = self.classList[self.startFrame.curSelectIdx] curClass = chosenClass.get() message = 'Are You Sure?\n\n' message += 'Starting as: ' + chosenJob + '\n' message += 'Funding level: ' + chosenResource.get() res = tkMessageBox.askquestion('Start', message, type='yesno') if res == 'no': return self.startFrame.destroy() self.m_inventory = Inventory() self.m_marketInfo = MarketInfo() self.m_charInfo = Character(chosenJob) self.m_inventory.initBasicEquips(chosenJob, curClass) self.m_sysMessage = Tkinter.StringVar() self.m_sysMessage.set('Welcome!') self.initMainUI() self.tabInventory.reset() self.tabEquip.reset() self.tabPurchase.reset() self.tabActivity.reset()
def __init__(self, g, player_new, dimentions, p = 0): LevelBase.__init__(self, g, player_new,dimentions) self.prevlevel = p self.title = 'Engineers Lab' # current level currentLevel = os.path.join("levels", "level2.tga") TW,TH = 32,32 # load tile set tileTexture = os.path.join("textures", "tiles0.png") g.tga_load_tiles(tileTexture, (TW,TH), self.tdata) g.tga_load_level(currentLevel, 1) g.bounds = pygame.Rect(TW,TH,(len(g.tlayer[0])-2)*TW,(len(g.tlayer)-2)*TH) g.code_events(self.edata) self.microwave = Inventory(g, 'microwave') self.microwave.pos((6, 9)) self.professor = Character("professor.png","faceprofessor.tga", g) self.professor.pos((6, 9)) self.professor.direction = 0 self.assistant = Character("assistant.png","faceassistant.png", g) self.assistant.pos((12, 9)) self.assistant.direction = 1 g.intermission = 1 # already done the cut scene if 'scene1' in g.saveData: g.intermission = 0 self.professor.pos((11, 9)) self.dialog = 9 self.g.sprites.remove(self.assistant) # if you've put the transmitter in if 'scene3' in g.saveData: self.assistant = Character("assistant.png","faceassistant.png", g) self.assistant.pos((13, 9)) self.professor.pos((8, 9)) self.assistant.direction = 1 self.dialog = 10 g.intermission = 1 # already had the talk after putting in the transmitter if 'scene4' in g.saveData: self.dialog = 19 g.intermission = 0 self.g.sprites.remove(self.assistant) if 'scene5' in g.saveData: self.dialog = 20 self.professor.pos((11,9)) self.professor.faceup = 1 g.run_codes(self.cdata,(0,0,g.dimentions[0],g.dimentions[1]))
def test_detect_changes_and_update(self): fs_path = self.create_test_data() inventories = Inventory.perform_recursive_inventory(os.path.dirname(fs_path), self.base_path) for inventory in inventories: inventory.write(self.inventory_base_path) # Nothing changes self.assertEqual([], self.inventory_manager.detect_change(fs_path).inventory_diffs) # Add a directory and new file dir4_path = os.path.join(fs_path, 'dir4') os.mkdir(dir4_path) self.create_test_file(os.path.join(dir4_path, 'file5.txt')) # Remove a directory shutil.rmtree(os.path.join(fs_path, 'dir3')) # Add a file self.create_test_file(os.path.join(fs_path, 'file6.txt')) # Remove a file os.remove(os.path.join(fs_path, 'file1.txt')) # Change a file self.create_test_file(os.path.join(fs_path, 'dir1/file3.txt'), contents='test') inventory_report = self.inventory_manager.detect_change(fs_path) self.assertIsNone(inventory_report.applied_timestamp) rel_path = os.path.relpath(fs_path, self.base_path) self.assertInventoryDiffEqual({ 'path': rel_path, 'directories_missing_from_fs': ['dir3'], 'directories_missing_from_inventory': ['dir4'], 'files_missing_from_fs': {'file1.txt': hashlib.sha256('file1.txt'.encode('utf-8')).hexdigest()}, 'files_missing_from_inventory': {'file6.txt': hashlib.sha256('file6.txt'.encode('utf-8')).hexdigest()}, 'file_fixity_mismatch': {} }, self._find_inventory_diff(inventory_report.inventory_diffs, rel_path)) dir4_rel_path = os.path.join(rel_path, 'dir4') self.assertInventoryDiffEqual({ 'path': dir4_rel_path, 'directories_missing_from_fs': [], 'directories_missing_from_inventory': [], 'files_missing_from_fs': {}, 'files_missing_from_inventory': {'file5.txt': hashlib.sha256('file5.txt'.encode('utf-8')).hexdigest()}, 'file_fixity_mismatch': {} }, self._find_inventory_diff(inventory_report.inventory_diffs, dir4_rel_path)) dir1_rel_path = os.path.join(rel_path, 'dir1') self.assertInventoryDiffEqual({ 'path': dir1_rel_path, 'directories_missing_from_fs': [], 'directories_missing_from_inventory': [], 'files_missing_from_fs': {}, 'files_missing_from_inventory': {}, 'file_fixity_mismatch': {'file3.txt': (hashlib.sha256('file3.txt'.encode('utf-8')).hexdigest(), hashlib.sha256('test'.encode('utf-8')).hexdigest())} }, self._find_inventory_diff(inventory_report.inventory_diffs, dir1_rel_path)) self.inventory_manager.update_inventory(inventory_report) # Nothing changes self.assertEqual([], self.inventory_manager.detect_change(fs_path).inventory_diffs)
def detect_change(self, path): log.info('Detecting changes for %s', path) inventory_diffs = [] fs_inventories = Inventory.perform_recursive_inventory(path, self.base_fs_path, fixity_threads=self.fixity_threads) # If path is not base path, check parent non-recursively to make sure added/deleted directory handled. if path != self.base_fs_path: fs_inventories.append( Inventory.perform_inventory(os.path.dirname(path), self.base_fs_path, fixity_threads=self.fixity_threads)) for fs_inventory in fs_inventories: try: inventory_inventory = Inventory.read(fs_inventory.path, self.base_inventory_path) except FileNotFoundError: inventory_inventory = Inventory(fs_inventory.path) inventory_diff = InventoryDiff.generate_inventory_diff(fs_inventory, inventory_inventory) if inventory_diff.has_diffs(): inventory_diffs.append(inventory_diff) return InventoryReport(path, inventory_diffs)
def test_add_2(self): inv = Inventory(slot_count=20) block = random.choice(G.BLOCKS_DIR.keys()) max_items = G.BLOCKS_DIR[block].max_stack_size * 20 for i in xrange(0, max_items): self.assertTrue(inv.add_item(block)) item = random.choice(G.ITEMS_DIR.keys()) inv2 = Inventory(slot_count=20) max_items2 = G.ITEMS_DIR[item].max_stack_size * 20 for i in xrange(0, max_items2): self.assertTrue(inv2.add_item(item)) self.assertNotIn(None, inv.slots) self.assertNotIn(None, inv2.slots) for slot in inv.slots: self.assertEqual(slot.type, block) self.assertEqual(slot.amount, G.BLOCKS_DIR[block].max_stack_size) for slot in inv2.slots: self.assertEqual(slot.type, item) self.assertEqual(slot.amount, G.ITEMS_DIR[item].max_stack_size)
def setUp(self): """ set up data used in the tests. setUp is called before each test function execution. """ self.inv = Inventory() self.weapon = Weapon("Canon", 20) self.inv.addWeapon(self.weapon)
def __init__(self, Ystart, Xstart, graphics_file, space): self.name = 'Shipbox' self.inventory = Inventory(self.name) Node.__init__(self, Ystart, Xstart, graphics_file, space) self.visible = True self.vicinity = find_vicinity(self.boundaries)
def __init__(self): #----------------------------------------------------------------------- #Here the game is initialized asking for commands via the Cmd module, #the variables given are the first room you start in and prints out the #location cmd.Cmd.__init__(self) self.loc = get_room('intro') self.look() self.inventory = Inventory() self.player = Player()
def __init__(self, parent, player, world, *args, **kwargs): super(InventorySelector, self).__init__(parent, *args, **kwargs) self.amount_labels = [] self.parent = parent self.world = world self.player = player self.max_items = self.player.inventory.slot_count self.current_index = 1 self.icon_size = self.world.group.texture.width / G.TILESET_SIZE self.selected_item = None self.selected_item_icon = None self.mode = 0 # 0 - Normal inventory, 1 - Crafting Table, 2 - Furnace self.change_image() self.crafting_panel = Inventory(4) self.crafting_outcome = None # should be an item stack self.crafting_outcome_icon = None self.crafting_outcome_label = None self.crafting_table_panel = Inventory(9) self.furnace_panel = None # should be a FurnaceBlock self.visible = False
def __init__(self, name): self.name = name self.level = 1 self.hp_max = 10 self.hp = self.hp_max self.damage_min = 0 self.damage_max = 3 self.heal_min = 2 self.heal_max = 4 self.level_kills = 0 self.total_kills = 0 self.inventory = Inventory()
def touch(self, e): if self.imortal == 0: self.g.hurt.play() self.imortal = 10 self.health -= e.get_damage() ef = Effect(self.g, "health", (self.rect.x, self.rect.y)) ef.healthchange = -e.get_damage() # drop some skyberries if "weapon" in self.g.saveData: if self.g.saveData["weapon"] >= 1: wpnstr = "shot" + str(self.g.saveData["weapon"]) + "_lvl" if self.g.saveData[wpnstr] > 1: self.g.saveData[wpnstr] -= 1 if self.g.saveData[wpnstr] == 9: Effect(self.g, "msg", (self.rect.x, self.rect.y), "Level Down") if self.g.saveData[wpnstr] == 19: Effect(self.g, "msg", (self.rect.x, self.rect.y), "Level Down") sb = Inventory(self.g, "skyberry", (self.rect.x, self.rect.y)) sb.canget = 0 sb = Inventory(self.g, "skyberry", (self.rect.x, self.rect.y)) sb.canget = 0 sb = Inventory(self.g, "skyberry", (self.rect.x, self.rect.y)) sb.canget = 0 self.g.player.gravity = 15 self.g.player.jumping = 1 if self.g.saveData["weapon"] != 0: shotType = "shot" + str(self.g.saveData["weapon"]) self.g.saveData[shotType] -= 1 self.g.saveData["health"] = self.health
def __init__(self, g, player_new, dimentions, p = 0): LevelBase.__init__(self, g, player_new, dimentions) self.prevlevel = p self.title = 'Jail' # current level TW,TH = 32,32 # load tile set tileTexture = os.path.join("textures", "tiles5.png") g.tga_load_tiles(tileTexture, (TW,TH), self.tdata) currentLevel = os.path.join("levels", "level14.tga") g.tga_load_level(currentLevel, 1) g.bounds = pygame.Rect(TW,TH,(len(g.tlayer[0])-2)*TW,(len(g.tlayer)-2)*TH) g.code_events(self.edata) self.robot = Character("robot0.png","facerobot.tga", g,'robot') self.robot.pos((13, 20)) self.robot.direction = 0 #(2, 3) 'i_arms' in g.saveData self.arms = Inventory(g, 'arms') self.arms.pos((2,3)) # if you've given her arms if 'scene7' in g.saveData: self.dialog = 6 self.robot.feeling = 'arms' # if you read the newspaper, she fights you to get to the top self.newspaper = 0 if 'scene17' in g.saveData: self.newspaper = Inventory(g, "newspaper") self.newspaper.pos((6, 20)) if 'scene19' in g.saveData: self.robot.feeling = 'dead' self.robot.hidden = 1 g.run_codes(self.cdata,(0,0,g.dimentions[0],g.dimentions[1]))
def decodeInventoryEntry_level2(document): """ Entry level 2, a more complicated parsing scheme that covers examples such as 'i have 80 boxes of freshly baked pies' @document @param document : NLP Doc object :return: Status if decoded correctly (true, false), and Inventory object- """ count = Inventory(str(document)) for token in document: # Look for a preposition object that is a noun (this is the item we are counting). # If found, look at its' dependency (if a preposition that is not indicative of # inventory location, the dependency of the preposition must be a noun if token.dep_ == (u'pobj' or u'meta') and token.pos_ == (u'NOUN' or u'NNS' or u'NN'): item = '' # Go through all the token's children, these are possible adjectives and other add-ons # this deals with cases such as 'hollow rounded waffle pancakes" for i in token.children: item += ' ' + str(i) item += ' ' + str(token) count.item = item # Get the head of the item: if token.head.dep_ != u'prep': # Break out of the loop, this is a confusing entry break else: amountUnit = token.head.head count.unit = str(amountUnit) for inner in amountUnit.children: if inner.pos_ == u'NUM': count.amount += str(inner) return count
def __init__(self, position, rotation, flying=False, game_mode=G.GAME_MODE): super(Player, self).__init__(position, rotation, health=7, max_health=10, attack_power=2.0 / 3, attack_range=4) self.inventory = Inventory() self.quick_slots = Inventory(9) self.armor = Inventory(4) self.flying = flying self.game_mode = game_mode self.strafe = [0, 0] self.dy = 0 self.current_density = 1 # Current density of the block we're colliding with self.last_sector = None self.damage_block = 0, 100, 0 initial_items = [torch_block, stick_item] for item in initial_items: quantity = random.randint(2, 10) if random.choice((True, False)): self.inventory.add_item(item.id, quantity)