def claimed_loots(self):
"""Return a list of loot based on the rank of the player"""
#TODO: prendre en compte le débordement d'inventaire avec courier
recipes_1 = [tool.recipe for tool in self.rank.gain_tools]
upgraders_1 = [
Item.by_name(f'upgrader_{min(self.rank.index,5)}'),
]
recipes_2 = [tool.recipe for tool in self.rank.allowed_tools]
upgraders_2 = [
Item.by_name(f'upgrader_{i}')
for i in range(min(self.rank.index, 5) + 1)
]
loots = {}
for i in range(random.randint(3, 5)): # 1 + 2-4
recipe_list = recipes_1 if (i == 0) else recipes_2
upgrader_list = upgraders_1 if (i == 0) else upgraders_2
if (random.random() < 0.1): # 10%
loot = Item.weighted_choice(recipe_list)
else:
loot = Item.weighted_choice(upgrader_list)
if loot in loots:
loots[loot] += 1
else:
loots[loot] = 1
return Stack.to_stack_list(loots)
def allowed_tools(self):
try:
# tool_names = self.pre_rank.allowed_tools + self._allowed_tools
return self.pre_rank.allowed_tools + [
Item.by_name(name) for name in self._allowed_tools
]
except:
# tool_names = self._allowed_tools
return [Item.by_name(name) for name in self._allowed_tools]
async def unequip(self, ctx, item_id):
_item = Item(item_id)
_user = User(ctx.message.author.id)
if _user.is_Registered is False:
await self.bot.say(self.errors.USER_NOT_IN_DB)
return
if _item.exists is False:
await self.bot.say(self.errors.ITEM_NOT_EXIST)
return
if len(_user.get_user_item(item_id)) == 0 and len(
_user.get_user_badge(item_id)) == 0:
await self.bot.say(self.errors.ITEM_DONT_OWN)
return
try:
if _user.get_user_item(item_id)[0][2] == 0:
await self.bot.say(self.errors.NOT_EQUIPPED)
return
except:
if _user.get_user_badge(item_id)[0][2] == 0:
await self.bot.say(self.errors.NOT_EQUIPPED)
return
if _item.kind == 3:
_user.unequip_badge(item_id)
else:
_user.unequip_item(item_id)
await self.bot.say(self.msg.ITEM_UNEQUIPPED)
async def myitems(self, ctx):
_user = User(ctx.message.author.id)
if _user.is_Registered is False:
await self.bot.say(self.errors.USER_NOT_IN_DB)
return
items = _user.user_items
user_items = []
for item_id in items:
_item = Item(item_id)
conc = f"`{_item.name}` | ID: `{item_id}`"
user_items.append(conc)
msg = ""
for i in user_items:
msg += f"{i}\n"
if len(msg) == 0:
msg = f"No items in your inventory. Buy some items at `{self.configs.PREFIX}shop`!"
embed = discord.Embed(description="This is your backpack! 🎒",
color=self.themes.MAIN_COL)
embed.set_author(name=f"{ctx.message.author.name}'s Inventory",
icon_url=ctx.message.author.avatar_url)
embed.add_field(name="Inventory", value=msg)
embed.set_footer(
text=f"Use {self.configs.PREFIX}equip <Item_ID> to equip an item.")
await self.bot.say(embed=embed)
async def sell(self, ctx, item_id):
_item = Item(item_id)
_user = User(ctx.message.author.id)
if _user.is_Registered is False:
await self.bot.say(self.errors.USER_NOT_IN_DB)
return
if _item.exists is False:
await self.bot.say(self.errors.ITEM_NOT_EXIST)
return
if len(_user.get_user_item(item_id)) == 0:
await self.bot.say(self.errors.ITEM_DONT_OWN)
return
if _item.kind == 3:
await self.bot.say("❌ | Badges cannot be sold.")
cost = _item.cost
give_back = cost * 0.20
_user.delete_user_item(item_id)
_user.add_money(int(give_back))
await self.bot.say(self.msg.SELL_STR.format(int(give_back)))
async def purgebadge(self, ctx, user: discord.Member, badge):
_user = User(user.id)
_item = Item(badge)
if _user.is_Registered is False:
await self.bot.say(self.errors.USER_NOT_IN_DB)
return
if _item.exists is False:
await self.bot.say(self.errors.ITEM_NOT_EXIST)
return
if _item.kind != 3:
await self.bot.say("❌ | Item is not a badge.")
return
try:
if len(_user.get_user_badge(badge)) == 0:
await self.bot.say(self.errors.ITEM_DONT_OWN)
return
except:
pass
_user.purge_user_badge(badge)
await self.bot.say(f"You purged **{_item.name}** from {user.mention}.")
def swap_stack(self, idx_1, idx_2):
"""Swap two stacks, if boths stacks have same items, fill a stack with the other"""
stack_1 = self._inventory.get(str(idx_1), None)
stack_2 = self._inventory.get(str(idx_2),
None) # move stack_1 TO stack_2
# merge two stacks if same stack
if (stack_1 is not None) and (stack_2 is not None):
if stack_1['item_name'] == stack_2['item_name']:
item = Item.by_name(stack_1['item_name'])
place_left = (item.stack_size - stack_2['quantity'])
if stack_1['quantity'] > place_left:
stack_1['quantity'] -= place_left
stack_2['quantity'] = item.stack_size
else:
stack_2['quantity'] += stack_1['quantity']
stack_1 = None
return
else:
self._inventory[str(idx_1)] = stack_2
self._inventory[str(idx_2)] = stack_1
if (stack_1 is not None) ^ (stack_2 is not None):
if stack_2 is not None:
self._inventory[str(idx_1)] = stack_2
else:
del self._inventory[str(idx_1)]
if stack_1 is not None:
self._inventory[str(idx_2)] = stack_1
else:
del self._inventory[str(idx_2)]
async def grantbadge(self, ctx, user: discord.Member, badge):
_user = User(user.id)
_item = Item(badge)
if _user.is_Registered is False:
await self.bot.say(self.errors.USER_NOT_IN_DB)
return
if _item.exists is False:
await self.bot.say(self.errors.ITEM_NOT_EXIST)
return
if _item.kind != 3:
await self.bot.say("❌ | Item is not a badge.")
return
try:
if badge == _user.get_user_badge(badge)[0][1]:
await self.bot.say(self.errors.ALREADY_OWNED)
return
except:
pass
_user.store_badge(badge)
await self.bot.say(
f"You gave {user.mention} the badge **{_item.name}**.")
def add_item():
global items
item_name = request.args.get('itemName')
price = request.args.get('Price')
item_url = request.args.get('itemUrl')
description = request.args.get('comment')
item = Item(item_name, price, item_url, description)
items.append(item)
return Response("", 204)
def random_loot(self):
loot_weight = {
item_name: Item.by_name(item_name).frequency
for item_name in self.tool_used.item.loots
}
luck = self.get('stats')['luck']
apply_luck(loot_weight, luck)
summ = sum([weight for weight in loot_weight.values()])
offset = random.random() * summ
for item_name, weight in loot_weight.items():
if offset < weight:
return Stack(item_name, 1)
offset -= weight
async def equip(self, ctx, item_id):
_item = Item(item_id)
_user = User(ctx.message.author.id)
if _user.is_Registered is False:
await self.bot.say(self.errors.USER_NOT_IN_DB)
return
if _item.exists is False:
await self.bot.say(self.errors.ITEM_NOT_EXIST)
return
if len(_user.get_user_item(item_id)) == 0 and len(
_user.get_user_badge(item_id)) == 0:
await self.bot.say(self.errors.ITEM_DONT_OWN)
return
try:
if _user.get_user_item(item_id)[0][2] == 1:
await self.bot.say(self.errors.ALREADY_EQUIPPED)
return
except:
if _user.get_user_badge(item_id)[0][2] == 1:
await self.bot.say(self.errors.ALREADY_EQUIPPED)
return
if _user.equipped_background is not None and _item.kind == 0: # if background
_user.unequip_item(_user.equipped_background)
if _user.equipped_badge is not None and _item.kind == 3: #if badge
_user.unequip_badge(_user.equipped_badge)
if _item.kind == 3:
_user.equip_badge(item_id)
else:
_user.equip_item(item_id)
await self.bot.say(self.msg.ITEM_EQUIPPED)
async def buy(self, ctx, item_id):
_user = User(ctx.message.author.id)
_item = Item(item_id)
if _user.is_Registered is False:
await self.bot.say(self.errors.USER_NOT_IN_DB)
return
if _item.exists is False:
await self.bot.say(self.errors.ITEM_NOT_EXIST)
return
try:
if item_id == _user.get_user_item(item_id)[0][1]:
await self.bot.say(self.errors.ALREADY_OWNED)
return
except:
try:
if item_id == _user.get_user_badge(item_id)[0][1]:
await self.bot.say(self.errors.ALREADY_OWNED)
return
except:
pass
cost = _item.cost
if _user.money < cost:
await self.bot.say(self.errors.INSUF_MONEY)
return
if _item.kind == 3:
_user.store_badge(item_id)
else:
_user.put_background(item_id)
_user.add_money(-cost)
await self.bot.say(self.msg.ITEM_INV)
def frequency(self):
return Item.by_name(self.result).frequency * 2
class Room(object):
def __init__(self, roomType, enemies, items, obstructions=stdObstructions):
self.type = roomType
self.enemies = enemies
self.items = items
self.obstructions = obstructions
self.doors = []
# START
start = Room("standard",[],[],[])
# STANDARD
standard = [
Room("standard", [Enemy("apple")], []),
Room("standard", [Enemy("apple"), Enemy("cherry")],[Item(1)]),
Room("standard", [Enemy("cherry"), Enemy("cherry")], [Item(1,25),Item(0,-25)]),
Room("standard", [Spawner("banana")], [])
]
# SHOP
shop = [
Room("shop", [], [Item(3)]),
Room("shop", [], [Item(4)])
]
# DISH
dish = [
Room("dish", [], [Item(0,-5,-10)])
]
def recipe(self):
"""Return the recipe of the current equipment"""
parts = self.name.split('_')
parts.insert(len(parts) - 1, 'recipe')
recip_name = '_'.join(parts)
return Item.by_name(recip_name)
}
}
node_factory.create_new_node({
'db_position': position,
'instance_components': {
"components": json.dumps(component_data)
}
})
with session_manager.get_session() as session:
_, node_factory, node_factory_db, object_db, player_factory, account_utils = setup_objects(
all_db_components, all_components, session)
object_db.set_session(session)
session.add(Item("iron ore", 'ore'))
session.add(Item("silver ore", 'ore'))
session.add(Item("gold ore", 'ore'))
session.add(Item("trishot", 'upgrade'))
session.add(Item("health", 'upgrade'))
create_spacestation(node_factory_db,
position={
"x": 0,
"y": -200
},
radius=200)
create_shop(node_factory_db, {"x": 0, "y": -200}, session)
def display_name(self):
return narr('item.equipment_recipe.name').format(
item_name=Item.by_name(self.result).display_name)
def description(self):
return narr('item.equipment_recipe.desc').format(
item_name=Item.by_name(self.result).display_name,
quantity=self.result_quantity)
def gain_tools(self):
return [Item.by_name(name) for name in self._allowed_tools]
def generate_recipe(self):
"""Generate a recip base on the generation values of the item then return a dict that contain all the ingredients"""
desired_rarity = Item.by_name(
self.result).rarity * self.result_quantity
resource_to_use = [item() for item in Item.resources()]
resource_to_use = resource_to_use[(self.min_resource_level) *
7:(self.max_resource_level + 1) * 7]
resource_to_use = [
item for item in resource_to_use
if (self.min_ratio_per_resource <= (
item.rarity / desired_rarity) <= self.max_ratio_per_resource)
]
final_recipe = {} # key = item | value = quantity
while desired_rarity > 0:
if len(final_recipe
) < self.max_ingredients: # use the same ingredients
if len(final_recipe) < self.min_ingredients:
resource_to_use_this_turn = [
item for item in resource_to_use
if (item.rarity < desired_rarity) and (
item not in final_recipe)
]
else:
resource_to_use_this_turn = [
item for item in resource_to_use
if (item.rarity < desired_rarity)
]
if len(resource_to_use_this_turn) > 0:
if len(
final_recipe
) < self.max_ingredients: # ici on ne prend pas un aléatoire avec poid pour pouvoir sortir des ressources rare dans la recette
actual_resource = random.choice(
resource_to_use_this_turn)
else:
actual_resource = self._weighted_choice(
resource_to_use_this_turn
) # choice(resource_to_use_this_turn)
else:
actual_resource = sorted(resource_to_use,
key=lambda x: x.rarity)[0]
else:
resource_to_use_this_turn = [
item for item in final_recipe.keys()
if (item.rarity < desired_rarity)
]
if len(resource_to_use_this_turn) > 0:
actual_resource = self._weighted_choice(
resource_to_use_this_turn
) # choice(resource_to_use_this_turn)
else:
actual_resource = sorted(final_recipe.keys(),
key=lambda x: x.rarity)[0]
if actual_resource in final_recipe:
final_recipe[actual_resource] += 1
else:
final_recipe[actual_resource] = 1
desired_rarity -= actual_resource.rarity
return {
item.name: quantity
for item, quantity in sorted(final_recipe.items(),
key=lambda tup: tup[0])
}
"area": {"radius": 100},\
"position": "db_position",\
"force": {},\
"acceleration": {},\
"server_updated": {},\
"physics_update": {},\
"state_history": {}\
}'
}
})
if i % 100:
print("Created " + str(i) + " asteroids")
with session_manager.get_session() as session:
_, node_factory, node_factory_db, object_db, player_factory, account_utils = setup_objects(
all_db_components, all_components, session)
object_db.set_session(session)
session.add(Item("iron ore"))
session.add(Item("silver ore"))
session.add(Item("gold ore"))
session.add(Item("iron"))
session.add(Item("silver"))
session.add(Item("gold"))
session.add(Item("gasoline"))
create_asteroids(node_factory_db, session)
create_planets(node_factory_db, session)