apps/openchess/src/game.c

   1 /*
   2  *  ZeX/OS
   3  *  Copyright (C) 2008  Tomas 'ZeXx86' Jedrzejek (zexx86@zexos.org)
   4  *
   5  *  This program is free software: you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation, either version 3 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <stdlib.h>
  23 #include <unistd.h>
  24 #include "client.h"
  25 #include "game.h"
  26
  27 game_t game_list;
  28
  29 /** Reset game board to default positions */
  30 int game_board_reset (game_t *game)
  31 {
  32         //Vez,Jezdec,Strelec,Dama,Kral,Strelec,Jezdec,Vez
  33         memcpy (game->board[0], "VJSDKSJV", 8);         // radek 1 (bily)
  34         memcpy (game->board[1], "PPPPPPPP", 8);         // radek 2 (bily)
  35         memcpy (game->board[2], "........", 8);
  36         memcpy (game->board[3], "........", 8);
  37         memcpy (game->board[4], "........", 8);
  38         memcpy (game->board[5], "........", 8);
  39         memcpy (game->board[6], "pppppppp", 8);         // radek 7 (cerny)
  40         memcpy (game->board[7], "vjsdksjv", 8);         // radek 8 (cerny)
  41
  42         return 1;
  43 }
  44
  45 game_t *game_find (char *name)
  46 {
  47         game_t *game;
  48         for (game = game_list.next; game != &game_list; game = game->next)
  49                 if (!strcmp (game->name, name))
  50                         return game;
  51
  52         return 0;
  53 }
  54
  55 game_t *game_findbyclient (client_t *client)
  56 {
  57         game_t *game;
  58         for (game = game_list.next; game != &game_list; game = game->next)
  59                 if (game->white == client ||
  60                         game->black == client)
  61                         return game;
  62
  63         return 0;
  64 }
  65
  66 /** Create new game's structure */
  67 game_t *game_new (client_t *client, char *name, unsigned name_len)
  68 {
  69         game_t *game = game_find (name);
  70
  71         if (game)
  72                 return 0;
  73
  74         /* alloc and init context */
  75         game = (game_t *) malloc (sizeof (game_t));
  76
  77         if (!game)
  78                 return 0;
  79
  80         /* setup game name */
  81         game->name = (char *) malloc (sizeof (char) * (name_len + 1));
  82
  83         if (!game->name)
  84                 return 0;
  85
  86         memcpy (game->name, name, name_len);
  87         game->name[name_len] = '\0';
  88
  89         /* set variables to default value */
  90         game->play = 0;
  91         game->round = 0;
  92         game->player = 'w';
  93
  94         /* white player is each time game creator */
  95         game->white = client;
  96         /* black player have to join to game*/
  97         game->black = 0;
  98
  99         /* reset chess board */
 100         game_board_reset (game);
 101
 102         /* add into list */
 103         game->next = &game_list;
 104         game->prev = game_list.prev;
 105         game->prev->next = game;
 106         game->next->prev = game;
 107
 108         return game;
 109 }
 110
 111 /** Client would to join to game */
 112 int game_join (client_t *client, game_t *game)
 113 {
 114         /* you can join to game, when it not running */
 115         if (game->play)
 116                 return 0;
 117
 118         /* player, what create game have to be connected */
 119         if (!game->white)
 120                 return 0;
 121
 122         /* player, what create game, cant join as opponent too */
 123         if (game->white == client)
 124                 return 0;
 125
 126         game->play = 1;
 127         game->black = client;
 128
 129         unsigned white_len = strlen (game->white->nick);
 130         unsigned black_len = strlen (game->black->nick);
 131
 132         char *str = (char *) malloc (white_len+white_len+3);
 133
 134         if (!str)
 135                 return 0;
 136
 137         memcpy (str, "s   ", 4);
 138
 139         str[2] = 'b';
 140
 141         memcpy (str+4, game->white->nick, white_len);
 142
 143         client_pmmsg (game->black, str, 4+white_len);
 144
 145
 146         str[2] = 'w';
 147
 148         memcpy (str+4, game->black->nick, black_len);
 149
 150         client_pmmsg (game->white, str, 4+black_len);
 151
 152         return 1;
 153 }
 154
 155 /** Delete game's structure */
 156 int game_quit (game_t *game)
 157 {
 158         game->next->prev = game->prev;
 159         game->prev->next = game->next;
 160
 161         free (game->name);
 162
 163         free (game);
 164
 165         return 1;
 166 }
 167
 168 /** Synchronize game with client's positions */
 169 int game_sync (client_t *client, game_t *game)
 170 {
 171         char str[73];
 172
 173         /*unsigned i = 0;
 174         unsigned y = 0;
 175
 176         while (i < 8) {
 177                 y = 0;
 178
 179                 while (y < 8) {
 180                         str[y+i*9] = game->board[i][y];
 181                         y ++;
 182                 }
 183
 184                 str[8+i*9] = '\n';
 185
 186                 i ++;
 187         }*/
 188
 189         int x;
 190         int y;
 191
 192         int i = 0;
 193
 194         for (x = 7; x >= 0; x --) {
 195                 for (y = 0; y < 8; y ++) {
 196                         str[i] = game->board[x][y];
 197                         i ++;
 198                 }
 199
 200                 str[i] = '\n';
 201                 i ++;
 202         }
 203
 204         client_pmmsg (client, str, 72);
 205
 206         return 1;
 207 }
 208
 209 int game_pos (client_t *client, game_t *game, unsigned char x_old, unsigned char y_old, unsigned char x, unsigned char y)
 210 {
 211         char f = game->board[y_old][x_old];
 212
 213         game->board[y_old][x_old] = '.';
 214
 215         game->board[y][x] = f;
 216
 217         return 1;
 218 }
 219
 220 int game_getlist (client_t *client)
 221 {
 222         int len = 0;
 223
 224         game_t *game;
 225
 226         /* first calculate length of all names */
 227         for (game = game_list.next; game != &game_list; game = game->next)
 228                 len += (strlen (game->name) + 3);
 229
 230         if (!len)
 231                 return 0;
 232
 233         char *list = (char *) malloc (sizeof (char) * (len + 1));
 234
 235         if (!list)
 236                 return 0;
 237
 238         len = 0;
 239
 240         unsigned l;
 241
 242         /* we can save all game names to list now */
 243         for (game = game_list.next; game != &game_list; game = game->next) {
 244                 l = strlen (game->name);
 245
 246                 if (game->play)
 247                         list[len] = '-';
 248                 else
 249                         list[len] = '+';
 250
 251                 memcpy (list+1+len, " ", 1);
 252                 memcpy (list+2+len, game->name, l);
 253                 memcpy (list+2+len+l, "\n", 1);
 254
 255                 len += (l + 3);
 256         }
 257
 258         list[len] = '\0';
 259
 260         client_pmmsg (client, list, len);
 261
 262         free (list);
 263
 264         return 1;
 265 }
 266
 267 /** Client Init function */
 268 int init_game ()
 269 {
 270         game_list.next = &game_list;
 271         game_list.prev = &game_list;
 272
 273         return 1;
 274 }
 275