303 lines
9.7 KiB
Python
303 lines
9.7 KiB
Python
from flask import Flask, render_template, request, session, make_response
|
|
import random
|
|
import socket
|
|
import time
|
|
|
|
app = Flask(__name__)
|
|
app.secret_key = b'RoboRallyRolling'
|
|
|
|
random.seed(0)
|
|
|
|
moves = ['forward', 'forward x2', 'forward x3', 'backward', 'turn left', 'turn right', 'turn around']
|
|
probabilities = [0.21428571428571427, 0.14285714285714285, 0.07142857142857142, 0.07142857142857142, 0.21428571428571427, 0.21428571428571427, 0.07142857142857142]
|
|
|
|
|
|
class Robot:
|
|
def __init__(self, x, y, orientation, id):
|
|
self.x = x
|
|
self.y = y
|
|
self.orientation = orientation
|
|
self.id = id
|
|
|
|
def move(self, type):
|
|
pass
|
|
|
|
def __str__(self):
|
|
return str(self.id)
|
|
|
|
class Tile:
|
|
# possible modifiers:
|
|
# conveyors: <, >, ^, v
|
|
# repair station: r
|
|
# flag: f<number>
|
|
def __init__(self, x, y, modifier=None):
|
|
self.modifier = modifier
|
|
self.occupant = None
|
|
self.x = x
|
|
self.y = y
|
|
|
|
def is_empty(self):
|
|
return self.occupant is None
|
|
|
|
def __str__(self):
|
|
if self.is_empty():
|
|
if self.modifier is None:
|
|
return ' '
|
|
else:
|
|
return self.modifier
|
|
else:
|
|
return str(self.occupant)
|
|
|
|
class Board:
|
|
x_dims = 12 # number of tiles in x direction
|
|
y_dims = 6 # number of tiles in y direction
|
|
def __init__(self):
|
|
self.board = {}
|
|
for x in range(Board.x_dims):
|
|
for y in range(Board.y_dims):
|
|
if x == 0 and (y >= 1) and (y <= 4):
|
|
self.board[(x,y)] = Tile(x,y,'v')
|
|
else:
|
|
self.board[(x, y)] = Tile(x, y)
|
|
|
|
self.board[(0,0)].occupant = Robot(0,0,'>',1)
|
|
self.board[(2,0)].occupant = Robot(2,0,'v',2)
|
|
|
|
def apply_actions(self, actions):
|
|
# apply the actions to the board and generate a list of movement commands
|
|
# sort actions by priority
|
|
sorted_actions = sorted(actions, key=lambda a: a[1].priority)
|
|
pass
|
|
|
|
|
|
def __str__(self):
|
|
output = '#' * (Board.x_dims + 2) + '\n'
|
|
for y in range(Board.y_dims):
|
|
output += '#'
|
|
for x in range(Board.x_dims):
|
|
output += str(self.board[(x,y)])
|
|
output += '#\n'
|
|
output += '#' * (Board.x_dims + 2)
|
|
return output
|
|
|
|
class Game:
|
|
def __init__(self):
|
|
self.action_stack = {}
|
|
self.processing_done = False # indicates whether all commands in the current round have been processed
|
|
|
|
self.board = Board()
|
|
|
|
self.comm_socket = socket.socket() # socket for communicating with the program controlling the robots
|
|
try:
|
|
self.comm_socket.connect(('192.168.1.222', 1337))
|
|
except socket.error:
|
|
print("could not connect to robot control socket!")
|
|
|
|
def ready(self):
|
|
# have all players chosen an action?
|
|
return len(self.action_stack.keys()) == Player.player_counter
|
|
|
|
def register_actions(self, player_id, actions):
|
|
if not player_id in self.action_stack.keys():
|
|
print("registered actions: ", [str(a) for a in actions])
|
|
self.action_stack[player_id] = actions
|
|
deck.return_cards(actions) # put cards back into the deck
|
|
self.processing_done = False
|
|
return True
|
|
else:
|
|
print("actions already chosen!")
|
|
return False
|
|
|
|
def process_actions(self):
|
|
# send commands to the robots in the order of priority
|
|
for i in range(5):
|
|
current_actions = []
|
|
for p in self.action_stack.keys():
|
|
current_actions += [(p, self.action_stack[p][i])]
|
|
|
|
print("current actions = ", current_actions)
|
|
# generate list of movement commands to send to the control program
|
|
|
|
self.board.apply_actions(current_actions)
|
|
|
|
if False:
|
|
# send movements to the program
|
|
for c in current_actions:
|
|
if c[0] == 0:
|
|
print("{}, {}\n".format(c[1].action, 11))
|
|
self.comm_socket.sendall("{}, {}\n".format(c[1].action, 11).encode())
|
|
elif c[0] == 1:
|
|
print("{}, {}\n".format(c[1].action, 14))
|
|
self.comm_socket.sendall("{}, {}\n".format(c[1].action, 14).encode())
|
|
data = self.comm_socket.recv(32)
|
|
|
|
if data == b'OK\n':
|
|
print("an error occured while processing the commands")
|
|
self.processing_done = True
|
|
self.action_stack = {}
|
|
return
|
|
|
|
time.sleep(0.5)
|
|
|
|
#self.comm_socket.send()
|
|
|
|
|
|
# clear the action stack for the next round
|
|
self.action_stack = {}
|
|
|
|
self.processing_done = True
|
|
|
|
class Card:
|
|
card_counter = 0
|
|
def __init__(self):
|
|
self.number = Card.card_counter
|
|
Card.card_counter += 1
|
|
self.action = random.choice(moves)
|
|
self.priority = random.randint(0, 100)
|
|
|
|
def __str__(self):
|
|
return "Card No. " + str(self.number) + " " + self.action + " " + str(self.priority)
|
|
|
|
class CardDeck:
|
|
def __init__(self, n=84):
|
|
self.deck = {}
|
|
# generate cards
|
|
for i in range(0,n):
|
|
self.deck[i] = Card()
|
|
self.dealt = set()
|
|
self.discard_pile = set()
|
|
|
|
def draw_cards(self, n=1):
|
|
available = set(self.deck.keys()).difference(self.dealt)
|
|
#print("{} cards are available".format(len(available)))
|
|
|
|
if len(available) < n:
|
|
drawn = list(available) # give out remaining cards
|
|
#print("drawing remaining {} cards".format(len(drawn)))
|
|
self.dealt = self.dealt.union(drawn)
|
|
|
|
# put the cards from the discard pile back into the game
|
|
self.dealt = self.dealt - self.discard_pile
|
|
self.discard_pile = set() # reset the discard pile
|
|
|
|
# draw rest of cards
|
|
available = set(self.deck.keys()).difference(self.dealt)
|
|
#print("drawing another {} cards".format(n - len(drawn)))
|
|
drawn += random.sample(available, n - len(drawn))
|
|
else:
|
|
drawn = random.sample(available, n)
|
|
#print("cards drawn: {}".format(drawn))
|
|
|
|
self.dealt = self.dealt.union(drawn)
|
|
|
|
return [self.deck[i] for i in drawn]
|
|
|
|
def return_cards(self, cards):
|
|
self.discard_pile = self.discard_pile.union(set([c.number for c in cards]))
|
|
pass
|
|
|
|
deck = CardDeck()
|
|
|
|
class Player:
|
|
MAX_PLAYERS = 3
|
|
player_counter = 0
|
|
def __init__(self):
|
|
if Player.player_counter < Player.MAX_PLAYERS:
|
|
self.id = Player.player_counter
|
|
Player.player_counter += 1
|
|
|
|
self.max_cards = 9
|
|
|
|
self.player_hand = deck.draw_cards(self.max_cards)
|
|
print("current hand: ", [str(c) for c in self.player_hand])
|
|
|
|
self.action_count = 5
|
|
self.action_chosen = False
|
|
|
|
else:
|
|
print("max players reached!")
|
|
|
|
def draw_new_cards(self):
|
|
self.player_hand += deck.draw_cards(self.max_cards - len(self.player_hand))
|
|
|
|
players = {}
|
|
game = Game()
|
|
|
|
|
|
@app.route('/send_cmds', methods=['POST', 'GET'])
|
|
def send_cmds():
|
|
if request.method == 'POST':
|
|
# POST is used for submitting commands
|
|
player_id = session['player_id']
|
|
p = players[player_id]
|
|
|
|
if game.register_actions(p.id, p.player_hand[0:p.action_count]):
|
|
p.player_hand = p.player_hand[p.action_count:] # discard used cards
|
|
p.draw_new_cards()
|
|
|
|
if game.ready():
|
|
game.process_actions()
|
|
|
|
return 'OK'
|
|
else:
|
|
return 'please wait'
|
|
elif request.method == 'GET':
|
|
# GET is used when we have to wait for other players to finish
|
|
while not game.processing_done: # wait for other players to choose commands and processing to finish
|
|
pass
|
|
|
|
return 'OK'
|
|
|
|
@app.route('/', methods=['GET', 'POST'])
|
|
def hello_world():
|
|
if not 'player_id' in session:
|
|
if Player.player_counter < Player.MAX_PLAYERS:
|
|
# new player
|
|
p = Player()
|
|
session['player_id'] = p.id
|
|
players[p.id] = p
|
|
player_id = session['player_id']
|
|
else:
|
|
return "Sorry, maximum number of players reached!"
|
|
else:
|
|
player_id = session['player_id']
|
|
if Player.player_counter < player_id + 1:
|
|
session.clear()
|
|
response = make_response('Please reload the page!')
|
|
#response.set_cookie('player_id', '', expires=0)
|
|
return response
|
|
player_hand = players[player_id].player_hand
|
|
|
|
|
|
if request.method == 'GET':
|
|
return render_template('drag_example.html', cmds=player_hand, player_id=player_id)
|
|
elif request.method == 'POST':
|
|
#print(request.form)
|
|
|
|
if request.form.get('drag') and request.form.get('drop'):
|
|
|
|
# swap cards in the current hand
|
|
i1 = int(request.form.get('drag')) # number of first card
|
|
i2 = int(request.form.get('drop')) # number of second card
|
|
|
|
card1 = deck.deck[i1] # get card by number
|
|
card2 = deck.deck[i2]
|
|
|
|
print("swapping {} and {}".format(card1, card2))
|
|
|
|
j1 = player_hand.index(card1) # get index of card in the hand
|
|
j2 = player_hand.index(card2)
|
|
|
|
player_hand[j1], player_hand[j2] = player_hand[j2], player_hand[j1] # swap the cards in the list
|
|
|
|
#print("current hand: ", [str(c) for c in player_hand[player_id]])
|
|
|
|
return 'OK'
|
|
else:
|
|
return render_template('drag_example.html', cmds=player_hand, player_id=player_id)
|
|
|
|
|
|
|
|
if __name__ == '__main__':
|
|
app.run(host='0.0.0.0', port=5000)
|