class ClassWithCounter(object): oid = primarykey(int) counter = dimension(Counter) def __init__(self, oid): self.oid = oid self.counter = Counter(oid)
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 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
class Counter(object): oid = primarykey(int) count = dimension(int) def __init__(self, oid): self.oid = oid self.count = 0
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 _Observation: """ Base observation class that specific observations will be created from. """ pid = primarykey(int) def __init__(self, pid: int): self.pid = pid def set_observation(self, observations: Dict[str, np.ndarray]): for key, value in observations.items(): self.__setattr__(key, value)
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 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 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 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 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 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 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 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 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 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 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