NAME
SYNOPSIS
DESCRIPTION
DATA STRUCTURES
FUNCTIONS
CALLBACK FUNCTIONS
SEE ALSO
THANKS
AUTHOR
COPYRIGHT

NAME

GGTL-Reversi- GGTL extension for playing Reversi (aka Othello)

SYNOPSIS

  #include <ggtl/reversi.h>
  
  GGTL *reversi_init(GGTL *g, void *state);
  RMove *reversi_move_new(int x, int y, GGTL *g);
  RState *reversi_state_new(int size);
  void reversi_state_draw(RState *state);
  RStateCount reversi_state_count(RState *state);
  
  /* callback functions used by ggtl core */
  void *reversi_state_clone(void *state, GGTL *g);
  int reversi_eval(void *state, GGTL *g);
  void reversi_state_free(void *state);
  GGTL_MOVE *reversi_get_moves(void *state, GGTL *g);
  void *reversi_move(void *s, void *mv, GGTL *g);

See reversi-demo(3) for a complete example of a self-playing Reversi game using this extension.

DESCRIPTION

GGTL-Reversi is a GGTL extension for playing Reversi (aka Othello). It provides all the callback functions and datastructures GGTL needs to provide a Reversi AI, leaving you free to worry about other aspects of the game.

All even board sizes greater than 4x4 are supported and can be specified at run time.

DATA STRUCTURES

Three data structures are used by this GGTL extension. They are:

RState

  typedef struct reversi_state {
    int player;
    int size;
    int **board;
  } RState;

RMove

  typedef struct reversi_move {
    int x;
    int y;
  } RMove;

RStateCount

  typedef struct reversi_counts {
    int c[3];
  } RStateCount;

FUNCTIONS

RState *reversi_state_new( int size ): Returns a reversi state with a board of the desired size, or NULL on failure. The board is set up for the beginning of a game and player 1 is set to start.
void *reversi_state_clone( void *s, GGTL *g ): Clone the state s (using a cached state from g if available). Return the cloned state, or NULL on error.; It is assumed that cached states are the same size as the one being cloned.
void reversi_state_draw( RState *s ): Print a plain-text representation of a state to standard out.
RMove *reversi_move_new( int x, int y ): Returns a new move, or NULL on failure.
GGTL_MOVE *reversi_move_new_wrapped( int x, int y, *g ): Returns a new move, wrapped in a ggtl_mc container, or NULL on failure. If g is non-NULL it will be asked for a cached move; otherwise, a new move will be allocated.
GGTL *reversi_init(GGTL *g, void *state): Initialises a GGTL structure's vtable with functions for playing Reversi and set the provided state to be the starting state of the game.
RStateCount reversi_state_count(RState *s): Returns a structure containing the counts of empty, white & black squares in the given state.

CALLBACK FUNCTIONS

These functions are used internally by GGTL; it is unlikely that you should have to worry about them. However, you are allowed to override these should you wish. See ggtl_vtab().

int reversi_eval( void *state, GGTL *g ): Evaluate a reversi state and return its fitness.
void *reversi_move( void *state, void *move, GGTL *g ): Returns the state resulting from applying move to state, or NULL on failure.
GGTL_MOVE *reversi_get_moves( void *state, GGTL *g ): Returns a list of the available moves at the given position, or NULL if no moves could be found.
void reversi_state_free( void *state ): Free up the memory held up by a state. This overrides the default free_state() callback supplied by GGTL.

THANKS

The code for performing a move was inspired by code found in Gnome Iagno by Ian Peters.

AUTHOR

Stig Brautaset <stig@brautaset.org>

COPYRIGHT

This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.