class Player(object):
oid = primarykey(int)
player_id = dimension(str)
ready = dimension(bool)
done = dimension(bool)
winner = dimension(bool)
def __init__(self, dataframe):
self.oid = random.randint(0, sys.maxsize)
self.player_id = "T-{0}".format(random.randint(0, 500))
self.ready = False
self.done = False
self.winner = False
# The reference is not shared, but the ship itself is
self.ship = Ship(self.player_id, 0)
dataframe.add_one(Ship, self.ship)
self.world = World()
self.dataframe = dataframe
def init_world(self):
for a in self.dataframe.read_all(Asteroid):
self.world.asteroids[a.oid] = a
my_print("World has {0} asteroids".format(len(self.world.asteroids)))
def ready(self, x, df):
self.ready = True
self.dataframe = df
# Find the player's ship
for s in self.dataframe.read_all(Ship):
if s.player_id in self.player_id:
self.ship = s
self.ship.global_x = float(x)
my_print("Player {0} ready at {1:.2f} with ship {0}".format(
self.player_id, self.ship.global_x, self.ship.oid))
def act(self):
#my_print("Ship state is {0}".format(self.ship.state))
# This is pretty brain dead: just keep going,
# ignore all asteroids. Let the server do the movement
# according to the constant velocity set here in "go".
if self.ship.state == ShipState.STOPPED:
self.ship.go()
elif self.ship.state == ShipState.DESTROYED:
my_print("My ship was destroyed!")
return False
return True
def reset(self):
self.ship.reset()
self.ship.go()
def game_over(self):
if self.winner:
my_print("I WON!!!!!!!!")
class Register(object):
crawler_id = primarykey(str)
load_balancer = dimension(tuple)
fresh = dimension(bool)
invalid = dimension(bool)
def __init__(self, crawler_id, fresh):
self.crawler_id = crawler_id
self.load_balancer = tuple()
self.fresh = fresh
self.invalid = False
class BaseSet(object):
oid = primarykey(int)
prop1 = dimension(int)
prop2 = dimension(str)
prop3 = dimension(float)
prop4 = dimension(str)
def __init__(self, oid, p1, p2, p3, p4):
self.oid = oid
self.prop1 = p1
self.prop2 = p2
self.prop3 = p3
self.prop4 = p4
class Snake():
'''Defines the snakes which are the player characters in the game.'''
@property
def direction_vector(self):
# pylint: disable=unsubscriptable-object,missing-docstring
return (np.array(self.snake_position[0])
- np.array(self.snake_position[1]))
oid = primarykey(str)
snake_head = dimension(tuple)
snake_position = dimension(list)
score = dimension(int)
start_game = dimension(bool)
crashed = dimension(bool)
direction = dimension(int)
prev_direction = dimension(int)
assigned_player = dimension(int)
def __init__(self):
self.oid = str(uuid.uuid4())
self.score = 0
self.start_game = False
self.crashed = False
self.direction = 1
self.prev_direction = 1
def set_direction(self, direct):
''' Sets the new direction for the snake.'''
self.prev_direction = self.direction
self.direction = direct
class Blocker(object):
oid = primarykey(int)
prop = dimension(int)
def __init__(self, oid):
self.oid = oid
self.prop = 0
class Counter(object):
oid = primarykey(int)
count = dimension(int)
def __init__(self, oid):
self.oid = oid
self.count = 0
class ClassWithCounter(object):
oid = primarykey(int)
counter = dimension(Counter)
def __init__(self, oid):
self.oid = oid
self.counter = Counter(oid)
def Observation(observation_names: List[str]):
""" Creates a proper player class with the attributes necessary to transfer the observations. """
class Observation(_Observation):
pass
for name in observation_names:
setattr(Observation, name, dimension(np.array))
return pcc_set(Observation)
class Blocker(object):
oid = primarykey(int)
prop = dimension(int)
def __init__(self, oid):
self.oid = oid
self.prop = 0
@merge
def merge_func(original, yours, theirs):
return theirs
class GameMaster(object):
public_key_serial = dimension(bytes)
def __init__(self):
self.private_key = generate_key()
self.public_key = get_public_key(self.private_key)
self.public_key_serial = serialize_public_key(self.public_key)
my_print("My pub key (serial): {0}".format(self.public_key_serial))
def load_key(self):
self.public_key = deserialize_public_key(self.public_key_serial)
class Car(object):
oid = primarykey(int)
xvel = dimension(int)
yvel = dimension(int)
xpos = dimension(int)
ypos = dimension(int)
def move(self):
self.xpos += self.xvel
self.ypos += self.yvel
def details(self):
return self.oid, self.xvel, self.yvel, self.xpos, self.ypos
def __init__(self, oid):
self.oid = oid
self.xvel = 0
self.yvel = 0
self.xpos = 0
self.ypos = 0
class Mark(object):
player_id = dimension(int)
secret_position = dimension(bytes)
x = dimension(int)
y = dimension(int)
rejected = dimension(bool)
def __init__(self, pid, x, y):
self.player_id = pid
self.x = x
self.y = y
self.rejected = False
my_print("New mark for {0}-{1}".format(x, y))
def hide(self, crypto_key):
pos_list = [self.x, self.y]
pos_str = str(pos_list)
ciphertext_bytes = encrypt_message(pos_str, crypto_key)
self.secret_position = ciphertext_bytes
self.x = -1
self.y = -1
class Counter(object):
oid = primarykey(int)
count = dimension(int)
def __init__(self, oid):
self.oid = oid
self.count = 0
@merge
def merge_func(original, yours, theirs):
original.count = (yours.count + theirs.count) - original.count
return original
class Car(object):
oid = primarykey(int)
xvel = dimension(int)
yvel = dimension(int)
xpos = dimension(int)
ypos = dimension(int)
color = dimension(str)
def start(self, vel):
self.xvel, self.yvel = vel
def details(self):
return self.oid, self.xvel, self.yvel, self.xpos, self.ypos, self.color
def __init__(self, oid, color):
self.oid = oid
self.xvel = 0
self.yvel = 0
self.xpos = 0
self.ypos = 0
self.color = color
class Player(object):
player_id = dimension(int)
player_name = dimension(str)
ready = dimension(bool)
winner = dimension(bool)
done = dimension(bool)
def __init__(self, gm):
self.player_name = "Team-{0}".format(random.randint(0, 500))
self.ready = False
self.done = False
# Local, non-shared data
self.board = Board()
self.game_master = gm
self.game_master.load_key()
my_print("Game Master's key: {0}".format(self.game_master.public_key))
def create_mark(self):
# Do something smarter?
good = False
while not good:
x = random.randint(0, 2)
y = random.randint(0, 2)
if self.board.is_empty(x, y):
good = True
mark = Mark(self.player_id, x, y)
self.board.enforce(mark)
return mark
def invalid_mark(self, mark):
# The other player has a mark in that spot
player_id = (self.player_id + 1) % 2
self.board.change_player_id(player_id, mark.x, mark.y)
def game_over(self):
if self.winner:
my_print("I WON!!!!!!!!")
class Apple():
''' Defines the fruit that the snake(s) have to eat.'''
# pylint: disable=too-few-public-methods
oid = primarykey(int)
apple_position = dimension(tuple)
def __init__(self):
self.oid = 0
self.reset_position()
def reset_position(self):
'''Resets Apple fruit's position.'''
self.apple_position = (
random.randrange(1, World.display_width),
random.randrange(1, World.display_height))
class Asteroid(object):
oid = primarykey(int)
global_x = dimension(float)
global_y = dimension(float)
velocity = dimension(float)
def __init__(self):
self.oid = random.randint(0, sys.maxsize)
self.global_x, self.global_y, self.velocity = Asteroid._random_asteroid_data(
)
my_print("New asteroid at {0:.2f}-{1:.2f} vel={2:.2f}".format(
self.global_x, self.global_y, self.velocity))
def move(self, delta):
self.global_x += (self.velocity * delta)
#my_print("Asteroid at {0:.2f}-{1:.2f} vel={2:.2f} delta={3:.2f}".format(self.global_x, self.global_y, self.velocity, delta))
# Did it reach the end?
if self.global_x >= World.WORLD_WIDTH or self.global_x <= 0:
self.global_x, self.global_y, self.velocity = Asteroid._random_asteroid_data(
)
def _random_asteroid_data():
x = float(random.randint(0, 1) * World.WORLD_WIDTH)
y = float(random.randint(0, World.ASTEROID_MIN_Y))
speed = float(
random.randint(World.ASTEROID_MIN_SPEED, World.ASTEROID_MAX_SPEED))
vel = speed if x == 0 else speed * -1
return x, y, vel
@merge
def merge_func(original, yours, theirs):
my_print(
"Conflict! orig={0:.2f}-{1:.2f} yours={2:.2f}-{3:.2f} theirs={4:.2f}-{5:.2f}"
.format(original.global_x, original.global_y, yours.global_x,
yours.global_y, theirs.global_x, theirs.global_y))
return theirs
class Ship(object):
oid = primarykey(int)
player_id = dimension(str)
global_x = dimension(float)
global_y = dimension(float)
velocity = dimension(float)
state = dimension(int)
trips = dimension(int)
def __init__(self, pid, x):
self.oid = random.randint(0, sys.maxsize)
self.player_id = pid
self.velocity = 0.0
self.global_x = float(x)
self.global_y = float(World.WORLD_HEIGHT)
self.trips = 0
self.state = ShipState.STOPPED
my_print("New ship at {0:.2f}-{1:.2f} vel={2:.2f}".format(
self.global_x, self.global_y, self.velocity))
def go(self):
self.velocity = -100.0
self.state = ShipState.RUNNING
def stop(self):
self.velocity = 0.0
self.state = ShipState.STOPPED
def reset(self):
self.stop()
self.global_y = World.WORLD_HEIGHT
def move(self, delta):
""" Returns True upon reaching the finish line, False otherwise
"""
if self.state == ShipState.RUNNING:
self.global_y += (self.velocity * delta)
#my_print("Ship at {0:.2f}-{1:.2f} vel={2:.2f}".format(self.global_x, self.global_y, self.velocity))
# Did we reach the end?
if self.global_y <= 0:
# We got to the finish line!
my_print("Ship {0} got to the finish line".format(self.oid))
self.reset()
return True
return False
def collision(self):
self.state = ShipState.DESTROYED
self.velocity = 0.0
my_print("Ship {0} was destroyed".format(self.player_id))
class ServerState(object):
oid = primarykey(int)
env_class_name = dimension(str)
env_config = dimension(str)
env_dimensions = dimension(tuple)
terminal = dimension(bool)
server_no_longer_joinable = dimension(bool)
winners = dimension(str)
rankings = dimension(str)
serialized_state = dimension(bytes)
def __init__(self, env_class_name, env_config, env_dimensions):
self.oid = random.randint(0, sys.maxsize)
self.env_class_name = env_class_name
self.env_config = env_config
self.env_dimensions = tuple(env_dimensions)
self.terminal = False
self.server_no_longer_joinable = False
self.winners = ""
self.rankings = ""
self.serialized_state = b""
class Lander(object):
oid = primarykey(str)
player_id = dimension(int)
ready = dimension(bool)
pos_x = dimension(int)
pos_y = dimension(int)
vel_x = dimension(float)
vel_y = dimension(float)
x_distance_to_landing = dimension(float)
y_distance_to_landing = dimension(float)
angle = dimension(float)
angular_velocity = dimension(float)
right_leg_in_contact = dimension(bool)
left_leg_in_contact = dimension(bool)
winner = dimension(bool)
done = dimension(bool)
reward = dimension(int)
main_thrust = dimension(float)
side_thrust = dimension(float)
def do_sample_action(self):
self.main_thrust, self.side_thrust = map(float, spaces.Box(-1, +1, (2,), dtype=np.float32).sample())
@property
def state(self):
return np.array([
self.x_distance_to_landing,
self.y_distance_to_landing,
self.vel_x, self.vel_y,
self.angle,
self.right_leg_in_contact,
self.left_leg_in_contact], dtype=np.float32)
def get_state(self, helipad_y):
return [
(self.pos_x - VIEWPORT_W/SCALE/2) / (VIEWPORT_W/SCALE/2),
(self.pos_y - (helipad_y+LEG_DOWN/SCALE)) / (VIEWPORT_H/SCALE/2),
self.vel.x*(VIEWPORT_W/SCALE/2)/FPS,
self.vel.y*(VIEWPORT_H/SCALE/2)/FPS,
self.body.angle,
20.0*self.body.angularVelocity/FPS,
self.legs[0].ground_contact,
self.legs[1].ground_contact
]
def __init__(self):
self.oid = str(uuid.uuid4())
self.body = None
self.legs = list()
self.prev_shaping = None
self.vel = None
self.s_power = None
self.m_power = None
self.main_thrust = 0.0
self.side_thrust = 0.0
self.ready = False
self.done = False
def set_up_local_objects(self):
self.body = None
self.legs = list()
self.prev_shaping = None
self.vel = None
self.s_power = None
self.m_power = None
def set_state(self, helipad_y):
pos = self.body.position
self.vel = self.body.linearVelocity
if self.pos_x != pos.x:
self.pos_x = pos.x
if self.pos_y != pos.y:
self.pos_y = pos.y
state = self.get_state(helipad_y)
x, y, vel_x, vel_y, angle, angularvel, l_leg, r_leg = state
if self.x_distance_to_landing != x:
self.x_distance_to_landing = x
if self.y_distance_to_landing != y:
self.y_distance_to_landing = y
if self.vel_x != vel_x:
self.vel_x = vel_x
if self.vel_y != vel_y:
self.vel_y = vel_y
if self.angle != angle:
self.angle = angle
if self.angular_velocity != angularvel:
self.angular_velocity = angularvel
if self.left_leg_in_contact != l_leg:
self.left_leg_in_contact = l_leg
if self.right_leg_in_contact != r_leg:
self.right_leg_in_contact = r_leg
reward = 0
shaping = \
- 100*np.sqrt(state[0]*state[0] + state[1]*state[1]) \
- 100*np.sqrt(state[2]*state[2] + state[3]*state[3]) \
- 100*abs(state[4]) + 10*state[6] + 10*state[7] # And ten points for legs contact, the idea is if you
# lose contact again after landing, you get negative reward
if self.prev_shaping is not None:
reward = shaping - self.prev_shaping
self.prev_shaping = shaping
reward -= self.m_power*0.30 # less fuel spent is better, about -30 for heurisic landing
reward -= self.s_power*0.03
if self.reward != reward:
self.reward = reward
class Player(object):
pid = primarykey(int)
authentication_key = dimension(str)
name = dimension(str)
number = dimension(int)
observation_port = dimension(int)
action = dimension(str)
reward_from_last_turn = dimension(float)
turn = dimension(bool)
ready_for_start = dimension(bool)
ready_for_action_to_be_taken = dimension(bool)
winner = dimension(bool)
acknowledges_game_over = dimension(bool)
def __init__(self, name, auth_key: str = ""):
self.pid = random.randint(0, sys.maxsize)
self.authentication_key = auth_key
self.name = name
self.number = -1
self.action = ""
self.turn = False # server is waiting for player to make their action
self.ready_for_action_to_be_taken = False # player is ready for their current action to executed, unset when server executes action
self.reward_from_last_turn = -1.0
self.acknowledges_game_over = False # So the server can exit once it knows players got their final pull in.
self.winner = False
self.ready_for_start = False
self.observation_port = -1
def finalize_player(self, number: int, observation_port: int):
self.number = number
self.observation_port = observation_port
