Next: , Previous: libimg, Up: C API


5.24 libker

5.24.1 Overview

View lcov test coverage results on http://www.gnu.org/software/liquidwar6/coverage/src/lib/ker/index.html.

5.24.2 API

— Function: char * lw6ker_capture_str (lw6ker_game_state_t * game_state)

game_state: game state to represent

Gives a string representation, an ASCII capture of the game. This representation is suitable for debugging, typically print it to a VT100 console.

Return value: dynamically allocated string.

— Function: void lw6ker_cursor_reset (lw6ker_cursor_t * cursor)

cursor: the cursor to reset

Sets a cursor to defaults (disabled). This function will not touch the node_id and cursor_id fields, so you can call it on an already used cursor, it will stay usable.

Return value: none

— Function: lw6ker_game_state_t * lw6ker_game_state_new (lw6ker_game_struct_t * game_struct, lw6sys_progress_t * progress)

game_struct: game_struct use to construct the object

progress: progress indicator

Creates a game state from a game struct. The game struct must be kept (never freed) while game_state is in use.

Return value: newly created object.

— Function: void lw6ker_game_state_free (lw6ker_game_state_t * game_state)

game_state: the object to free

Frees a game_state object, releases all required objects. At this stage the map_struct must still be available.

Return value: none

— Function: void lw6ker_game_state_point_to (lw6ker_game_state_t * game_state, lw6ker_game_struct_t * game_struct)

game_state: the game_state to modify

game_struct: the game_struct to point to

This can be used when one makes a copy (dup) of a game struct and for some reason want the game_state to point on this new copy. Of course you should make the game_state point to a game_struct that is identical to the one that was used to construct the object in the first place. Use at your own risk.

Return value: none

— Function: int lw6ker_game_state_memory_footprint (lw6ker_game_state_t * game_state)

game_state: the game_state to query

Returns the approximative amount of memory taken by the object.

Return value: number of bytes (approximation)

— Function: char * lw6ker_game_state_repr (lw6ker_game_state_t * game_state)

game_state: the game_state to query

Gives a readable representation of the object.

Return value: newly allocated string, must be freed

— Function: int lw6ker_game_state_can_sync (lw6ker_game_state_t * dst, lw6ker_game_state_t * src)

dst: the destination game_state

src: the source game_state

Tells wether src and dst can be synced. This is not a fool proof function but in most cases it will raise the error, use it to avoid blunders. It just compares dst and src and tries to guess if they correspond to the same logical objects.

Return value: 1 if they are syncable, 0 if not.

— Function: int lw6ker_game_state_sync (lw6ker_game_state_t * dst, lw6ker_game_state_t * src)

dst: the destination game_state

src: the source game_state

Fundamental function, used to carbon copy a game state to another, this is intensively used to keep too tracks of the game state, one most-up-to-date but probably wrong, the one we use to display on the screen, and one slightly outdated (or very outdated if network is slow) but that we're sure of, something 100% bullet proof we can rely on.

Return value: 1 on success, 0 on error

— Function: lw6ker_game_state_t * lw6ker_game_state_dup (lw6ker_game_state_t * game_state, lw6sys_progress_t * progress)

game_state: the game_state to copy

progress: progress indicator

Dups (copy) a game_state object. The newly created object points to the same game_struct but is an independant copy, you can play a whole different game on it. In practice this is often used to create the game_state objects for anticipation in network games.

Return value: newly created object

— Function: u_int32_t lw6ker_game_state_checksum (lw6ker_game_state_t * game_state)

game_state: the game_state to query

Calculates the checksum of a game_state, this can be very usefull to make sure two states are identicall (prevent network errors and/or cheating).

Return value: 32-bit checksum

— Function: void lw6ker_game_state_get_shape (lw6ker_game_state_t * game_state, lw6sys_whd_t * shape)

game_state: the game_state to query

shape: the shape (out param)

Retrieves the shape (w*h*d)of the game_state.

Return value: none.

