CYLGame package

Submodules

CYLGame.Comp module

class CYLGame.Comp.MultiplayerComp(bots, room_size, default_bot_class, run_factor=10)

Bases: object

static make_bot(gamedb, compiler, token, debug=False)

next()

static sim_comp(c_token, gamedb, game, compiler, save_games=False, debug=False)

static sim_multiplayer(s_token, gamedb, game, compiler, save_games=False, debug=False)

class CYLGame.Comp.MultiplayerCompRunner(interval, gamedb, game, compiler, debug=False)

Bases: multiprocessing.context.Process

run()

Method to be run in sub-process; can be overridden in sub-class

stop()

class CYLGame.Comp.Ranking(bots)

Bases: object

add_rank(standing, bot)

class CYLGame.Comp.RollingMultiplayerComp(room_size, default_bot_class, rolling_n)

Bases: object

add_bot(bot, gamedb)

add_bot_if_needed(bot, gamedb)

next()

save_rolling_scores(gamedb)

class CYLGame.Comp.RollingMultiplayerCompRunner(interval, gamedb, game, compiler, rolling_n=100, batch_size=4, debug=False)

Bases: multiprocessing.context.Process

clean_up_old_games()

make_bot(token)

run()

Method to be run in sub-process; can be overridden in sub-class

stop()

CYLGame.Comp.avg(scores)

CYLGame.Comp.create_room(gamedb, bot, compiler, size)

CYLGame.Comp.sim_competition(compiler, game, gamedb, token, runs, ncores=None, debug=False, score_func=<function avg>)

Parameters

• compiler –

• game –

• gamedb –

• token –

• runs –

• ncores – If None will default to the number of all available cores.

• debug –

• score_func –

Returns:

CYLGame.Comp.sim_prog_for_score(game, compiler, code, options, seed, debug=True)

CYLGame.Database module

class CYLGame.Database.GameDB(root_dir)

Bases: object

This is the database that stores all persisted data. This database is a file based DB.

/ => Root game directory /data => Should be named something like “users”. This stores user related data. /data/TOKEN => A directory containing data for the user with the token TOKEN. /data/TOKEN/avg_score => File containing a single float representing the average score for the user. /data/TOKEN/name => File containing the name for the user. /data/TOKEN/code => Directory containing all code submitted by the user. /data/TOKEN/code/CTIME_HASH => The code submitted or played at CTIME. /data/TOKEN/code/CTIME_HASH/code.lp /data/TOKEN/code/CTIME_HASH/options.mp.gz /data/TOKEN/games => A directory related games. /data/TOKEN/games/GTOKEN => An empty file representing that the users bot was used in game GTOKEN. /games => Stores game related data. /schools => Stores school related data. /competitions => Stores competition related data. /www => Stores static and template files for the server. This is a cache that is deleted and

recreated on each restart.

ACTIVE_CODE_KEY = 'active_code'

CODE_DIR = 'code'

CODE_FILENAME = 'code.lp'

OPTIONS_FILENAME = 'options.mp.gz'

TOKEN_LEN = 8

add_game_to_comp(ctoken, gtoken)

add_new_competition(name='', _token=None)

add_new_game(frames=None, per_player_data=None, player_tokens=None)

add_new_school(name='', _token=None)

add_school_to_comp(ctoken, stoken)

delete_game(gtoken)

get_active_code_and_options(token)

get_all_comp_tokens()

get_all_game_tokens()

get_avg_score(token, default_value=None)

get_code_by_hash(code_hash_prefix)

Returns the code for the code hash or a list of hashes if the code hash prefix matches multiple codes.

get_comp_avg_score(ctoken, stoken)

get_comp_code(ctoken, stoken)

get_comp_tokens()

get_comps_for_token(utoken)

get_ctime_for_game(token)

get_exception(token)

get_exception_tokens()

get_game_frames(gtoken)

get_games_for_token(token)

get_name(token)

get_new_token(school_tk, _token=None)

get_player_game_data(gtoken, token)

get_players_for_game(gtoken)

get_school_for_token(token)

get_school_tokens()

get_schools_in_comp(ctoken)

get_tokens_for_school(school_tk)

get_value(token, key, default_value=None)

is_comp_token(token)

is_exception_token(token)

