def __init__(self):
GameState.__init__(self)
self.players = {}
self.teamCount = 0
self.largestTeam = 0
self.stopGameTimer = None
self.targetTeamCount = TEAM_COUNT
self.setGameTime(GAME_TIME)
def __init__(self):
GameState.__init__(self)
self.players = {}
self.teamCount = 0
self.largestTeam = 0
self.stopGameTimer = None
self.targetTeamCount = 2
self.setGameTime(GAME_TIME)
def startGame(self):
GameState.startGame(self)
def timerStop():
if self.gameStartTime + self.gameTime > time.time():
#the game must have been stopped and restarted as we aren't ready to stop yet. Why were we not cancelled though?
raise RuntimeError("timer seemingly triggered early")
self.stopGame()
self.stopGameTimer = Timer(self.gameTime, timerStop)
self.stopGameTimer.start()
self.listeningThread.queueMessageToAll(proto.STARTGAME.create(self.gameTime))
def __init__(self):
GameState.__init__(self)
self.players = {}
self.teamCount = 0
self.largestTeam = 0
self.stopGameTimer = None
self.targetTeamCount = TEAM_COUNT
self.setGameTime(GAME_TIME)
self.oocUpdater = self.OOCUpdater(self)
self.oocUpdater.start()
self._triggeredOOCWarning = {}
def __init__(self):
GameState.__init__(self)
self.players = {}
self.teamCount = 0
self.largestTeam = 0
self.stopGameTimer = None
self.targetTeamCount = TEAM_COUNT
self.setGameTime(GAME_TIME)
self.oocUpdater = self.OOCUpdater(self)
self.oocUpdater.start()
self._triggeredOOCWarning = {}
def __init__(self):
GameState.__init__(self)
self.players = {}
self.baselinePlayers = {}
self.teamCount = 0
self.largestTeam = 0
self.stopGameTimer = None
self.targetTeamCount = TEAM_COUNT
self.setGameTime(GAME_TIME)
self.confidencePoint = time.time()
self.uncertainEvents = []
def __init__(self):
super(AwlServer, self).__init__()
self.game = GameState()
print("Creating server")
self._s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
#self._s.setblocking(0)
self._s.bind((self.IP, self.PORT))
self._s.listen(1)
self.ins = [self._s]
self.outs = []
self.clients = {}
self.players = {}
def __init__(self, serial = None):
parser = argparse.ArgumentParser(description='BraidsTag gun logic.')
parser.add_argument('-s', '--serial', type=str, help='serial device to which the arduino is connected')
self.args = parser.parse_args()
self.player = None
self.logic = StandardGameLogic()
self.gameState = GameState()
self.serverConnection = Client(self)
self._sendToServer(proto.HELLO.create())
if serial:
self.serial = serial
self.responsiveSerial = True
else:
if not self.args.serial:
raise ArgumentError("You must specify -s if you do not start in fakeGun mode")
try:
import serial
self.serial = serial.Serial(self.args.serial, 115200)
self.responsiveSerial = True
except ImportError:
#We'll have to open this as a file
print("WARNING: No serial module, assuming the serial argument is a normal file for testing")
self.serial = open(self.args.serial)
self.responsiveSerial = False
except serial.serialutil.SerialException:
#Try just opening this as a file
self.serial = open(self.args.serial)
self.responsiveSerial = False
self.connectToArduino()
def main():
state = GameState(deck=make_deck(), player_hand=[], dealer_hand=[])
random.shuffle(state.deck)
initial_deal(state)
while True:
show_cards(state)
if has_blackjack(state.player_hand):
print(f'YOU GOT A BLACKJACK!')
if check_play_again() is True:
set_table(state, check_deck(state))
continue
else:
break
hit_or_not = get_hit_or_stay(state)
hit(hit_or_not, state)
if hit_or_not == Play.Hit and hand_total(state.player_hand) < 21:
continue
winner = get_winner(state)
display_winner(winner, state)
if check_play_again() is True:
set_table(state, check_deck(state))
continue
else:
break
def __init__(self):
parser = argparse.ArgumentParser(description='BraidsTag gun logic.')
parser.add_argument(
'-s',
'--serial',
type=str,
help='serial device to which the arduino is connected',
required=True)
#parser.add_argument('-p', '--playerID', type=self._stringToPlayerID, help='player id', default=1)
#parser.add_argument('-t', '--teamID', type=int, choices=xrange(1, 8), help='team id', default=1)
self.args = parser.parse_args()
self.serverConnection = Client(self)
self._sendToServer(proto.HELLO.create(-1, -1))
try:
self.serial = serial.Serial(self.args.serial, 115200)
self.properSerial = True
except serial.serialutil.SerialException:
#Try just opening this as a file
self.serial = open(self.args.serial)
self.properSerial = False
def playerDead():
print "Out of lives!"
self.logic = StandardGameLogic()
self.logic.playerDead.connect(playerDead)
self.gameState = GameState()
self.connectToArduino()
def __init__(self):
parser = argparse.ArgumentParser(description='BraidsTag gun logic.')
parser.add_argument(
'-s',
'--serial',
type=str,
help='serial device to which the arduino is connected')
#parser.add_argument('-p', '--playerID', type=self._stringToPlayerID, help='player id', default=1)
#parser.add_argument('-t', '--teamID', type=int, choices=xrange(1, 8), help='team id', default=1)
parser.add_argument('-d',
'--debugGun',
help='use the debuggin gun UI',
default=False,
action='store_true')
self.args = parser.parse_args()
self.player = None
self.serverConnection = Client(self)
self._sendToServer(proto.HELLO.create())
if self.args.debugGun:
import fakeGun
self.serial = fakeGun.showUI()
self.responsiveSerial = True
else:
if not self.args.serial:
raise ArgumentError(
"You must specify -s if you do not specify -d")
try:
import serial
self.serial = serial.Serial(self.args.serial, 115200)
self.responsiveSerial = True
except ImportError:
#We'll have to open this as a file
print "WARNING: No serial module, assuming the serial argument is a normal file for testing"
self.serial = open(self.args.serial)
self.responsiveSerial = False
except serial.serialutil.SerialException:
#Try just opening this as a file
self.serial = open(self.args.serial)
self.responsiveSerial = False
def playerDead():
print "Out of lives!"
self.logic = StandardGameLogic()
self.logic.playerDead.connect(playerDead)
self.gameState = GameState()
self.connectToArduino()
def load_game_state(state_row, world):
return GameState(
world=world,
location_name=state_row[0],
inventory=[Thing(name=x) for x in json.loads(state_row[1])])
def setUp(self):
self.gl = StandardGameLogic()
self.gameState = GameState()
self.gameState.setGameTime(120)
class TestTakingHits(unittest.TestCase):
def setUp(self):
self.gl = StandardGameLogic()
self.gameState = GameState()
self.gameState.setGameTime(120)
def test_simple_hit_while_game_stopped(self):
player = Player(1, 1)
initialHealth = player.health
sentTeam = 1
sentPlayer = 2
damage = 2
self.gl.hit(self.gameState, player, sentTeam, sentPlayer, damage)
self.assertEqual(initialHealth, player.health)
def test_simple_hit(self):
self.gameState.startGame()
player = Player(1, 1)
initialHealth = player.health
sentTeam = 2
sentPlayer = 1
damage = 2
self.gl.hit(self.gameState, player, sentTeam, sentPlayer, damage)
self.assertEqual(initialHealth - damage, player.health)
def test_self_hit(self):
self.gameState.startGame()
player = Player(1, 1)
initialHealth = player.health
sentTeam = 1
sentPlayer = 1
damage = 2
self.gl.hit(self.gameState, player, sentTeam, sentPlayer, damage)
self.assertEqual(initialHealth, player.health)
def test_team_hit(self):
self.gameState.startGame()
player = Player(1, 1)
initialHealth = player.health
sentTeam = 1
sentPlayer = 2
damage = 2
self.gl.hit(self.gameState, player, sentTeam, sentPlayer, damage)
self.assertEqual(initialHealth - damage, player.health)
def test_shot_until_dead(self):
self.gameState.startGame()
player = Player(1, 1)
initialHealth = player.health
sentTeam = 2
sentPlayer = 1
damage = (
player.health // 2
) + 1 # this will fail if the player only starts with 2 health :-(
self.gl.hit(self.gameState, player, sentTeam, sentPlayer, damage)
self.assertEqual(initialHealth - damage, player.health)
self.gl.hit(self.gameState, player, sentTeam, sentPlayer, damage)
self.assertEqual(0, player.health)
#TODO assert death signal
self.gl.hit(self.gameState, player, sentTeam, sentPlayer, damage)
self.assertEqual(0, player.health)
class AwlServer(threading.Thread):
IP = '0.0.0.0'
PORT = 1889
def __init__(self):
super(AwlServer, self).__init__()
self.game = GameState()
print("Creating server")
self._s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self._s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
#self._s.setblocking(0)
self._s.bind((self.IP, self.PORT))
self._s.listen(1)
self.ins = [self._s]
self.outs = []
self.clients = {}
self.players = {}
def broadcast(self, msg_type, msg_val):
for c in self.clients:
send(c, msg_type, msg_val)
def send_game(self, client=None):
state = {
'scores': self.game.scores,
'game': self.game.game,
'to_play': self.game.current_player,
}
if client:
send(client, 'game_state', state)
else:
self.broadcast('game_state', state)
def process_msg(self, client, msg):
if len(self.players) != 2:
send(client, 'info', "Waiting for opponent")
return
msg_type, msg = decode_message(msg)
if msg_type == 'play':
try:
self.game.play(self.players[client], msg)
p = player_name(self.players[client])
self.broadcast('info', "%s played %s" % (p, msg))
self.send_game()
except AwaleException as e:
send(client, 'error', str(e))
if self.game.over():
win_player = winner(self.game.game, self.game.scores)
if win_player is not None:
self.broadcast('info',
"%s wins !" % player_name(win_player))
else:
self.broadcast('info', "Draw !")
self.running = False
def run(self):
print("running...")
self.running = True
while self.running and self.ins:
rds, wts, ers = select.select(self.ins, self.outs, self.ins, 0)
for s in rds:
if s is self._s:
if len(self.clients) < 2:
cl, addr = s.accept()
print("New client %s" % str(addr))
self.ins.append(cl)
self.clients[cl] = b''
player_no = len(self.players)
pname = player_name(player_no)
send(cl, 'info', "welcome %s" % pname)
send(cl, 'player_id', player_no)
self.players[cl] = player_no
if len(self.players) == 2:
self.broadcast('info', "Ready to play")
self.send_game()
else:
print("Maximum clients reached")
cl, addr = s.accept()
cl.close()
else:
data = s.recv(5)
if data:
self.clients[s] += data
else:
print("Client disconnected")
self.ins.remove(s)
self.clients.pop(s)
if len(self.players) == 2:
self.broadcast(
'info',
"%s left. Exiting..." % \
player_name(self.players[s])
)
self.running = False
s.close()
for s in ers:
print("Error, closing socket.")
self.ins.remove(s)
s.close()
# manage data
for s in self.clients:
data = self.clients[s]
msg, remain = extract_msg(data)
if msg:
self.process_msg(s, msg)
self.clients[s] = remain
print("closing sockets")
for s in self.clients:
s.close()
self._s.close()
key = Thing(name="rusty key")
home = Location(name="Home",
description="Home is where the heart is!",
exits={
"east": (None, "Street"),
"down": (key, "Basement")
})
street = Location(name="Street",
description="The street next to your house.",
exits={"west": (None, "Home")},
items={key.name: key})
basement = Location(name="Basement",
description="You found the basement!",
exits={"up": (None, "Home")})
world = pmap({x.name: x for x in [home, street, basement]})
initial_state = GameState(location_name="Home", world=world)
in_street = initial_state.set(location_name="Street")
in_street_with_key = in_street.transform(["world", "Street", "items"],
lambda _: {}, ["inventory"],
lambda _: [key])
def test_take_not_found():
assert take(initial_state, "some item") is None
def test_take_something():
in_street = initial_state.set(location_name="Street")
assert take(in_street, "rusty key") == in_street_with_key
def setUp(self): self.gl = StandardGameLogic() self.gameState = GameState() self.gameState.setGameTime(120)
class TestTakingHits(unittest.TestCase):
def setUp(self):
self.gl = StandardGameLogic()
self.gameState = GameState()
self.gameState.setGameTime(120)
def test_simple_hit_while_game_stopped(self):
player = Player(1, 1)
initialHealth = player.health
sentTeam = 1
sentPlayer = 2
damage = 2
self.gl.hit(self.gameState, player, sentTeam, sentPlayer, damage)
self.assertEqual(initialHealth, player.health)
def test_simple_hit(self):
self.gameState.startGame()
player = Player(1, 1)
initialHealth = player.health
sentTeam = 2
sentPlayer = 1
damage = 2
self.gl.hit(self.gameState, player, sentTeam, sentPlayer, damage)
self.assertEqual(initialHealth - damage, player.health)
def test_self_hit(self):
self.gameState.startGame()
player = Player(1, 1)
initialHealth = player.health
sentTeam = 1
sentPlayer = 1
damage = 2
self.gl.hit(self.gameState, player, sentTeam, sentPlayer, damage)
self.assertEqual(initialHealth, player.health)
def test_team_hit(self):
self.gameState.startGame()
player = Player(1, 1)
initialHealth = player.health
sentTeam = 1
sentPlayer = 2
damage = 2
self.gl.hit(self.gameState, player, sentTeam, sentPlayer, damage)
self.assertEqual(initialHealth - damage, player.health)
def test_shot_until_dead(self):
self.gameState.startGame()
player = Player(1, 1)
initialHealth = player.health
sentTeam = 2
sentPlayer = 1
damage = (player.health // 2) + 1 # this will fail if the player only starts with 2 health :-(
self.gl.hit(self.gameState, player, sentTeam, sentPlayer, damage)
self.assertEqual(initialHealth - damage, player.health)
self.gl.hit(self.gameState, player, sentTeam, sentPlayer, damage)
self.assertEqual(0, player.health)
#TODO assert death signal
self.gl.hit(self.gameState, player, sentTeam, sentPlayer, damage)
self.assertEqual(0, player.health)
def game_state():
gameState = GameState()
gameState.setGameTime(120)
return gameState
def stopGame(self):
GameState.stopGame(self)
self.listeningThread.queueMessageToAll(proto.STOPGAME.create())
if self.stopGameTimer:
self.stopGameTimer.cancel()
self.stopGameTimer = None
def game_state():
gameState = GameState()
gameState.setGameTime(120)
return gameState