— Function: int lw6ker_game_state_get_w (lw6ker_game_state_t * game_state)

game_state: the game_state to query

Retrieves the width (shape.w) of the game_state.

Return value: the width.

— Function: int lw6ker_game_state_get_h (lw6ker_game_state_t * game_state)

game_state: the game_state to query

Retrieves the height (shape.h) of the game_state.

Return value: the height.

— Function: int lw6ker_game_state_get_d (lw6ker_game_state_t * game_state)

game_state: the game_state to query

Retrieves the depth (shape.d, AKA number of layers) of the game_state.

Return value: the depth.

— Function: int lw6ker_game_state_register_node (lw6ker_game_state_t * game_state, u_int64_t node_id)

game_state: the game_state to act on

node_id: the id of the node to register

Registers a node in the game, this must be done, else no action will be allowed (such as adding a cursor or moving it). There's a limited number of nodes allowed, and ids must be unique.

Return value: 1 on success, 0 on failure.

— Function: int lw6ker_game_state_unregister_node (lw6ker_game_state_t * game_state, u_int64_t node_id)

game_state: the game_state to act on

node_id: the id of the node to register

Unregisters a node in the game, this must be done when a node leaves the game, it will free ressources and allow others to connect.

Return value: 1 on success, 0 on failure.

— Function: int lw6ker_game_state_node_exists (lw6ker_game_state_t * game_state, u_int64_t node_id)

game_state: the game_state to query

node_id: the node to test

Tells wether a node is present in a game.

Return value: 1 if node is in game, 0 if not

— Function: int lw6ker_game_state_get_node_info (lw6ker_game_state_t * game_state, u_int16_t node_id, u_int32_t * last_command_round)

game_state: game_state to query

node_id: the node to get info about

last_command_round: the last round for which a command was issued (out parameter)

Queries information about a given node, mostly, what was the last round we got a command.

Return value: 1 on success, 0 on error.

— Function: int lw6ker_game_state_add_cursor (lw6ker_game_state_t * game_state, u_int64_t node_id, u_int16_t cursor_id, int team_color)

game_state: the game_state to act upon

node_id: the node issuing the command

cursor_id: the id of the cursor to add

team_color: the color we wish

Adds a cursor in a game. Note that if there's already a cursor with that id, it will fail, and the color is only the color we wish, we might indeed be attributed another color on a successfull call.

Return value: 1 on success, 0 on error.

— Function: int lw6ker_game_state_remove_cursor (lw6ker_game_state_t * game_state, u_int64_t node_id, u_int16_t cursor_id)

game_state: the game_state to act upon

node_id: the node issuing the command

cursor_id: the id of the cursor to remove

Removes a cursor from the game, corresponding teams will be removed if needed.

Return value: 1 on success, 0 on failure.

— Function: int lw6ker_game_state_cursor_exists (lw6ker_game_state_t * game_state, u_int16_t cursor_id)

game_state: the game_state to query

cursor_id: the cursor to test

Tells wether a cursor is present in the game.

Return value: 1 if cursor exists, 0 if not.

— Function: int lw6ker_game_state_get_cursor (lw6ker_game_state_t * game_state, lw6ker_cursor_t * cursor, u_int16_t cursor_id)

game_state: the game_state to query

cursor: the cursor data (out param)

cursor_id: the cursor to query

Return value: 1 on success, 0 on failure.

— Function: void lw6ker_game_state_get_cursor_by_index (lw6ker_game_state_t * game_state, lw6ker_cursor_t * cursor, int i)

game_state: the game state to query

cursor: the cursor (out param)

i: the index

Gets the cursor information, using its index. This is usefull to walk the whole cursor without knowing their ids.

Return value: none.

— Function: int lw6ker_game_state_set_cursor (lw6ker_game_state_t * game_state, lw6ker_cursor_t * cursor)

game_state: the game_state to act upon

cursor: the cursor