is_game_token(gtoken)

is_school_token(token)

is_user_token(token)

remove_game_from_comp(ctoken, gtoken)

replace_games_in_comp(ctoken, new_gtokens, cleanup=True)

save_avg_score(token, score)

Save a user’s average score.

Parameters

• token (str) – The user’s token.

• score (int) – The user’s average score.

save_code(token, code, options=None, set_as_active=True)

Save a user’s code under their token.

Parameters

• token (str) – The user’s token.

• code (str) – The user’s code.

• options (json-able object) – The user’s options.

• set_as_active (bool) – Whether to set the saved code as the active code for the token.

save_exception(exception_report)

save_game_frames(gtoken, frames)

save_name(token, name)

Save a user’s name under their token.

Parameters

• token (str) – The user’s token.

• name (str) – The user’s name.

save_value(token, key, value)

Save a key value pair to a tokens directory. If a value has been saved under the same key it will be

overwritten by the new value passed in. The value can be looked up using the get_value function.

Parameters

• token (str) – Any valid token.

• key (str) – The key to store the value under.

• value (str or int or float) – The value to be stored.

set_comp_avg_score(ctoken, stoken, score)

set_comp_school_code(ctoken, stoken, code)

set_game_player(gtoken, token, data=None)

class CYLGame.Database.WWWCache(root_dir)

Bases: object

safe_replace_cache(www_dir)

This function safely replaces the current www cached data with the data found in www_dir

property static_dir

property template_dir

CYLGame.Database.read_json(filename)

CYLGame.Database.write_json(o, filename)

CYLGame.Display module

class CYLGame.Display.CharSet(image_filepath: pathlib.Path, char_width: int, char_height: int, char_rows: int, char_columns: int)

Bases: CYLGame.Sprite.SpriteSet

char_columns: int

char_height: int

char_rows: int

char_size_to_pix(size)

char_width: int

create_char_img(char)

classmethod from_sprite_set(sprite_set)

get_img(char)

image_filepath: pathlib.Path

pix_size_to_char(size)

class CYLGame.Display.Display(width, height, title=None)

Bases: object

get_keys()

Gets the keys that were press since last time you called this function.

Returns

Key

get_size()

update(frame_buffer)

Updates the display with the buffer given.

Parameters

frame_buffer (FrameBuffer) – The buffer to use when redrawing the screen.

class CYLGame.Display.PyGameDisplay(width, height, title=None)

Bases: CYLGame.Display.Display

get_keys()

Gets the keys that were press since last time you called this function.

Returns

Key

update(frame_buffer)

Updates the display with the buffer given.

Parameters

frame_buffer (FrameBuffer) – The buffer to use when redrawing the screen.

CYLGame.Display.get_clock()

CYLGame.Frame module

class CYLGame.Frame.FrameBuffer

Bases: object

class CYLGame.Frame.GameFrame

Bases: CYLGame.Frame.FrameBuffer

draw_char(c, x, y, height, width)

draw_crater(x, y, rotation, color)

draw_sensors(x, y, rotation, turret, color, sensors)

draw_tank(x, y, rotation, turret, fire, led, color)

get_obj_array()

class CYLGame.Frame.GridFrameBuffer(width, height, charset=None, init_value='\x00')

Bases: CYLGame.Frame.FrameBuffer

draw_to_surface(surface)

dump()

Returns

a copy of the frame buffer’s grid

Return type

List[List[int]]

classmethod from_string_array(frame)

set(x, y, char)

Parameters

• x (int) –

• y (int) –

• char (int) – The id of the char.

CYLGame.Frame.grid_char_to_int(c: Union[int, str, CYLGame.Sprite.Char]) → int

CYLGame.Game module

class CYLGame.Game.Game(random)

Bases: object

GAME_TITLE = ''

MULTIPLAYER = False

OPTIONS: Optional[str] = None

SCREEN_HEIGHT = 0

SCREEN_WIDTH = 0

WEBONLY = True

create_new_player(prog)

This creates n new objects that inherits from the Player class.

Returns

n new objects that inherit from the Player class with the given program.

static default_prog_for_bot(language)

static default_prog_for_computer()

This method is only for multi-player games to implement. :returns: type[Prog]

do_turn()

