def player_death(game_event):
"""Executes kill, assist and death skills.
Also gives exp from kill and assist.
"""
# Get the attacker, defender and assister
defender = get_player(game_event.get_int('userid'))
attacker = get_player(game_event.get_int('attacker'))
assister = get_player(game_event.get_int('assister'))
# Create the event arguments dict
eargs = {
'attacker': attacker,
'defender': defender,
'assister': assister,
'headshot': game_event.get_bool('headshot'),
'weapon': game_event.get_string('weapon')
}
# If it was a suicide
if defender == attacker:
# Execute suicide skills
defender.hero.execute_skills('player_suicide',
player=defender,
**eargs)
# If it wasn't...
else:
# Execute kill and death skills
attacker.hero.execute_skills('player_kill', player=attacker, **eargs)
defender.hero.execute_skills('player_death', player=defender, **eargs)
# Give attacker exp from kill and headshot
give_exp(attacker, 'Kill')
if eargs['headshot']:
give_exp(attacker, 'Headshot')
# Give attacker gold from kill
give_gold(attacker, 'Kill')
# If the assister exists
if assister:
# Execute assist skills
assister.hero.execute_skills('player_assist', player=assister, **eargs)
# Give assister exp and gold
give_exp(assister, 'Assist')
give_gold(assister, 'Assist')
# Finally, remove defender's items
for item in defender.hero.items:
if not item.permanent:
defender.hero.items.remove(item)
def _buy_hero_categories_build_callback(menu, player_index):
"""Buy Hero Categories menu's build_callback function."""
player = get_player(player_index, key='index')
menu.entities = []
for hero_cls in Hero.get_subclasses():
if find_element(player.heroes, 'cls_id', hero_cls.cls_id):
continue
elif (hero_cls.allowed_users
and player.steamid not in hero_cls.allowed_users):
continue
menu.entities.append(hero_cls)
menu.clear()
categories = dict()
for entity in menu.entities:
if entity.category not in categories:
categories[entity.category] = [entity]
else:
categories[entity.category].append(entity)
for category in categories:
menu.append(PagedOption('{category} ({size})'.format(
category=category,
size=len(categories[category])
), categories[category]
))
def _buy_item_categories_build_callback(menu, player_index):
"""Buy Hero Categories menu's build_callback function."""
player = get_player(player_index, key='index')
menu.entities = []
for item in Item.get_subclasses():
if (len(tuple(find_elements(player.hero.items, 'cls_id', item.cls_id)))
>= item.limit):
continue
elif (item.allowed_users and player.steamid not in item.allowed_users):
continue
menu.entities.append(item)
menu.clear()
categories = dict()
for entity in menu.entities:
if entity.category not in categories:
categories[entity.category] = [entity]
else:
categories[entity.category].append(entity)
for category in categories:
menu.append(PagedOption('{category} ({size})'.format(
category=category,
size=len(categories[category])
), categories[category]
))
def round_end(game_event):
"""Give exp from round win and loss.
Also executes round_end skills.
"""
# Get the winning team
winner = game_event.get_int('winner')
# Loop through all the players' userids
for userid in PlayerIter(is_filters=('ct', 't'), return_types='userid'):
# Get the player
player = get_player(userid)
# Give player win exp and gold
if player.get_team() == winner:
give_exp(player, 'Round Win')
give_gold(player, 'Round Win')
# Or loss exp and gold
else:
give_exp(player, 'Round Loss')
give_gold(player, 'Round Loss')
# Execute hero's round_end skills
player.hero.execute_skills('round_end', player=player, winner=winner)
def player_say(game_event):
"""Executes ultimate skills and opens the menu."""
# Get the player and the text
player = get_player(game_event.get_int('userid'))
text = game_event.get_string('text')
# If text doesn't begin with the prefix, it's useless for us
if text[:len(cfg.chat_command_prefix)] != cfg.chat_command_prefix:
return
# Get the ACTUAL text without the prefix
text2 = text[len(cfg.chat_command_prefix):]
# If the text was '!ultimate', execute ultimate skills
if text2 == 'ultimate':
Player_Ultimate(index=player.index, userid=player.userid).fire()
# If the text was '!hw' or '!hw', open Main menu
elif text2 in ('hw', 'hw'):
menus['Main'].send(player.index)
elif text2 == 'admin':
menus['Admin'].send(player.index)
# Finally, execute hero's player_say skills
player.hero.execute_skills('player_say', player=player, text=text)
def player_spawn(game_event):
"""Creates new players and saves existing players' data.
Also executes spawn skills and shows current exp/level progress.
"""
# Get the player
userid = game_event.get_int('userid')
player = get_player(userid)
# If the player was found
if player:
# Save his data
save_player_data(cfg.database_path, player)
# If the player wasn't found
else:
# Create a new player
player = create_player(userid)
# Get player's hero
hero = player.hero
# Show current exp and level
other_messages['Hero Status'].send(player.index,
name=hero.name,
level=hero.level,
current=hero.exp,
required=hero.required_exp)
# Execute spawn skills if the player's on a valid team
if player.team > 1:
hero.execute_skills('player_spawn', player=player)
def _current_hero_build_callback(menu, player_index):
"""Current Hero menu's build_callback function."""
# Get player and hero
player = get_player(player_index, key='index')
hero = player.hero
# Set menu's base attributes
menu.title = hero.name
menu.description = _TR['Description'].get_string(
level=hero.level,
skill_points=hero.skill_points
)
# Clear the menu
menu.clear()
# Loop through hero's skills
for skill in hero.skills:
# Set the default arguments for the PagedOption
info = '{0}/{1}'.format(skill.level, skill.max_level)
selectable = True
# If skill is already maxed out
if skill.level >= skill.max_level:
info = ' ({0})'.format(_translate_text(
_TR['Maxed'],
player_index
))
selectable = False
# If the hero hasn't reached skill's required level
elif skill.required_level > hero.level:
info += ' ({0})'.format(_translate_text(
_TR['Required'].get_string(
required=skill.required_level
),
player_index
))
selectable = False
# If skill costs more than one, show the cost
elif skill.cost > 1:
info += ' ({0})'.format(_translate_text(
_TR['Cost'].get_string(cost=skill.cost),
player_index
))
# And if hero doesn't have enough skill points, disable skill
if skill.cost > hero.skill_points:
selectable = False
# Add the PagedOption to the menu
menu.append(PagedOption(
'{0} {1}'.format(skill.name, info),
skill,
selectable=selectable,
highlight=selectable
))
def player_hurt(game_event):
"""Executes attack and defend skills."""
# Get defender and attacker
defender = get_player(game_event.get_int('userid'))
attacker = get_player(game_event.get_int('attacker'))
# Create event arguments dict
eargs = {
'attacker': attacker,
'defender': defender,
'damage': game_event.get_int('dmg_health'),
'damage_armor': game_event.get_int('dmg_armor'),
'weapon': game_event.get_string('weapon')
}
# Execute attack and defend skills
attacker.hero.execute_skills('player_attack', player=attacker, **eargs)
defender.hero.execute_skills('player_defend', player=defender, **eargs)
def _sell_items_build_callback(menu, player_index):
"""Sell Items menu's build_callback function."""
player = get_player(player_index, key='index')
menu.clear()
for item in player.hero.items:
menu.append(PagedOption('{name} (+${sell_value})'.format(
name=item.name,
sell_value=item.sell_value
), item
))
def round_start(game_event):
"""Executes round_start skills."""
# Loop through all the players' userids
for userid in PlayerIter(is_filters=('ct', 't'), return_types='userid'):
# Get the player
player = get_player(userid)
# Execute hero's round_end skills
player.hero.execute_skills('round_start', player=player, winner=winner)
def _hero_buy_info_select_callback(menu, player_index, choice):
"""Hero Buy Info menu's select_callback function."""
if choice.value == 7:
player = get_player(player_index, key='index')
if player.gold > menu.hero.cost:
hero = menu.hero()
player.gold -= hero.cost
player.heroes.append(hero)
player.hero = hero
print('changed hero to '+hero.name) # TODO: Temporary
def hostage_rescued(game_event):
"""Give exp from hostage rescue.
Also executes hostage_rescued skills.
"""
player = get_player(game_event.get_int('userid'))
give_exp(player, 'Hostage Rescue')
give_team_exp(player, 'Hostage Rescue Team')
# Execute hero's hostage_rescued skills
player.hero.execute_skills('hostage_rescued', player=player)
def hostage_follows(game_event):
"""Give exp from hostage pick up.
Also executes hostage_follows skills.
"""
player = get_player(game_event.get_int('userid'))
give_exp(player, 'Hostage Pick Up')
give_team_exp(player, 'Hostage Pick Up Team')
# Execute hero's hostage_follows skills
player.hero.execute_skills('hostage_follows', player=player)
def bomb_defused(game_event):
"""Give exp from bomb defusion.
Also executes bomb_defused skills.
"""
player = get_player(game_event.get_int('userid'))
give_exp(player, 'Bomb Defuse')
give_team_exp(player, 'Bomb Defuse Team')
# Execute hero's bomb_defused skills
player.hero.execute_skills('bomb_defused', player=player)
def bomb_planted(game_event):
"""Give exp from bomb planting.
Also executes bomb_planted skills.
"""
player = get_player(game_event.get_int('userid'))
give_exp(player, 'Bomb Plant')
give_team_exp(player, 'Bomb Plant Team')
# Execute hero's bomb_planted skills
player.hero.execute_skills('bomb_planted', player=player)
def _current_hero_select_callback(menu, player_index, choice):
"""Current Hero menu's select_callback function."""
player = get_player(player_index, key='index')
if choice.value == 7:
for skill in player.hero.skills:
skill.level = 0
else:
skill = choice.value
if (skill.cost <= player.hero.skill_points
and skill.required_level <= player.hero.level
and skill.level < skill.max_level):
skill.level += 1
return menu
def _owned_heroes_build_callback(menu, player_index):
"""Owned Heroes menu's build_callback function."""
player = get_player(player_index, key='index')
menu.clear()
for hero in player.heroes:
option = PagedOption(
'{0} {1}/{2}'.format(
hero.name, hero.level, hero.max_level
),
hero
)
menu.append(option)
def _admin_build_callback(menu, player_index):
"""Admin menu's build_callback function."""
player = get_player(player_index, key='index')
menu.clear()
if player.steamid in admins:
menu.extend([
Text('Admin'),
SimpleOption(1, 'Player Management', menus['Admin Players Menu'])
])
else:
menu.append(Text('Not an admin!'))
def give_team_exp(player, exp_key):
"""Gives exp for player's teammates.
Args:
player: Player whose teammates to give exp to
exp_key: Key used for finding the exp value and translation
"""
# Give all his teammates exp
team = player.team == 2 and 't' or 'ct'
for userid in PlayerIter(is_filters=team, return_types='userid'):
if userid != player.userid:
teammate = get_player(userid)
give_exp(teammate, exp_key)
def _buy_heroes_build_callback(menu, player_index):
"""Buy Heroes menu's build_callback function."""
player = get_player(player_index, key='index')
menu.clear()
for hero_cls in menu.entities:
option = PagedOption(
'{0} ({1})'.format(
hero_cls.name,
_translate_text(
_TR['Cost'].get_string(cost=hero_cls.cost),
player_index
)
),
hero_cls
)
if hero_cls.cost > player.gold:
option.selectable = option.highlight = False
menu.append(option)
def _buy_items_build_callback(menu, player_index):
"""Buy Items menu's build_callback function."""
player = get_player(player_index, key='index')
menu.clear()
for item in menu.entities:
option = PagedOption(
'{name} (${cost})\n{description}'.format(
name=item.name,
cost=_translate_text(
_TR['Cost'].get_string(cost=item.cost),
player_index
),
description=item.description
),
item
)
if item.cost > player.gold:
option.selectable = option.highlight = False
menu.append(option)
def hero_level_up(game_event):
"""Sends hero's status to player and opens current hero menu.
Also executes hero_level_up skills.
"""
# Get the player and his hero
player = get_player(game_event.get_int('player_userid'))
hero = player.hero
# Send hero's status via chat
other_messages['Hero Status'].send(player.index,
name=hero.name,
level=hero.level,
current=hero.exp,
required=hero.required_exp)
# Open current hero info menu (Kamiqawa, what?) to let the player
# spend skill points
menus['Current Hero'].send(player.index)
# Execute player_level_up skills
player.hero.execute_skills('hero_level_up', player=player, hero=hero)
def player_ultimate(game_event):
"""Executes ultimate skills."""
userid = game_event.get_int('userid')
player = get_player(userid)
player.hero.execute_skills('player_ultimate', player=player)
def _main_build_callback(menu, player_index):
"""Main menu's build_callback function."""
player = get_player(player_index, key='index')
menu[1].text.get_string(gold=player.gold)
def _hero_owned_info_select_callback(menu, player_index, choice):
"""Hero Owned Info menu's select_callback function."""
if choice.value == 7:
player = get_player(player_index, key='index')
player.hero = menu.hero
print('changed hero to '+player.hero.name)
def player_jump(game_event):
"""Executes jump skills."""
player = get_player(game_event.get_int('userid'))
player.hero.execute_skills('player_jump', player=player)
def player_disconnect(game_event):
"""Removes a player and saves his data upon disconnection."""
userid = game_event.get_int('userid')
player = get_player(userid)
remove_player(player)
def _sell_items_select_callback(menu, player_index, choice):
"""Sell Items menu's select_callback function."""
player = get_player(player_index, key='index')
player.hero.items.remove(choice.value)
player.cash += choice.value.sell_value
def _buy_items_select_callback(menu, player_index, choice):
"""Buy Items menu's select_callback function."""
player = get_player(player_index, key='index')
player.hero.items.append(choice.value())
player.cash -= choice.value.cost