Sets a cursor, that is, changes its position, this is pretty much anything we can do about a cursor except adding or removing it, just because of Liquid War very simple rules. The passed pointer may be freed after the call, only the cursor_id, node_id, x, y and fire fields are used, others are ignored. More precisely, the enabled will be ignored, it's not a valid way to add/remove teams.

Return value: 1 on success, 0 on failure

— Function: int lw6ker_game_state_team_exists (lw6ker_game_state_t * game_state, int team_color)

game_state: the game_state to query

team_color: the team color to test

Tells wether a team color is present in the game. Note that this is different from cursor ids.

Return value: 1 if team exists, 0 if not.

— Function: int lw6ker_game_state_get_team_info (lw6ker_game_state_t * game_state, int team_color, int32_t * nb_cursors, int32_t * nb_fighters)

game_state: the game_state to query

team_color: the color to get informations about

nb_cursors: number of cursors with this color (out param)

nb_fighters: number of fighters with this color (out param)

Gets informations about a given color. Indeed, a color can have several cursors, and knowing how many fighters there are with a given color is probably the most important things about a color.

Return value: 1 on success, 0 on failure.

— Function: int lw6ker_game_state_get_nb_teams (lw6ker_game_state_t * game_state)

game_state: the game_state to query

Tells how many teams there are in a game. This is different from the cursors number, there can be more cursors than teams, because a team can have several cursors.

Return value: the number of teams.

— Function: void lw6ker_game_state_do_spread (lw6ker_game_state_t * game_state, u_int32_t team_mask)

game_state: the game_state to act upon

team_mask: a binary mask of which gradients (teams) must be spreaded

Spreads the gradient, that is, calculates the potential of each point on the map, ie the distance to the closest cursor. The binary mask allows gradient to be spread for only some teams, this is usefull in a multithreaded context, as gradients can be calculated separately.

Return value: none

— Function: void lw6ker_game_state_do_move (lw6ker_game_state_t * game_state, u_int32_t team_mask)

game_state: the game_state to act upon

team_mask: a binary mask of which teams must be moved

Moves the fighters, note that you must calculate the gradient from time to time else they go to the wrong places. The team_mask allows the moving of only some given teams, but moving (for instance) even teams then odd teams isn't the same as moving odd teams then even teams. Whereas as far as gradient calculation is concerned, this could have been true, you could have multithreaded that.

Return value: none.

— Function: void lw6ker_game_state_finish_round (lw6ker_game_state_t * game_state)

game_state: the game_state to act upon

Finishes a round, that is, vaccums various stuff, checks if some team has lost, and so on. This is complementary to the spread and move steps, it should be called at each round.

Return value: none.

— Function: void lw6ker_game_state_do_round (lw6ker_game_state_t * game_state)

game_state: the game_state to act upon

This is a fundamental function, it's called at each round, it fires all the complex calculations in the game, the real core algorithm. Every time this function is called, the round is "over" and the game state is ready for the next... round. It's equivalent to calling the spread, move and finish functions.

Return value: none.

— Function: u_int32_t lw6ker_game_state_get_moves (lw6ker_game_state_t * game_state)

game_state: the game_state to query

Returns the number of moves done on this game.

Return value: number of moves.

— Function: u_int32_t lw6ker_game_state_get_spreads (lw6ker_game_state_t * game_state)

game_state: the game_state to query

Returns the number of spreads done on this game.

Return value: number of spreads.

— Function: u_int32_t lw6ker_game_state_get_rounds (lw6ker_game_state_t * game_state)

game_state: the game_state to query

Returns the number of rounds done on this game.

Return value: number of rounds.

— Function: u_int32_t lw6ker_game_state_get_total_rounds (lw6ker_game_state_t * game_state)

game_state: the game_state to query

Returns the number of playable rounds in the game, that is the number of rounds to be played if game goes up to the time limit. This is a fixed number, if game slows down then time is stretched, but the the exact maximum number of rounds is known at game start, and it is the number returned by this function.

