def __init__(self, name, address, socket):
"""
Regular Player constructor
Parameters:
- name: (string) name of the player
- address: (string) network address (used once for logging)
- socket: (PlayerSocket) PlayerSocket object associated
"""
# call the Player constructor
Player.__init__(self)
# waitGame event
self._waitingGame = Event()
self._waitingGame.clear()
# Tournament
self._tournament = None
# PlayerSocket
self._socket = socket
# and last, call the BaseClass constructor
BaseClass.__init__(self, name)
self.logger.info("=================================")
self.logger.info(name + " just log in (from " + address + ".")
frame_count = 0
epoch = time()
while True:
delta = Uhr.tick(120)
frame_count += 1
if time() - epoch > 10:
server_fps = int(frame_count / (time() - epoch))
com.send_all("root", "server-fps", fps=server_fps)
frame_count = 0
epoch = time()
# receaving and player init
for client in com.clients:
if client.player is None:
client.player = Player(Vector(), 0)
client.player.client = client
world.add(client.player)
client.player.world = world
while client.has_message():
message = client.pop()
if message['request'] == 'test':
print("test-message: " + str(message['value']))
if message['target'] == "client":
client.handle_event(**message)
if message["target"] == "root":
client.handle_event(**message)
world.update(delta, com)
def setUp(self):
self.dealer = MockDealer()
self.deck = self.dealer.deck
self.p1 = Player(1, self.deck, self.dealer)
class TestPlayer(unittest.TestCase):
def setUp(self):
self.dealer = MockDealer()
self.deck = self.dealer.deck
self.p1 = Player(1, self.deck, self.dealer)
def tearDown(self):
pass
def test_start_game(self):
self.deck.deal(4)
self.p1.start_game()
self.assertEqual(len(self.p1.cards), 7)
for c in self.p1.cards:
self.assertEqual(c.status, 1)
def test_draw_card(self):
self.deck.deal(4)
self.p1.start_game()
self.assertEqual(len(self.p1.cards), 7)
self.p1.draw(1)
self.assertEqual(len(self.p1.cards), 8)
self.p1.draw(10)
self.assertEqual(len(self.p1.cards), 18)
self.p1.draw ( 108 - 18 - 3*7)
self.assertRaises(DeckFull, self.p1.draw, 1)
def test_dispose(self):
self.p1.dispose()
self.assertEqual(len(self.p1.cards), 0)
def setup_play(self, l):
#make special set of card for player 1
self.p1.cards = []
for c_str in l:
c = [c for c in self.deck.lookup(c_str) if c.status == 0][0]
c.status = 1
c.playerId = 1
self.p1.cards.append(c)
def test_play_normal(self):
l = ['R5', 'R1', 'G5', 'G7', 'RU', 'GD', 'NW']
self.setup_play(l)
self.p1.dealer.current_card = self.deck.lookup('R6')[0]
self.p1.play('R5')
self.assertEqual(self.dealer.current_card.toString(), 'R5')
self.assertEqual(self.dealer.turn, 1)
self.assertEqual(len(self.p1.cards), 6)
self.assertEqual(self.dealer.current_card.status, 2)
self.dealer.turn = 1
self.p1.play('G5')
self.assertEqual(self.dealer.current_card.toString(), 'G5')
self.assertEqual(self.dealer.turn, 1)
self.assertEqual(len(self.p1.cards), 5)
self.assertEqual(self.dealer.current_card.status, 2)
self.dealer.turn = 1
self.p1.dealer.current_card = self.deck.lookup('NW')[0]
self.p1.dealer.current_card.color = 'G'
self.p1.play('G7')
self.assertEqual(self.dealer.current_card.toString(), 'G7')
self.assertEqual(self.dealer.turn, 1)
self.assertEqual(len(self.p1.cards), 4)
self.assertEqual(self.dealer.current_card.status, 2)
self.dealer.turn = 1
self.assertRaises(InvalidCard, self.p1.play, 'Y7')
self.assertRaises(InvalidCard, self.p1.play, 'R1')
self.dealer.turn = 2
self.assertRaises(InvalidTurn, self.p1.play, 'Y7')
def test_play_skipcard(self):
l = ['RS', 'R1', 'G5', 'G7', 'RU', 'GD', 'NW']
self.setup_play(l)
self.p1.dealer.current_card = self.deck.lookup('R6')[0]
self.assertRaises(InvalidCard, self.p1.play, 'GS')
self.dealer.turn = 1
self.p1.play('RS')
self.assertEqual(self.dealer.current_card.toString(), 'RS')
self.assertEqual(self.dealer.turn, 2)
self.assertEqual(self.dealer.current_card.status, 2)
self.dealer.turn = 1
self.assertEqual(len(self.p1.cards), 6)
def test_play_reverse(self):
l = ['RS', 'RU', 'G5', 'G7', 'GU', 'GD', 'NW']
self.setup_play(l)
self.p1.dealer.current_card = self.deck.lookup('R6')[0]
self.assertRaises(InvalidCard, self.p1.play, 'GU')
self.dealer.turn = 1
self.p1.play('RU')
self.assertEqual(self.dealer.current_card.toString(), 'RU')
self.assertEqual(self.dealer.turn, -1)
self.assertEqual(self.dealer.current_card.status, 2)
self.dealer.turn = 1
self.assertEqual(len(self.p1.cards), 6)
def test_play_draw2(self):
l = ['RD', 'GU', 'G5', 'G7', 'RU', 'GD', 'NW']
self.setup_play(l)
self.p1.dealer.current_card = self.deck.lookup('R6')[0]
self.assertRaises(InvalidCard, self.p1.play, 'GD')
self.dealer.turn = 1
self.p1.play('RD')
self.assertEqual(self.dealer.current_card.toString(), 'RD')
self.assertEqual(self.dealer.turn, 2)
self.assertEqual(self.dealer.playerIdToDraw, 2)
self.assertEqual(self.dealer.numberToDraw, 2)
self.assertEqual(self.dealer.current_card.status, 2)
self.dealer.turn = 1
self.assertEqual(len(self.p1.cards), 6)
def test_play_wild(self):
l = ['NW', 'NF', 'NW', 'G7', 'RU', 'GD', 'RS']
self.setup_play(l)
self.p1.dealer.current_card = self.deck.lookup('R6')[0]
self.assertRaises(InvalidCard, self.p1.play, 'GD')
self.dealer.turn = 1
self.p1.play('GW')
self.assertEqual(self.dealer.current_card.toString(), 'GW')
self.assertEqual(len(self.p1.cards), 6)
self.assertEqual(self.dealer.current_card.status, 2)
self.dealer.turn = 1
self.dealer.turn = 1
self.p1.play('YW')
self.assertEqual(self.dealer.current_card.toString(), 'YW')
self.assertEqual(len(self.p1.cards), 5)
self.assertEqual(self.dealer.current_card.status, 2)
self.dealer.turn = 1
self.assertRaises(InvalidCard, self.p1.play, 'YW')
def test_play_wild4(self):
l = ['NF', 'RU', 'G5', 'G7', 'GU', 'GD', 'NW']
self.setup_play(l)
self.p1.dealer.current_card = self.deck.lookup('R6')[0]
self.assertRaises(InvalidCard, self.p1.play, 'RF')
self.assertEqual(self.dealer.current_card.toString(), 'R6')
self.p1.dealer.current_card = self.deck.lookup('G2')[0]
self.assertRaises(InvalidCard, self.p1.play, 'GF')
self.assertEqual(self.dealer.current_card.toString(), 'G2')
self.p1.dealer.current_card = self.deck.lookup('Y1')[0]
self.dealer.turn = 1
self.p1.play('GF')
self.assertEqual(self.dealer.current_card.toString(), 'GF')
self.assertEqual(self.dealer.turn, 2)
self.assertEqual(self.dealer.playerIdToDraw, 2)
self.assertEqual(self.dealer.numberToDraw, 4)
self.assertEqual(self.dealer.current_card.status, 2)
self.dealer.turn = 1
def test_get_card_str(self):
self.deck.deal(4)
self.p1.start_game()
s = self.p1.get_cards_str()
self.assertEqual(len(s), 7*2 + 6)
def test_play_NN(self):
self.deck.deal(4)
self.p1.start_game()
count = len(self.p1.cards)
self.dealer.turn = 0
self.p1.play('NN')
self.assertEqual(len(self.p1.cards), count + 1)
self.assertEqual(self.dealer.turn, 0)
self.p1.play('NN')
self.assertEqual(len(self.p1.cards), count + 1)
self.assertEqual(self.dealer.turn, 1)
ln1 = TestGameObject([Vector(x, y) for x, y in ((-2, 10), (10, -2))])
ln2 = TestGameObject([Vector(x, y) for x, y in ((10, 10), (-10, -10))])
ta1 = TestGameObject(
[Vector(x, y) for x, y in ((3, -1), (2, -4), (4, -4))])
ta2 = TestGameObject(
[Vector(x, y) for x, y in ((1, -2), (5, -3), (5, -1))])
print("sq1 / sq2:", sq1.colliding(sq2), sq2.colliding(sq1))
print("sq1 / sq3:", sq1.colliding(sq3), sq3.colliding(sq1))
print("sq2 / sq3:", sq2.colliding(sq3), sq3.colliding(sq2))
print("sq1 / ln1:", sq1.colliding(ln1), ln1.colliding(sq1))
print("ln1 / ln2:", ln1.colliding(ln2), ln2.colliding(ln1))
print("ln1 / ln1:", ln1.colliding(ln1), ln1.colliding(ln1))
print("ta1 / ta2:", ta1.colliding(ta2), ta2.colliding(ta1))
print()
pl1 = Player(Vector(), 0, Vector(2, 4))
pl2 = Player(Vector(-1, 0.5), math.pi * 3 / 8, Vector(2, 4))
pl3 = Player(Vector(500, 0), -0.5 * math.pi, Vector(2, 4))
print("pl1 / pl2:", pl1.colliding(pl2), pl2.colliding(pl1))
print("pl1 / pl3:", pl1.colliding(pl3), pl3.colliding(pl1))
print("pl2 / pl3:", pl2.colliding(pl3), pl3.colliding(pl2))
print()
me1 = Meadow(Vector())
me2 = Meadow(Vector(1, 0))
me3 = Meadow(Vector(1, 1), 2)
ho1 = House(Vector(0, 1))
ho2 = House(Vector(500, 500))
ho3 = House(Vector(0.5, 0.5))
print("me1 / me1:", me1.colliding(me1))
print("me1 / me2:", me1.colliding(me2), me2.colliding(me1))
