def set_players_speaking(player_ids, speaking):
for player_id in player_ids:
old_player = _.head(_speaking_players.where(id=player_id))
if speaking and not old_player:
new_player = DataObject(id=player_id)
_speaking_players.insert(new_player)
messages.publish(PlayerSpeakingMessage("added", new_player))
elif not speaking and old_player:
_speaking_players.remove(old_player)
messages.publish(PlayerSpeakingMessage("removed", old_player))
def insert_user(id, name, game_name, unique_id, speaking, is_me, my_channel):
if _users.where(id=id):
return
new_user = DataObject(id=id,
name=name,
game_name=game_name,
unique_id=unique_id,
speaking=speaking,
is_me=is_me,
my_channel=my_channel)
_users.insert(new_user)
messages.publish(UserMessage("added", new_user))
def update_user(id, name, game_name, unique_id, speaking, is_me, my_channel):
old_user = _.head(_users.where(id=id))
if old_user:
_users.remove(old_user)
new_user = DataObject(id=id,
name=name,
game_name=game_name,
unique_id=unique_id,
speaking=speaking,
is_me=is_me,
my_channel=my_channel)
_users.insert(new_user)
messages.publish(UserMessage("modified", new_user))
def insert_pairing(user_unique_id, player_id):
if not _pairings.where(user_unique_id=user_unique_id, player_id=player_id):
# Insert pairing
pairing = DataObject(user_unique_id=user_unique_id,
player_id=player_id)
_pairings.insert(pairing)
# Insert pair's user to cache
user = _.head(_users.where(unique_id=user_unique_id))
if user:
_cached_users.delete(unique_id=user.unique_id)
_cached_users.insert(
DataObject(unique_id=user.unique_id, name=user.name))
# Insert pair's player to cache
result = _battle_players.where(id=player_id)
if not result:
result = _prebattle_players.where(id=player_id)
if not result:
result = _me_player.where(id=player_id)
player = _.head(result)
if player:
_cached_players.delete(id=player.id)
_cached_players.insert(DataObject(id=player.id, name=player.name))
# Notify listeners
messages.publish(PairingMessage("added", pairing))
def insert_prebattle_player(id, name):
if not _prebattle_players.where(id=id):
player = DataObject(id=id, name=name)
_prebattle_players.insert(player)
messages.publish(PrebattlePlayerMessage("added", player))
def update_vehicle(id, player_id, is_alive):
if _vehicles.delete(id=id):
vehicle = DataObject(id=id, player_id=player_id, is_alive=is_alive)
_vehicles.insert(vehicle)
messages.publish(VehicleMessage("modified", vehicle))
def insert_vehicle(id, player_id, is_alive):
if not _vehicles.where(id=id):
vehicle = DataObject(id=id, player_id=player_id, is_alive=is_alive)
_vehicles.insert(vehicle)
messages.publish(VehicleMessage("added", vehicle))
def set_me_player(id, name):
_me_player.remove_many(_me_player)
player = DataObject(id=id, name=name)
_me_player.insert(player)
messages.publish(PlayerMeMessage("added", player))
def migrate_user_cache_0_6_to_0_7(source_dirpath, dest_dirpath):
"""
This function migrates tessu_mod_cache.ini to following files:
* users_cache.v1.json
* players_cache.v1.json
* pairings_cache.v1.json
"""
source_filepath = os.path.join(source_dirpath, "tessu_mod_cache.ini")
users_filepath = os.path.join(dest_dirpath, constants.USERS_CACHE_FILE)
players_filepath = os.path.join(dest_dirpath, constants.PLAYERS_CACHE_FILE)
pairings_filepath = os.path.join(dest_dirpath, constants.PAIRINGS_CACHE_FILE)
backup_filepath = os.path.join(dest_dirpath, "tessu_mod_cache.ini.old-0.6")
source_exists = os.path.isfile(source_filepath)
dest_exists = all(map(os.path.isfile, [users_filepath, players_filepath, pairings_filepath]))
if source_exists and not dest_exists:
logger.info("Migrating caches from version 0.6 to 0.7")
# Schema for new caches
users = Table()
users.create_index('unique_id', unique=True)
players = Table()
players.create_index('id', unique=True)
pairings = Table()
pairings.create_index('player_id')
pairings.create_index('user_unique_id')
# Load old 0.6.x cache file
parser = ConfigParser.ConfigParser()
with open(source_filepath, "rb") as file:
parser.readfp(file)
# Build new cache structures
users.insert_many(DataObject(unique_id=id, name=name) for name, id in parser.items("TeamSpeakUsers"))
players.insert_many(DataObject(id=int(id), name=name) for name, id in parser.items("GamePlayers"))
for user_name, player_names in parser.items("UserPlayerPairings"):
userid = _.head(users.where(name=user_name)).unique_id
for player_name in list(csv.reader([player_names]))[0]:
playerid = _.head(players.where(name=player_name)).id
pairings.insert(DataObject(player_id=int(playerid), user_unique_id=userid))
# Remove users & players which do not exist in pairings
for user in users.clone():
if not pairings.where(user_unique_id=user.unique_id):
users.remove(user)
for player in players.clone():
if not pairings.where(player_id=player.id):
players.remove(player)
# create destination directory if it doesn't exist yet
if not os.path.isdir(dest_dirpath):
os.makedirs(dest_dirpath)
# write out the new cache files
users.json_export(users_filepath)
players.json_export(players_filepath)
pairings.json_export(pairings_filepath)
# backup and remove old cache file
backup_filepath = os.path.join(dest_dirpath, os.path.basename(source_filepath)) + ".old-0.6"
if os.path.isfile(backup_filepath):
os.remove(backup_filepath)
os.rename(source_filepath, backup_filepath)