Return value: number of rounds in the game

— Function: int lw6ker_game_state_is_over (lw6ker_game_state_t * game_state)

game_state: the game_state to query

Tells wether the game is over or not. The answer depends on time limit, game rules, and of course what happened on the battlefield.

Return value: 1 if over, 0 if not.

— Function: int lw6ker_game_state_did_cursor_win (lw6ker_game_state_t * game_state, u_int16_t cursor_id)

game_state: game_state to query

cursor_id: the cursor to test

Tells wether a cursor was the winner after a game is over.

Return value: 1 if cursor is in winning team, 0 if not.

— Function: int lw6ker_game_state_get_winner (lw6ker_game_state_t * game_state, int excluded_team)

game_state: the game_state to query

excluded_team: a team to exclude

Returns the winner, if you set excluded_team to something else than a valid team number (for instance -1, but 0 is a valid team) then this team will be excluded from search. This is usefull if you want to find out who's the best positionned player while excluding yourself, for instance if you're a bot.

Return value: the winner team number, note that it can be invalid (-1) if there's no winner (for example, there are no teams on the map).

— Function: int lw6ker_game_state_get_looser (lw6ker_game_state_t * game_state, int excluded_team)

game_state: the game_state to query

excluded_team: a team to exclude

Returns the looser, if you set excluded_team to something else than a valid team number (for instance -1, but 0 is a valid team) then this team will be excluded from search. This is usefull if you want to find out who's the worst positionned player while excluding yourself, for instance if you're a bot.

Return value: the looser team number, note that it can be invalid (-1) if there's no looser (for example, there are no teams on the map).

— Function: int32_t lw6ker_game_state_get_nb_active_fighters (lw6ker_game_state_t * game_state)

game_state: the game_state to query

Gets the number of active fighters, this is relatively constant within the game, it does not change when someone looses, but it can vary when a new team arrives or disappears.

Return value: number of fighters.

— Function: int32_t lw6ker_game_state_get_time_elapsed (lw6ker_game_state_t * game_state)

game_state: the game_state to query

Returns the time elapsed, this is not the real time you'd time with an atomic clock, rather the time that would have elapsed if game had been run at its nominal speed. There can be a difference if your computer is too slow, among other things.

Return value: time elapsed, in seconds.

— Function: int32_t lw6ker_game_state_get_time_left (lw6ker_game_state_t * game_state)

game_state: the game_state to query

Returns the time left, this is not the real time you'd time with an atomic clock, rather the time that would theorically be left is game was to be run at its nominal speed. There can be a difference if your computer is too slow, among other things. You shouldn't rely on this to know wether a game is over or not, there's another dedicated function for that.

Return value: time left, in seconds.

— Function: int32_t lw6ker_game_state_get_global_history (lw6ker_game_state_t * game_state, int i, int team_id)

game_state: the game_state to query

i: the index of the history point

team_id: the team to query

Returns the number of fighters at some point in the past (the lower i, the oldest). The history scrolls automatically and erases itself at some point, it's of constant length. This is the global, long term history, reflects the whole game and could be used for an end-game score screen.

Return value: number of fighters at that time.

— Function: int32_t lw6ker_game_state_get_latest_history (lw6ker_game_state_t * game_state, int i, int team_id)

game_state: the game_state to query

i: the index of the history point

team_id: the team to query

Returns the number of fighters at some point in the past (the lower i, the oldest). The history scrolls automatically and erases itself at some point, it's of constant length. This is the latest, short term history, reflects the recent game evolutions and could be used to display an in-game monitor.

Return value: number of fighters at that time.

— Function: int32_t lw6ker_game_state_get_global_history_max (lw6ker_game_state_t * game_state)

game_state: game_state to query

Returns the maximum value, that is, the maximum number of fighters, all teams combined, for this history. This can be used to scale charts. This function for the global long term history.

Return value: max number of fighters.

— Function: int32_t lw6ker_game_state_get_latest_history_max (lw6ker_game_state_t * game_state)

