def do_run_program(player, bot, gamedata, pdb, program_id):
with pdb.connect() as conn:
player.update_lore(gamedata)
update_player(player, conn)
if program_id not in player._installed_soft:
bot.send_message(player._chat_id,
u"Нужно сперва скомпилировать программу")
return
program = gamedata._programs[program_id]
cpu_ok = (player.get_cpu() -
player.get_used_cpu(gamedata)) >= program._cpu_usage
ram_ok = (player.get_ram() -
player.get_used_ram(gamedata)) >= program._ram_usage
if cpu_ok and ram_ok:
player._running_soft.add(program_id)
player._installed_soft.remove(program_id)
update_player(player, conn)
bot.send_message(
player._chat_id,
u"Запускаю {}".format(gamedata._programs[program_id]._name))
else:
text = u"Не удалось запустить программу\n"
if not cpu_ok:
text += u"Недостаточно CPU\n"
if not ram_ok:
text += u"Недостаточно свободной памяти\n"
bot.send_message(player._chat_id, text)
def do_show_software(player, bot, gamedata, pdb):
with pdb.connect() as conn:
player.update_lore(gamedata)
update_player(player, conn)
text = u""
if player._running_soft:
text += u"Запущенные программы:\n"
for program_id in player._running_soft:
text += gamedata._programs[
program_id]._name + u" /view_{} /stop_{}\n".format(
program_id, program_id)
text += u"\n"
if player._installed_soft:
text += u"Скомпилированные программы:\n"
for program_id in player._installed_soft:
text += gamedata._programs[
program_id]._name + u" /view_{} /run_{}\n".format(
program_id, program_id)
text += u"\n"
text += u"Новые программы:\n"
for program_id in gamedata._programs:
if program_id not in player._running_soft and (
len(player._compiling_soft) == 0 or player._compiling_soft[0]
!= program_id) and program_id not in player._installed_soft:
text += gamedata._programs[
program_id]._name + u" /view_{} /compile_{}\n".format(
program_id, program_id)
bot.send_message(player._chat_id, text)
def undo_last_match():
conn, cursor = db.connect()
matches = db.get_matches(cursor)
if not matches:
return None, None, None, None
latest_match = matches[0]
if latest_match.player1_score > latest_match.player2_score:
winner = get_player(player_id=latest_match.player1_id)
winner_prev_rating = latest_match.player1_rating
loser = get_player(player_id=latest_match.player2_id)
loser_prev_rating = latest_match.player2_rating
else:
winner = get_player(player_id=latest_match.player2_id)
winner_prev_rating = latest_match.player2_rating
loser = get_player(player_id=latest_match.player1_id)
loser_prev_rating = latest_match.player1_rating
db.delete_matches(cursor, ids=[latest_match.id])
db.update_player(cursor, winner.id, new_rating=winner_prev_rating)
db.update_player(cursor, loser.id, new_rating=loser_prev_rating)
conn.commit()
conn.close()
return winner.name, winner_prev_rating, loser.name, loser_prev_rating
def do_show_mind(player, bot, gamedata, pdb):
with pdb.connect() as conn:
player.update_lore(gamedata)
update_player(player, conn)
text = u"{}\nЗнание Мира: {}\nСырое ЗМ: {}".format(
player.get_name(), player._lore, player._raw_lore)
if player._raw_lore > 0:
text += u", время обработки: {}\n".format(
format_time(player._raw_lore * 1. / player.get_cpu() * 60))
else:
text += u"\n"
text += u"""Использование памяти: {} / {}\nЗагрузка CPU: {} / {}\n""".format(
player.get_used_ram(gamedata), player.get_ram(),
player.get_used_cpu(gamedata), player.get_cpu())
text += u"Запущенных программ: {}\n".format(len(player._running_soft))
text += u"Скомпилированных программ: {}\n".format(
len(player._installed_soft))
text += u"Новых программ: {} /software".format(len(gamedata._programs))
if player._compiling_soft != []:
program = gamedata._programs[player._compiling_soft[0]]
cpu, start_time = player._compiling_soft[1:3]
ts = time.time()
progress = (ts - start_time) / (program._compile_time / cpu *
TICK_DURATION)
progress = int(progress * 100)
text += u"\nКомпиляция {} выполнена на {}%".format(
program._name, progress)
send_message(player, conn, bot, text)
def add_match(p1_id, nd1, p2_id, nd2, score_p1, score_p2):
if p1_id == p2_id or int(score_p1) == int(score_p2):
raise InvalidMatchRegistration()
p1_id += "(nd)" if nd1 else ""
p1 = get_player(p1_id)
p2_id += "(nd)" if nd2 else ""
p2 = get_player(p2_id)
if p1 and p2:
match = Match(None, p1_id, p2_id, score_p1, score_p2, p1.get_rating(),
p2.get_rating())
conn, cursor = db.connect()
db.create_match(cursor, match)
new_rating1, new_rating2 = calculate_new_elo_ratings(
rating1=p1.get_rating(),
rating2=p2.get_rating(),
player1_win=int(match.player1_score) > int(match.player2_score))
db.update_player(cursor, p1.id, new_rating=new_rating1)
db.update_player(cursor, p2.id, new_rating=new_rating2)
conn.commit()
conn.close()
new_p1 = get_player(p1.id)
new_p2 = get_player(p2.id)
updated_players = (new_p1, new_rating1 - p1.get_rating(), new_p2,
new_rating2 - p2.get_rating())
return updated_players
raise PlayerDoesNotExist()
def do_change_location(player, bot, gamedata, pdb, to_loc_id):
cur_loc_id = player._location_id
with pdb.connect() as conn:
player.set_location(to_loc_id)
try:
update_player(player, conn)
except Exception as e:
player.set_location(cur_loc_id)
raise e
do_show_map(player, bot, gamedata, pdb)
def update_display_name(player, new_name):
conn, cursor = db.connect()
players = db.get_players(cursor)
names = [p.get_name().lower() for p in players]
if new_name.lower() in names:
return False
db.update_player(cursor, player.get_id(), new_name=new_name)
conn.commit()
conn.close()
return True
def __call__(self, bot, update):
user_id = update.message.from_user.id
player = fetch_player(user_id, self._players)
if player is None:
return
player = Player(user_id, update.message.chat_id)
text = "User {} is welcome in chat {}".format(user_id, update.message.chat_id)
keyboard = [[("CONTINUE", u"Продолжить")]]
with self._players.connect() as conn:
update_player(player, conn)
send_message(player, conn, bot, text, keyboard)
logging.info("NEW_USER\t{}".format(user_id))
def do_stop_program(player, bot, gamedata, pdb, program_id):
with pdb.connect() as conn:
player.update_lore(gamedata)
update_player(player, conn)
program = gamedata._programs.get(program_id)
if program is None:
return
if program_id not in player._running_soft:
bot.send_message(player._chat_id,
u"Программа {} не запущена".format(program._name))
return
player._running_soft.remove(program_id)
player._installed_soft.add(program_id)
update_player(player, conn)
bot.send_message(player._chat_id,
u"Программа {} остановлена".format(program._name))
def do_compile_program(player, bot, gamedata, pdb, program_id):
with pdb.connect() as conn:
player.update_lore(gamedata)
update_player(player, conn)
if player._compiling_soft != []:
bot.send_message(player._chat_id,
u"Другая программа ещё компилируется")
else:
if player.compile_program(program_id, gamedata):
update_player(player, conn)
send_message(
player, conn, bot, u"Компилирую {}".format(
gamedata._programs[program_id]._name))
else:
bot.send_message(player._chat_id,
u"Недостаточно ЦП для начала компиляции")
def do_get_outcome(player, bot, gamedata, pdb, event_id, text_id, option_text,
show_descr, lore_gained):
descr, options = gamedata._texts[event_id][text_id]
outcome = choose_outcome(options[option_text])
message_parts = list()
if show_descr:
message_parts.append(descr)
if outcome._message:
message_parts.append(outcome._message)
message = u" ".join(message_parts) + u"\n"
outcome_id = outcome._outcome_id
if outcome_id is not None:
if outcome_id.startswith("i_"):
if outcome_id not in gamedata._items:
bot.send_message(player._chat_id,
u"Unknown item: {}".format(outcome_id))
else:
item = gamedata._items[outcome_id]
message += u"...\nНаходка! {} ({}) /view_{}".format(
item._name, outcome._cnt, outcome_id)
backpack = player._avatar._backpack
free_weight = backpack._max_weight - backpack.get_weight(
gamedata)
taken_count = int(min(free_weight / item._weight,
outcome._cnt))
if taken_count > 0:
backpack.insert_item(outcome_id, taken_count)
message += u"\n{} ({}) помещён(-а) в рюкзак".format(
item._name, taken_count)
if taken_count < outcome._cnt:
message += u"\n{} {} не поместился(-ась) в рюкзак".format(
outcome._cnt - taken_count, item._name)
lore_for_new_item = player.get_lore_for_new_entity(
outcome_id, gamedata)
if lore_for_new_item > 0:
message += u"\nПолучено {} ЗМ за находку".format(
lore_for_new_item)
else:
message += outcome_id
if lore_gained > 0:
message += u"\nПолучено {} ЗМ за исследование".format(lore_gained)
keyboard = get_show_venues_keyboard(player, gamedata)
with pdb.connect() as conn:
update_player(player, conn)
send_message(player, conn, bot, message, keyboard)
def post(self):
user_id = users.get_current_user().user_id()
first_name = self.request.get('first_name')
last_name = self.request.get('last_name')
psn_id = self.request.get('psn_id')
list_me = self.request.get('list_me') == 'on'
telegram = self.request.get('telegram')
bungie = self.request.get('bungie')
dtr = self.request.get('dtr')
youtube = self.request.get('youtube')
twitch = self.request.get('twitch')
player = db.find_player(user_id)
if player is None:
db.add_player(user_id, first_name, last_name, psn_id, telegram, bungie, dtr, youtube, twitch, list_me)
self.redirect('/')
else:
db.update_player(player, first_name, last_name, psn_id, telegram, bungie, dtr, youtube, twitch, list_me)
self.redirect('/players')
def post(self):
user_id = users.get_current_user().user_id()
first_name = self.request.get("first_name")
last_name = self.request.get("last_name")
psn_id = self.request.get("psn_id")
list_me = self.request.get("list_me") == "on"
telegram = self.request.get("telegram")
bungie = self.request.get("bungie")
dtr = self.request.get("dtr")
youtube = self.request.get("youtube")
twitch = self.request.get("twitch")
player = db.find_player(user_id)
if player is None:
db.add_player(user_id, first_name, last_name, psn_id, telegram, bungie, dtr, youtube, twitch, list_me)
self.redirect("/")
else:
db.update_player(player, first_name, last_name, psn_id, telegram, bungie, dtr, youtube, twitch, list_me)
self.redirect("/players")
def post(self):
user_id = users.get_current_user().user_id()
first_name = self.request.get('first_name')
last_name = self.request.get('last_name')
psn_id = self.request.get('psn_id')
list_me = self.request.get('list_me') == 'on'
telegram = self.request.get('telegram')
bungie = self.request.get('bungie')
dtr = self.request.get('dtr')
youtube = self.request.get('youtube')
twitch = self.request.get('twitch')
player = db.find_player(user_id)
if player is None:
db.add_player(user_id, first_name, last_name, psn_id, telegram,
bungie, dtr, youtube, twitch, list_me)
self.redirect('/')
else:
db.update_player(player, first_name, last_name, psn_id, telegram,
bungie, dtr, youtube, twitch, list_me)
self.redirect('/players')
def do_explore(player, bot, gamedata, pdb):
loc = gamedata._map[player._location_id]
venue_id = choose_outcome(loc._events)
if venue_id not in gamedata._venues:
bot.send_message(player._chat_id,
"Missing venue {}".format(venue_id.encode("utf8")))
logging.error("Missing venue {}".format(venue_id.encode("utf8")))
return
researched = min(loc._research_rate,
100 - player._research_percent[player._location_id])
lore_gained = int(researched * 0.1 * player.get_cpu())
if researched > 0:
with pdb.connect() as conn:
player.update_lore(gamedata)
player._raw_lore += lore_gained
player._lore_last_update = time.time()
player._research_percent[player._location_id] += researched
update_player(player, conn)
event_id = choose_outcome(gamedata._venues[venue_id]._events)
resolve_event(player, bot, gamedata, pdb, event_id, lore_gained)
def update_player(player_id: uuid.UUID, player: Player):
try:
db.update_player(player_id, player)
except KeyError:
raise HTTPException(status_code=HTTP_404_NOT_FOUND)