get_debug_vars()

get_frame()

static get_intro()

static get_move_consts()

static get_number_of_players()

This method is only for multi-player games to implement. :returns: The number of players needed to play the game. :rtype: int

init_board()

is_running()

This is how the game runner knows if the game is over.

Returns

True if the game should still be play. False otherwise

Return type

bool

start_game()

class CYLGame.Game.GameLanguage

Bases: object

LITTLEPY = 0

static get_language_description(language)

class CYLGame.Game.GameRunner(game_class: Type[CYLGame.Game.Game])

Bases: object

init_game(seed: int) → CYLGame.Game.PlayGameState

static move_game(state: CYLGame.Game.PlayGameState, move: str) → CYLGame.Game.PlayGameState

run(room, playback=True)

The the game.

Parameters

• room (Room) – The room to play.

• playback (bool) – if True save the playback.

Returns

Return type

Room

run_for_avg_score(room, times=1, func=<function scorer.<locals>.wrapped>)

Runs the given game keeping only the scores.

Parameters

times (int) – The number of times to run to get the average score.

Returns

The return value the average score for the times runs.

run_with_local_display(seed=None)

Will run the game for a user.

Returns:

class CYLGame.Game.GridGame(random)

Bases: CYLGame.Game.Game

CHAR_HEIGHT = 8

CHAR_SET = '/home/runner/work/CYLGame/CYLGame/CYLGame/data/fonts/terminal8x8_gs_ro.png'

CHAR_WIDTH = 8

GAME_TITLE = ''

SCREEN_HEIGHT = 25

SCREEN_WIDTH = 80

WEBONLY = False

create_new_player(prog)

TODO: write this

static default_prog_for_bot(language)

do_turn()

This function should read the new state of all the players and react to them.

draw_screen(frame_buffer)

WARNING: There MUST NOT be any game logic in this function since it isn’t called when simulating the game during the competitions.

get_frame()

static get_intro()

static get_move_consts()

get_score()

This is the game runner gets the ending or mid-game score

Returns

The current score.

Return type

int

classmethod get_sprite_set() → CYLGame.Sprite.SpriteSet

get_vars(player)

TODO: write this

is_running()

This is how the game runner knows if the game is over.

Returns

True if the game should still be play. False otherwise

Return type

bool

class CYLGame.Game.NonGridGame(random)

Bases: CYLGame.Game.Game

WEBONLY = True

get_vars_for_bot()

read_bot_state(state)

class CYLGame.Game.PlayGameState(game: CYLGame.Game.Game, computer_players: List[CYLGame.Player.Player], human_player: CYLGame.Player.Player, human_prog: CYLGame.Player.UserProg, seed: int, moves: str, frame: Optional[List[List[int]]])

Bases: object

computer_players: List[CYLGame.Player.Player]

frame: Optional[List[List[int]]]

game: CYLGame.Game.Game

human_player: CYLGame.Player.Player

human_prog: CYLGame.Player.UserProg

moves: str

seed: int

CYLGame.Game.average(a, b=None)

CYLGame.Game.data_file(filename)

CYLGame.Game.run(game_class, avg_game_func=<function scorer.<locals>.wrapped>)

CYLGame.Game.scorer(func)

This function is a decorator for a scoring function. This is hack a to get around self being passed as the first argument to the scoring function.

CYLGame.Panels module

class CYLGame.Panels.Map(width, height, default_char=' ')

Bases: object

char_to_ps: This is a dictionary which has a character for the keys and the value for the key is a set of all the

positions where that char is located.

p_to_char: The is a dictionary which has a position(tuple with two elements: x and y) as a key and the current

ColoredChar as the value.

add(char: Union[str, int, CYLGame.Sprite.Char], pos)

get_all_pos(char)

get_char_at(pos)

get_diff()

get_x_y_dist_to_foo(pos, foo, wrapping=False, diagonal_moving=False, default=None)

in_bounds(pos)

rm_char(pos)

shift_all(offset, wrap_x=False, wrap_y=False)

wrap(pos, wrap_x=False, wrap_y=False)

class CYLGame.Panels.MapPanel(x, y, w, h, default_char=' ', border=<CYLGame.Panels.PanelBorder object>, padding=<CYLGame.Panels.PanelPadding object>)