game_state: game_state to query

Returns the maximum value, that is, the maximum number of fighters, all teams combined, for this history. This can be used to scale charts. This function for the latest short term history.

Return value: max number of fighters.

— Function: int32_t lw6ker_game_state_get_fighter_id (lw6ker_game_state_t * game_state, int32_t x, int32_t y, int32_t z)

game_state: game_state to query

x: x position

y: y position

z: z position

Gets the id of a fighter in a given position. Previous versions of the game used to have this declared inline static for speed, but the price to pay in terms of maintainability was too high: too much stuff from the ker module had to be kept public. This functions is very likely to be called often when one wants to know what's happening on the battlefield, to draw it, for instance. If there's no fighter, the id is negative, any id equal or greater than 0 (returned by this function) is valid.

Return value: the id of the fighter at that position.

— Function: lw6ker_fighter_t * lw6ker_game_state_get_fighter_by_id (lw6ker_game_state_t * game_state, int32_t fighter_id)

game_state: game_state to query

fighter_id: the id of the fighter

Gets a fighter by its id. Internally, all fighters are stored in an array so it could be "safe" to get fighter with id 0 then walk the array. Previous versions of the game used to have this public (the array), it has been hidden since.

Return value: pointer to the fighter with the given id.

— Function: lw6ker_fighter_t * lw6ker_game_state_get_fighter_safe (lw6ker_game_state_t * game_state, int32_t x, int32_t y, int32_t z)

game_state: game_state to query

x: x position

y: y position

z: z position

Gets a fighter by its position. This function will check for boundaries, if there's no fighter in this place, it will return NULL, but nothing worse can happen. More precisely, if the place is in a wall, it won't bug, unlike the non-bullet-proof equivalent of this function.

Return value: pointer to the fighter at this position, or NULL if none.

— Function: lw6ker_fighter_t * lw6ker_game_state_get_fighter_unsafe (lw6ker_game_state_t * game_state, int32_t x, int32_t y, int32_t z)

game_state: game_state to query

x: x position

y: y position

z: z position

Gets a fighter by its position. This function will not check for boundaries, if there's no fighter in this place, not only will it probably not return a valid value, but it will also even segfault before that, trying to access non-existing structures in menory. So only call this if you're sure there's a fighter here.

Return value: pointer to the fighter at this position, or NULL if none.

— Function: int lw6ker_game_state_get_zone_potential (lw6ker_game_state_t * game_state, int i, int team_id)

game_state: the game_state to query

team_id: the team id (color)

Gets the potential of a zone. In practice this is not needed to make the game function, you need not call this to know how to move fighters, however the information can be interesting for debugging.

Return value: the potential

— Function: int lw6ker_game_state_get_charge_per1000 (lw6ker_game_state_t * game_state, int team_color)

game_state: game_state to query

team_color: the team color to query

Returns the charge ratio for a given team/color. A value of 100 means fire is enabled, more than 1000 means super-charge, under 100 means you have to wait.

Return value: integer value.

— Function: int lw6ker_game_state_get_weapon_per1000_left (lw6ker_game_state_t * game_state, int team_color)

game_state: game_state to query

team_color: the team color to query

Returns how much of the weapon is yet to be consumed for a given team. More than 1000 means extra time, 1000 is standard time to be elapsed, 0 means it's over.

Return value: integer value.

— Function: int lw6ker_game_state_get_latest_weapon (lw6ker_game_state_t * game_state, int * team_color, int * weapon_id, int * per1000_left)

game_state: game_state to query

team_color: the team color corresponding to last weapon (out param)

weapon_id: the corresponding weapon_id (out param)

per1000_left: how much of the weapon is yet to be spent (out param)

Returns informations about the latest weapon, this is typically for drawing purposes, just query this and you know if you need to paint everything in red, green, whatever, as far as the default backend is concerned. In case there's no weapon, well, parameters are untouched. Pointers can be passed as NULL.

