mirror of https://github.com/dirtbags/moth.git
451 lines
13 KiB
Python
Executable File
451 lines
13 KiB
Python
Executable File
#! /usr/bin/env python3
|
|
|
|
import json
|
|
import asyncore
|
|
import asynchat
|
|
import socket
|
|
import traceback
|
|
import time
|
|
from errno import EPIPE
|
|
from . import teams
|
|
from . import Flagger
|
|
|
|
|
|
# Heartbeat frequency (in seconds)
|
|
pulse = 2.0
|
|
|
|
##
|
|
## Network stuff
|
|
##
|
|
|
|
class Listener(asyncore.dispatcher):
|
|
def __init__(self, addr, player_factory, manager):
|
|
asyncore.dispatcher.__init__(self)
|
|
self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
|
|
self.set_reuse_addr()
|
|
self.bind(addr)
|
|
self.listen(4)
|
|
self.player_factory = player_factory
|
|
self.manager = manager
|
|
|
|
def handle_accept(self):
|
|
conn, addr = self.accept()
|
|
player = self.player_factory(conn, self.manager)
|
|
# We don't need to keep the player, asyncore.socket_map already
|
|
# has a reference to it for as long as it's open.
|
|
|
|
def readable(self):
|
|
self.manager.heartbeat(time.time())
|
|
return True
|
|
|
|
|
|
class Manager:
|
|
"""Contest manager.
|
|
|
|
When a player connects and registers, they enter the lobby. As soon
|
|
as there are enough players in the lobby to run a game, everyone in
|
|
the lobby becomes a contestant. Contestants are assigned to games.
|
|
When the game declares a winner, the winner is added back to the list
|
|
of contestants, and other players are sent back to the lobby. When
|
|
a winner is declared by the last running game, that winner gets the
|
|
flag.
|
|
|
|
"""
|
|
|
|
def __init__(self, game_factory, flagger, minplayers, maxplayers=None):
|
|
self.game_factory = game_factory
|
|
self.flagger = flagger
|
|
self.minplayers = minplayers
|
|
self.maxplayers = maxplayers or minplayers
|
|
self.games = set()
|
|
self.lobby = set()
|
|
self.contestants = []
|
|
self.last_beat = 0
|
|
self.timers = set()
|
|
|
|
def heartbeat(self, now):
|
|
"""Called by listener to beat heart."""
|
|
|
|
now = time.time()
|
|
if now > self.last_beat + pulse:
|
|
for game in list(self.games):
|
|
game.heartbeat(now)
|
|
self.last_beat = now
|
|
for event in self.timers:
|
|
when, cb = event
|
|
if now >= when:
|
|
self.timers.remove(event)
|
|
cb()
|
|
|
|
def add_timer(self, when, cb):
|
|
"""Add a timed callback."""
|
|
|
|
self.timers.add((when, cb))
|
|
|
|
def enter_lobby(self, player):
|
|
self.lobby.add(player)
|
|
self.run_contest()
|
|
|
|
def add_contestant(self, player):
|
|
self.contestants.append(player)
|
|
self.run_contest()
|
|
|
|
def disconnect(self, player):
|
|
"""Player has disconnected."""
|
|
|
|
pass
|
|
|
|
def set_flag(self, player):
|
|
"""Player has the flag."""
|
|
|
|
self.flagger.set_flag(player.name)
|
|
|
|
def start_contest(self):
|
|
"""Start a new contest."""
|
|
|
|
self.contestants = list(self.lobby)
|
|
print('new playoff:', [c.name for c in self.contestants])
|
|
|
|
def run_contest(self):
|
|
# Purge any disconnected players
|
|
self.contestants = [p for p in self.contestants if p.connected]
|
|
self.lobby = set([p for p in self.lobby if p.connected])
|
|
|
|
llen = len(self.lobby)
|
|
clen = len(self.contestants)
|
|
glen = len(self.games)
|
|
if llen == 1:
|
|
# Give the flag to the only team connected
|
|
self.set_flag(list(self.lobby)[0])
|
|
elif llen < self.minplayers:
|
|
# More than one connected team, but still not enough to play
|
|
self.set_flag(None)
|
|
elif (clen == 1) and (glen == 0):
|
|
# Give the flag to the last team standing, and start a new contest
|
|
self.set_flag(self.contestants.pop())
|
|
self.start_contest()
|
|
elif (llen >= self.minplayers) and (clen == 0) and (glen == 0):
|
|
# There are enough in the lobby to begin a contest now
|
|
self.start_contest()
|
|
|
|
while len(self.contestants) >= self.minplayers:
|
|
players = self.contestants[:self.maxplayers]
|
|
del self.contestants[:self.maxplayers]
|
|
game = self.game_factory(self, set(players))
|
|
self.games.add(game)
|
|
for player in players:
|
|
player.attach_game(game)
|
|
|
|
def declare_winner(self, game, winner=None):
|
|
print('Winner:', winner and winner.name)
|
|
self.games.remove(game)
|
|
|
|
# Winner stays in the contest
|
|
if winner:
|
|
self.add_contestant(winner)
|
|
|
|
def player_cmd(self, args):
|
|
cmd = args[0].lower()
|
|
if cmd == 'lobby':
|
|
return [p.name for p in self.lobby]
|
|
elif cmd == 'games':
|
|
return len(self.games)
|
|
elif cmd == 'flag':
|
|
return self.flagger.flag
|
|
else:
|
|
raise ValueError('Unrecognized manager command')
|
|
|
|
|
|
class Player(asynchat.async_chat):
|
|
# How long can a connection not send anything at all (unless blocked)?
|
|
timeout = 10.0
|
|
|
|
def __init__(self, sock, manager):
|
|
asynchat.async_chat.__init__(self, sock=sock)
|
|
self.manager = manager
|
|
self.game = None
|
|
self.set_terminator(b'\n')
|
|
self.inbuf = []
|
|
self.blocked = None
|
|
self.name = None
|
|
self.pending = None
|
|
self.last_activity = time.time()
|
|
|
|
def readable(self):
|
|
ret = (not self.blocked) and asynchat.async_chat.readable(self)
|
|
if ret:
|
|
if time.time() - self.last_activity > self.timeout:
|
|
# They waited too long.
|
|
self.err('idle timeout')
|
|
self.close()
|
|
return False
|
|
return ret
|
|
|
|
def block(self):
|
|
"""Block reads"""
|
|
self.blocked = True
|
|
|
|
def unblock(self):
|
|
"""Unblock reads"""
|
|
self.blocked = False
|
|
self.last_activity = time.time()
|
|
|
|
def attach_game(self, game):
|
|
self.game = game
|
|
if self.pending:
|
|
self.unblock()
|
|
self.game.handle(self, *self.pending)
|
|
self.pending = None
|
|
|
|
def detach_game(self):
|
|
self.game = None
|
|
|
|
def _write_val(self, val):
|
|
s = json.dumps(val) + '\n'
|
|
self.push(s.encode('utf-8'))
|
|
|
|
def write(self, val):
|
|
self._write_val(['OK', val])
|
|
|
|
def err(self, msg):
|
|
self._write_val(['ERR', msg])
|
|
|
|
def win(self):
|
|
self.detach_game()
|
|
self._write_val(['WIN'])
|
|
self.unblock()
|
|
|
|
def lose(self):
|
|
self.detach_game()
|
|
self._write_val(['LOSE'])
|
|
self.unblock()
|
|
|
|
def collect_incoming_data(self, data):
|
|
self.inbuf.append(data)
|
|
if len(self.inbuf) > 10:
|
|
self.err('Too much data, punk.')
|
|
self.close()
|
|
|
|
def found_terminator(self):
|
|
self.last_activity = time.time()
|
|
try:
|
|
data = b''.join(self.inbuf)
|
|
self.inbuf = []
|
|
val = json.loads(data.decode('utf-8'))
|
|
cmd, args = val[0].lower(), val[1:]
|
|
|
|
if cmd == 'login':
|
|
if self.name:
|
|
self.err('Already logged in.')
|
|
elif teams.chkpasswd(args[0], args[1]):
|
|
self.name = args[0]
|
|
self.write('Welcome to the fray, %s.' % self.name)
|
|
self.manager.enter_lobby(self)
|
|
else:
|
|
self.err('Invalid password.')
|
|
elif cmd == '^':
|
|
# Send to manager
|
|
ret = self.manager.player_cmd(args)
|
|
self.write(ret)
|
|
elif not self.name:
|
|
self.err('Log in first.')
|
|
else:
|
|
# Send to game
|
|
if not self.game:
|
|
self.pending = (cmd, args)
|
|
self.block()
|
|
else:
|
|
self.game.handle(self, cmd, args)
|
|
except Exception as err:
|
|
traceback.print_exc()
|
|
self.err(str(err))
|
|
|
|
def close(self):
|
|
self.unblock()
|
|
if self.game:
|
|
self.game.player_died(self)
|
|
self.manager.disconnect(self)
|
|
asynchat.async_chat.close(self)
|
|
|
|
def send(self, data):
|
|
try:
|
|
return asynchat.async_chat.send(self, data)
|
|
except socket.error as why:
|
|
if why.args[0] == EPIPE:
|
|
# Broken pipe, shut down.
|
|
self.close()
|
|
else:
|
|
raise
|
|
|
|
|
|
class Game:
|
|
def __init__(self, manager, players):
|
|
self.manager = manager
|
|
self.players = players
|
|
self.setup()
|
|
|
|
def setup(self):
|
|
pass
|
|
|
|
def heartbeat(self, now):
|
|
pass
|
|
|
|
def declare_winner(self, winner):
|
|
self.manager.declare_winner(self, winner)
|
|
|
|
# Congratulate winner
|
|
if winner:
|
|
winner.win()
|
|
|
|
# Inform losers of their loss
|
|
losers = [p for p in players if p != winner]
|
|
for p in losers:
|
|
p.lose()
|
|
|
|
def handle(self, player, cmd, args):
|
|
"""Handle a command from player.
|
|
|
|
This just dispatches to 'self.do_[cmd]'.
|
|
|
|
"""
|
|
|
|
method_name = 'do_%s' % cmd
|
|
try:
|
|
method = getattr(self, method_name)
|
|
method(player, args)
|
|
except AttributeError:
|
|
raise ValueError('Invalid command: %s' % cmd)
|
|
|
|
def forfeit(self, player):
|
|
"""Player forfeits the game."""
|
|
|
|
self.remove(player)
|
|
|
|
def remove(self, player):
|
|
"""Remove the player from the game."""
|
|
|
|
self.players.remove(player)
|
|
player.detach_game()
|
|
|
|
def player_died(self, player):
|
|
self.forfeit(player)
|
|
|
|
|
|
class TurnBasedGame(Game):
|
|
# How long you get to make a move (in seconds)
|
|
move_timeout = 2.0
|
|
|
|
# How long you get to complete the game (in seconds)
|
|
game_timeout = 6.0
|
|
|
|
def __init__(self, manager, players):
|
|
now = time.time()
|
|
self.ended_turn = set()
|
|
self.running = True
|
|
self.winner = None
|
|
self.lastmoved = dict([(p, now) for p in players])
|
|
self.began = now
|
|
Game.__init__(self, manager, players)
|
|
|
|
def heartbeat(self, now=None):
|
|
print('heart', self)
|
|
if now and (now - self.began > self.game_timeout):
|
|
self.running = False
|
|
|
|
# Idle players forfeit. They're also booted, so we don't have
|
|
# to worry about the synchronous illusion.
|
|
for player in list(self.players):
|
|
if not player.connected:
|
|
self.remove(player)
|
|
continue
|
|
when = self.lastmoved[player]
|
|
if now - when > self.move_timeout:
|
|
player.err('Timeout waiting for a move')
|
|
player.close()
|
|
|
|
# If everyone left, nobody wins.
|
|
if not self.players:
|
|
self.manager.declare_winner(self, None)
|
|
|
|
def player_died(self, player):
|
|
Game.player_died(self, player)
|
|
if player in self.players:
|
|
# Update stuff
|
|
self.heartbeat()
|
|
|
|
def declare_winner(self, winner):
|
|
"""Declare winner.
|
|
|
|
In a turn-based game, you can't tell anyone that the game has
|
|
ended until they make a move. Otherwise, you ruin the illusion
|
|
of the game being synchronous. This only sets the winner variable,
|
|
which is checked in self.end_turn().
|
|
|
|
"""
|
|
|
|
self.running = False
|
|
self.winner = winner
|
|
|
|
def calculate_moves(self):
|
|
"""Calculate all moves at the end of a turn.
|
|
|
|
Override this to define what to do when every player has ended
|
|
their turn.
|
|
|
|
"""
|
|
pass
|
|
|
|
def end_turn(self, player):
|
|
"""End player's turn."""
|
|
|
|
now = time.time()
|
|
|
|
self.ended_turn.add(player)
|
|
self.lastmoved[player] = now
|
|
if not self.players:
|
|
self.manager.declare_winner(self, None)
|
|
elif len(self.players) == 1:
|
|
winners = list(self.players)
|
|
self.declare_winner(winners[0])
|
|
elif len(self.ended_turn) >= len(self.players):
|
|
self.calculate_moves()
|
|
if self.running:
|
|
for p in self.players:
|
|
p.unblock()
|
|
else:
|
|
# Game has ended, tell everyone how they did
|
|
for p in list(self.players):
|
|
if self.winner == p:
|
|
p.win()
|
|
else:
|
|
p.lose()
|
|
self.manager.declare_winner(self, self.winner)
|
|
self.ended_turn = set()
|
|
elif self.running:
|
|
player.block()
|
|
else:
|
|
# The game has ended, tell the player, now that they've made
|
|
# a move.
|
|
if self.winner == player:
|
|
player.win()
|
|
self.manager.declare_winner(self, self.winner)
|
|
else:
|
|
player.lose()
|
|
self.remove(player)
|
|
|
|
|
|
##
|
|
## Running a game
|
|
##
|
|
|
|
def start(game_factory, port, auth, minplayers, maxplayers=None):
|
|
flagger = Flagger(('localhost', 6668), auth)
|
|
manager = Manager(game_factory, flagger, minplayers, maxplayers)
|
|
listener = Listener(('', port), Player, manager)
|
|
return (flagger, manager, listener)
|
|
|
|
def run(game_factory, port, auth, minplayers, maxplayers=None):
|
|
start(game_factory, port, auth, minplayers, maxplayers)
|
|
asyncore.loop(use_poll=True)
|
|
|