Bases: CYLGame.Panels.Panel

first_draw(frame_buffer)

redraw(frame_buffer)

class CYLGame.Panels.MessagePanel(x, y, w, h, default_char=' ', border=<CYLGame.Panels.PanelBorder object>, padding=<CYLGame.Panels.PanelPadding object>)

Bases: CYLGame.Panels.Panel

This panel contains messages to be displayed to the user. It acts as a scrolling text log. This means that the first message is display on the first line and some on till you have enough messages to fill the height. Then the next message added will push all the other messages up and the first message will be discarded.

Example

A MessagePanel with height of 3. Add messages “A”, “B” and “C”. It will display like the following:

A B C

Add message “D” and it will display like the following:

B C D

Note

The following is deprecated: >>> m = MessagePanel() >>> m += [“Hi”] You should do this instead: >>> m = MessagePanel() >>> m.add(“Hi”)

add(messages)

clear()

get_current_messages()

redraw(frame_buffer)

class CYLGame.Panels.Panel(x, y, w, h, background_char=' ', border=<CYLGame.Panels.PanelBorder object>, padding=<CYLGame.Panels.PanelPadding object>)

Bases: CYLGame.Panels.Map

draw_char(char, pos, frame_buffer)

redraw(frame_buffer)

class CYLGame.Panels.PanelBorder(sides=0, char=None)

Bases: object

BOTTOM = 8

DEFAULT_CHARS = {1: 'Ä', 2: '³', 3: '¿', 4: '³', 5: 'Ú', 8: 'Ä', 10: 'Ù', 12: 'À'}

LEFT = 4

RIGHT = 2

TOP = 1

static create(top=False, bottom=False, right=False, left=False, top_right=False, top_left=False, bottom_right=False, bottom_left=False)

Use this method for an easy way to create nice borders. Set any side to true to create a border with the default characters. You can also set any side to a character which will create a border with that character instead. In order for the corners (top_right, top_left, …) to be rendered both of their respective sides must be set to True or a char.

Ex. >>> PanelBorder.create(top=True) # This will create a top border with the default char

>>> PanelBorder.create(top='$')  # This will create a top border of '$'s.

>>> PanelBorder.create(top='=', left='!', top_left='?')  # This will create a border looking like some thing below.
    ?====
    !
    !

has_side(side)

class CYLGame.Panels.PanelPadding(sides=0, size=0)

Bases: object

BOTTOM = 8

DEFAULT_SIZE = 0

LEFT = 4

RIGHT = 2

TOP = 1

static create(top=False, bottom=False, right=False, left=False)

has_side(side)

class CYLGame.Panels.StatusPanel(x, y, w, h, default_char=' ', border=<CYLGame.Panels.PanelBorder object>, padding=<CYLGame.Panels.PanelPadding object>)

Bases: CYLGame.Panels.MessagePanel

get_current_messages()

CYLGame.Panels.to_char(c: Union[str, int, CYLGame.Sprite.Char]) → str

CYLGame.Panels.to_coord(p: Union[Tuple[int, int], List[int]]) → Tuple[int, int]

CYLGame.Player module

class CYLGame.Player.DefaultGridPlayer(prog: CYLGame.Player.Prog, bot_consts: CYLGame.structures.const_mapping.ConstMapping)

Bases: CYLGame.Player.Player

Make sure that all bot_vars are updated in game.do_turn

get_state() → dict

update_state(state: dict)

class CYLGame.Player.LittlePythonProg(prog: littlepython.interpreter.LPProg, options: dict, token: Optional[str] = None, name: Optional[str] = None, code_hash: Optional[str] = None)

Bases: CYLGame.Player.Prog

run(*args, **kargs)

class CYLGame.Player.Player(prog: CYLGame.Player.Prog)

Bases: abc.ABC

abstract get_state() → dict

run_turn(random: random.Random, max_ops: int = 1000000)

abstract update_state(new_state: dict)

class CYLGame.Player.Prog(options: dict, token: Optional[str] = None, name: Optional[str] = None, code_hash: Optional[str] = None)

Bases: abc.ABC

abstract run(state: dict, max_op_count: int = - 1, random=None)

class CYLGame.Player.Room(bots: Optional[List[CYLGame.Player.Prog]] = None, seed=None)