Return value: 1 if found, 0 if not.

— Function: lw6ker_game_struct_t * lw6ker_game_struct_new (lw6map_level_t * level, lw6sys_progress_t * progress)

level: the level on which the game_struct is based

progress: progress indicator

Creates a new game_struct from a level. The game_struct is different from the level in the sense that the game_struct does contain algorithmic specific optimizations, it's a ready-to-use struct desgined for execution speed, while the plain level just stores information.

Return value: newly allocated object

— Function: void lw6ker_game_struct_free (lw6ker_game_struct_t * game_struct)

game_struct: the game_struct to free

Frees a game_struct object, releasing all required stuff. The source level must still be available when freeing this.

Return value: none

— Function: void lw6ker_game_struct_point_to (lw6ker_game_struct_t * game_struct, lw6map_level_t * level)

game_struct: the game_struct to modify

level: the level to point to

This can be used when one makes a copy (dup) of a level and for some reason want the game_struct to point on this new copy. Of course you should make the game_struct point to a level that is identical to the one that was used to construct the object in the first place. Use at your own risk.

Return value: none

— Function: int lw6ker_game_struct_memory_footprint (lw6ker_game_struct_t * game_struct)

game_struct: the game_struct to query

Returns the approximative amount of memory taken by the object.

Return value: number of bytes (approximation)

— Function: char * lw6ker_game_struct_repr (lw6ker_game_struct_t * game_struct)

game_struct: the game_struct to query

Gives a readable representation of the object.

Return value: newly allocated string, must be freed

— Function: lw6ker_game_struct_t * lw6ker_game_struct_dup (lw6ker_game_struct_t * game_struct, lw6sys_progress_t * progress)

game_struct: the game_struct to copy

progress: progress indicator

Dups (copy) a game_struct object. The newly created object points to the same game_struct but is an independant copy, you can play a whole different game on it. In practice this is often used to create the game_struct objects for anticipation in network games.

Return value: newly created object

— Function: u_int32_t lw6ker_game_struct_checksum (lw6ker_game_struct_t * game_struct)

game_struct: the game_struct to query

Calculates the checksum of a game_struct, this can be very usefull to make sure two structs are identicall (prevent network errors and/or cheating).

Return value: 32-bit checksum

— Function: void lw6ker_game_struct_get_shape (lw6ker_game_struct_t * game_struct, lw6sys_whd_t * shape)

game_struct: the game_struct to query

shape: the shape (out param)

Retrieves the shape (w*h*d)of the game_struct.

Return value: none.

— Function: int lw6ker_game_struct_get_w (lw6ker_game_struct_t * game_struct)

game_struct: the game_struct to query

Retrieves the width (shape.w) of the game_struct.

Return value: the width.

— Function: int lw6ker_game_struct_get_h (lw6ker_game_struct_t * game_struct)

game_struct: the game_struct to query

Retrieves the height (shape.h) of the game_struct.

Return value: the height.

— Function: int lw6ker_game_struct_get_d (lw6ker_game_struct_t * game_struct)

game_struct: the game_struct to query

Retrieves the depth (shape.d, AKA number of layers) of the game_struct.

Return value: the depth.

— Function: int lw6ker_game_struct_is_fg (lw6ker_game_struct_t * game_struct, int32_t x, int32_t y, int32_t z)

game_struct: the game_struct to query

x: x position

y: y position

z: z position

Tests wether a given position is foreground, that is, occupied by a wall.

