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)