Bases: object

property rand_seeded

A randomly seeded room with the same bots.

save(gamedb)

The method saves the game data to a new game. Note: this room must be run before calling this function.

Parameters

gamedb (GameDB) – The current game database.

Returns: The gtoken of the newly created game.

class CYLGame.Player.UserProg

Bases: CYLGame.Player.Prog

run(*args, **kwargs)

CYLGame.SensorGame module

class CYLGame.SensorGame.SensorGame(random)

Bases: CYLGame.Game.NonGridGame

NONGRID = True

OPTIONS: Optional[str] = 'sensors'

WEBONLY = True

do_sensors()

class CYLGame.SensorGame.SensorPlayer(prog: CYLGame.Player.Prog)

Bases: CYLGame.Player.Player

add_sensor(_range, angle, width, turret)

Adds a sensor to this player. _range: integer [0, 100], the distance that the sensor travels angle: integer [0, 360], the direction in degrees the sensor points width: integer [0, 360], the width in degrees of the sensor turret: bool, if True, the angle is relative to the turret’s angle, otherwise angle is relative to the tank’s angle

sensor_calc(other, dist_sq, vector, tank_sensor_range)

See if other is in any of our sensors.

class CYLGame.SensorGame.SensorSanitizers

Bases: object

color_re = re.compile('#[0-9A-Fa-f]{6}')

static san_angle(a)

static san_color(c)

static san_range(r)

static san_turret(t)

static san_width(w)

CYLGame.SensorGame.compute_vector(start, end, screen_width, screen_height)

Computes the vector and distance between two objects, start and end. start and end must have a position attribute which is a list/tuple of the x and y coord.

CYLGame.SensorGame.deg2rad(deg)

CYLGame.SensorGame.dprint(string)

CYLGame.SensorGame.rad2deg(rad)

CYLGame.SensorGame.rotate_point(angle, point)

CYLGame.Server module

class CYLGame.Server.GameServer

Bases: flask_classful.FlaskView

avg_game_count = None

before_request(name, **kwarg)

charset = None

check_token()

comp_scoreboards()

compression = None

game = None

gamedb = None

get_game_data(gtoken)

get_player()

get_player_game_data(gtoken, token)

host = None

index()

language = None

load_code()

play()

play_game_cache: cachetools.LRUCache

port = None

route_base = '/'

save_code()

scoreboard()

classmethod serve(game, host='', port=5000, compression=False, language=0, avg_game_count=10, multiplayer_scoring_interval=20, num_of_threads=None, game_data_path='temp_game', avg_game_func=<function scorer.<locals>.wrapped>, debug=False, reuse_addr=None, play_cache_size=64, error_log_file='{dbfile}/log/error.log', debug_log_file='{dbfile}/log/debug.log')

sim()

sim_avg()

CYLGame.Server.find_name_from_code(code)

CYLGame.Server.get_public_ip()

CYLGame.Server.serve(game, host='', port=5000, compression=False, language=0, avg_game_count=10, multiplayer_scoring_interval=20, num_of_threads=None, game_data_path='temp_game', avg_game_func=<function scorer.<locals>.wrapped>, debug=False, reuse_addr=None, play_cache_size=64, error_log_file='{dbfile}/log/error.log', debug_log_file='{dbfile}/log/debug.log')

CYLGame.Utils module

class CYLGame.Utils.OnlineMean(i=0, mean=0, roll_after_n=- 1)

Bases: object

add(n)

property floored_mean

rounded_mean(places=2)

CYLGame.Utils.choose(n, k)

CYLGame.Utils.decrypt_token_list(tokens, key)

CYLGame.Utils.deprecated(message='')

CYLGame.Utils.encrypt_token_list(tokens, key)

CYLGame.Utils.hash_stream(fp)

CYLGame.Utils.hash_string(s, encoding='utf8')

CYLGame.Utils.int2base(x, base)

This function converts an int to a str using a specific base.

Note: This function was created to support weird bases that don’t already have a builtin method. So if you want to

convert ints to base 2, 8, 16 it is better to use bin, oct, hex method respectively.

CYLGame.Utils.prefix_filename(p: pathlib.Path, prefix: str)

CYLGame.version module

Module contents