Return value: 1 if foreground (wall, fighters can't move), 0 if not

— Function: int lw6ker_game_struct_is_bg (lw6ker_game_struct_t * game_struct, int32_t x, int32_t y, int32_t z)

game_struct: the game_struct to query

x: x position

y: y position

z: z position

Tests wether a given position is background, that is, there's no wall.

Return value: 1 if background (wall, fighters can move), 0 if not

— Function: void lw6ker_game_struct_get_zones_info (lw6ker_game_struct_t * game_struct, int * nb_zones, int * max_zone_size)

game_struct: game_struct to query

nb_zones: the maximum zone size (out param, can be NULL)

max_zone_size: the maximum zone size (out param, can be NULL)

This function gets information about the internal zoning system, can be used for debugging.

Return value: none.

— Function: void lw6ker_game_struct_get_zone_info (lw6ker_game_struct_t * game_struct, int i, lw6sys_xyz_t * zone_pos, int * zone_size)

game_struct: game_struct to query

i: index of the zone to query

zone_pos: coord of the zone, top-left corner (out param, can be NULL)

zone_size: size of the zone (out param, can be NULL)

This function gets information about the internal zoning system, can be used for debugging.

Return value: none

— Function: int32_t lw6ker_game_struct_get_zone_id (lw6ker_game_struct_t * game_struct, int32_t x, int32_t y, int32_t z)

game_struct: the game_struct to query

x: x pos

y: y pos

z: z pos

Gets the zone id for a given position. The id returned can then be used to query for a potential, for instance.

Return value: the zone id

— Function: void lw6ker_game_struct_find_free_slot_near (lw6ker_game_struct_t * game_struct, lw6sys_xyz_t * there, lw6sys_xyz_t here)

game_struct: the game_struct to query

there: the closest free slot (out param)

here: where we'd like to be

Tries to find the closest free slot (there) near a given position (here). This is typically used internally to find out where to apply the cursor when it's flying over walls.

Return value: none

— Function: int lw6ker_move_get_best_next_pos (lw6ker_game_state_t * game_state, lw6sys_xyz_t * next_pos, lw6sys_xyz_t * current_pos, int team_color)

game_state: the game_state to work on

next_pos: the next position (out param)

current_pos: the current position

team_color: the team color

Tries to find the best move given a position and a team. Note that this function does not check for the presence of another fighter, it will only check walls and can even (sometimes) fail when there's a path. The reason is that it uses the game_state at a given round and does not recalculate gradient while a real fighter has an ever-changing gradient. Whatsoever, this can be used to move cursors like they were fighters, it's not perfect but gives a good illusion.

Return value: 1 if best place found, 0 if not.

— Function: int lw6ker_score_array_update (lw6ker_score_array_t * score_array, lw6ker_game_state_t * game_state)

score_array: the score array to modify

game_state: the game_state to get the information from

Updates a score array, that is, calculates all scores, so that they can be displayed, for instance.

Return value: 1 on success, 0 on failure.

— Function: void lw6ker_team_mask_get (u_int32_t * even, u_int32_t * odd, int32_t round)

even: even team mask (out param)

odd: odd team mask (out param)

round: round concerned

Returns a default team mask for a given round, even and odd will contain ready to use masks (for spread and move functions for instance).

Return value: none.

— Function: void lw6ker_team_mask_best (u_int32_t * even, u_int32_t * odd, lw6ker_game_state_t * game_state)

even: even team mask (out param)

odd: odd team mask (out param)

game_state: the game_state concerned

Returns an optimal team mask for a given round, even and odd will contain ready to use masks (for spread and move functions for instance). The difference with the default team mask is that this one will test for which teams are present and try and manage to find an equilibrated set of odd/even teams.

Return value: none.

— Function: int lw6ker_team_mask_is_concerned (int team_color, u_int32_t team_mask)

team_color: color index

team_mask: team mask

Tells wether a given team is concerned by a team mask.

Return value: 1 if concerned, 0 if not.

— Function: int lw6ker_team_mask_color2mask (int team_color)

team_color: color index

Gives the mask corresponding to a given color.

Return value: bitwise mask.

— Function: int lw6ker_test (int mode)

mode: 0 for check only, 1 for full test

Runs the ker module test suite. Will perform deep checksums and *really* check many things. If this passes, the algorithm is fine. What could make it fail is a serious bug and/or some weird combination of endianess, byte alignment...

Return value: 1 if test is successfull, 0 on error.