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")
