qcsrc/common/minigames/minigame/snake.qc

   1 const float SNAKE_TURN_MOVE  = 0x0100; // the snake is moving, player must control it
   2 const float SNAKE_TURN_LOSS  = 0x0200; // they did it?!
   3 const float SNAKE_TURN_WAIT  = 0x0400; // the snake is waiting for the player to make their first move and begin the game
   4 const float SNAKE_TURN_TYPE  = 0x0f00; // turn type mask
   5
   6 const int SNAKE_SF_PLAYERSCORE = MINIG_SF_CUSTOM;
   7
   8 const int SNAKE_LET_CNT = 15;
   9 const int SNAKE_NUM_CNT = 15;
  10
  11 const int SNAKE_TILE_SIZE = 15;
  12
  13 const int SNAKE_DELAY_INITIAL = 0.7;
  14
  15 .int snake_score;
  16 .entity snake_head;
  17
  18 .float snake_delay;
  19 .float snake_nextmove;
  20 .vector snake_dir;
  21
  22 // find same game piece given its tile name
  23 entity snake_find_piece(entity minig, string tile)
  24 {
  25         entity e = world;
  26         while ( ( e = findentity(e,owner,minig) ) )
  27                 if ( e.classname == "minigame_board_piece" && e.netname == tile )
  28                         return e;
  29         return world;
  30 }
  31
  32 // find same game piece given its cnt
  33 entity snake_find_cnt(entity minig, int tile)
  34 {
  35         entity e = world;
  36         while ( ( e = findentity(e,owner,minig) ) )
  37                 if ( e.classname == "minigame_board_piece" && e.cnt == tile )
  38                         return e;
  39         return world;
  40 }
  41
  42 // check if the tile name is valid (15x15 grid)
  43 bool snake_valid_tile(string tile)
  44 {
  45         if ( !tile )
  46                 return false;
  47         int number = minigame_tile_number(tile);
  48         int letter = minigame_tile_letter(tile);
  49         return 0 <= number && number < SNAKE_NUM_CNT && 0 <= letter && letter < SNAKE_LET_CNT;
  50 }
  51
  52 void snake_new_mouse(entity minigame)
  53 {
  54         RandomSelection_Init();
  55         for(int i = 0; i < SNAKE_LET_CNT; ++i)
  56         for(int j = 0; j < SNAKE_NUM_CNT; ++j)
  57         {
  58                 string pos = minigame_tile_buildname(i, j);
  59                 if(!snake_find_piece(minigame, pos))
  60                         RandomSelection_Add(world, 0, pos, 1, 1);
  61         }
  62
  63         entity piece = msle_spawn(minigame,"minigame_board_piece");
  64         piece.team = 1;
  65         piece.netname = strzone(RandomSelection_chosen_string);
  66         minigame_server_sendflags(piece,MINIG_SF_ALL);
  67
  68         minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
  69 }
  70
  71 void snake_setup_pieces(entity minigame)
  72 {
  73         int targnum = bound(1, floor(random() * SNAKE_NUM_CNT), SNAKE_NUM_CNT - 1);
  74         int targlet = bound(1, floor(random() * SNAKE_LET_CNT), SNAKE_LET_CNT - 1);
  75
  76         entity piece = msle_spawn(minigame,"minigame_board_piece");
  77         piece.team = 1; // init default team?
  78         piece.netname = strzone(minigame_tile_buildname(targlet,targnum));
  79         piece.cnt = 1;
  80         minigame_server_sendflags(piece,MINIG_SF_ALL);
  81
  82         minigame.snake_head = piece;
  83
  84         snake_new_mouse(minigame);
  85
  86         minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
  87 }
  88
  89 void snake_add_score(entity minigame, int thescore)
  90 {
  91 #ifdef SVQC
  92         if(!minigame)
  93                 return;
  94         if(minigame.minigame_players)
  95         {
  96                 minigame.minigame_players.snake_score += thescore;
  97                 minigame.minigame_players.SendFlags |= SNAKE_SF_PLAYERSCORE;
  98         }
  99 #endif
 100 }
 101
 102 void snake_move_body(entity minigame, bool ate_mouse)
 103 {
 104         entity tail = world;
 105         string tailpos = string_null;
 106         vector taildir = '0 0 0';
 107
 108         int i, pieces = 0;
 109         for(i = (SNAKE_NUM_CNT * SNAKE_LET_CNT); i >= 2; --i)
 110         {
 111                 entity piece = snake_find_cnt(minigame, i);
 112                 entity nextpiece = snake_find_cnt(minigame, i - 1);
 113                 if(!piece)
 114                         continue;
 115
 116                 pieces++;
 117
 118                 if(!tail)
 119                 {
 120                         tail = piece;
 121                         tailpos = piece.netname;
 122                         taildir = piece.snake_dir;
 123                 }
 124
 125                 if(piece.netname) { strunzone(piece.netname); }
 126                 piece.netname = strzone(nextpiece.netname);
 127                 piece.snake_dir = nextpiece.snake_dir;
 128                 minigame_server_sendflags(piece, MINIG_SF_ALL);
 129         }
 130
 131         // just a head
 132         if(!pieces)
 133         {
 134                 tail = minigame.snake_head;
 135                 tailpos = minigame.snake_head.netname;
 136                 taildir = minigame.snake_head.snake_dir;
 137         }
 138
 139         if(tail && ate_mouse)
 140         {
 141                 int newcnt = tail.cnt + 1;
 142                 minigame.snake_delay = max(0.1, SNAKE_DELAY_INITIAL - (newcnt / 100));
 143                 snake_add_score(minigame, 1);
 144
 145                 entity piece = msle_spawn(minigame,"minigame_board_piece");
 146                 piece.cnt = newcnt;
 147                 piece.team = 1;
 148                 piece.snake_dir = taildir;
 149                 piece.netname = strzone(tailpos);
 150                 minigame_server_sendflags(piece,MINIG_SF_ALL);
 151
 152                 minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 153         }
 154 }
 155
 156 void snake_move_head(entity minigame)
 157 {
 158         entity head = minigame.snake_head;
 159
 160         int myx = minigame_tile_letter(head.netname);
 161         int myy = minigame_tile_number(head.netname);
 162
 163         myx += minigame.snake_dir_x;
 164         myy += minigame.snake_dir_y;
 165
 166         string newpos = minigame_tile_buildname(myx, myy);
 167
 168         if(!snake_valid_tile(newpos) || (snake_find_piece(minigame, newpos)).cnt)
 169         {
 170                 minigame.minigame_flags = SNAKE_TURN_LOSS;
 171                 minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 172                 return;
 173         }
 174
 175         bool ate_mouse = false;
 176         entity piece = snake_find_piece(minigame, newpos);
 177         if(piece && !piece.cnt)
 178                 ate_mouse = true;
 179
 180         // move the body first, then set the new head position?
 181         snake_move_body(minigame, ate_mouse);
 182
 183         if(ate_mouse)
 184         {
 185                 if(piece.netname) { strunzone(piece.netname); }
 186                 remove(piece);
 187
 188                 snake_new_mouse(minigame);
 189         }
 190
 191         if(head.netname) { strunzone(head.netname); }
 192         head.netname = strzone(newpos);
 193         minigame_server_sendflags(head,MINIG_SF_ALL);
 194 }
 195
 196 // make a move
 197 void snake_move(entity minigame, entity player, string dxs, string dys )
 198 {
 199         if ( (minigame.minigame_flags & SNAKE_TURN_MOVE) || (minigame.minigame_flags & SNAKE_TURN_WAIT) )
 200         if ( dxs || dys )
 201         {
 202                 //if ( snake_valid_tile(pos) )
 203                 //if ( snake_find_piece(minigame, pos) )
 204                 {
 205                         int dx = ((dxs) ? stof(dxs) : 0);
 206                         int dy = ((dys) ? stof(dys) : 0);
 207
 208                         int myl = minigame_tile_letter(minigame.snake_head.netname);
 209                         int myn = minigame_tile_number(minigame.snake_head.netname);
 210
 211                         entity head = snake_find_piece(minigame, minigame_tile_buildname(myl + dx, myn + dy));
 212                         if(head && head.cnt == 2)
 213                                 return; // nope!
 214
 215                         if(minigame.minigame_flags & SNAKE_TURN_WAIT)
 216                                 minigame.snake_nextmove = time;
 217                         minigame.minigame_flags = SNAKE_TURN_MOVE;
 218                         minigame.snake_dir_x = dx;
 219                         minigame.snake_dir_y = dy;
 220                         minigame.snake_dir_z = 0;
 221                         minigame.snake_head.snake_dir = minigame.snake_dir;
 222                         minigame_server_sendflags(minigame.snake_head,MINIG_SF_UPDATE);
 223                         minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 224                 }
 225         }
 226 }
 227
 228 #ifdef SVQC
 229
 230
 231 // required function, handle server side events
 232 int snake_server_event(entity minigame, string event, ...)
 233 {
 234         switch(event)
 235         {
 236                 case "start":
 237                 {
 238                         snake_setup_pieces(minigame);
 239                         minigame.snake_delay = SNAKE_DELAY_INITIAL;
 240                         minigame.minigame_flags = SNAKE_TURN_WAIT;
 241                         return true;
 242                 }
 243                 case "end":
 244                 {
 245                         entity e = world;
 246                         while( (e = findentity(e, owner, minigame)) )
 247                         if(e.classname == "minigame_board_piece")
 248                         {
 249                                 if(e.netname) { strunzone(e.netname); }
 250                                 remove(e);
 251                         }
 252                         minigame.snake_head = world;
 253                         return false;
 254                 }
 255                 case "join":
 256                 {
 257                         int pl_num = minigame_count_players(minigame);
 258
 259                         // Don't allow more than 1 player
 260                         // not sure if this should be a multiplayer game (might get crazy)
 261                         if(pl_num >= 1) { return false; }
 262
 263                         // Team 1 by default
 264                         return 1;
 265                 }
 266                 case "frame":
 267                 {
 268                         if(minigame.minigame_flags & SNAKE_TURN_MOVE)
 269                         if(time >= minigame.snake_nextmove)
 270                         {
 271                                 snake_move_head(minigame);
 272                                 minigame.snake_nextmove = time + minigame.snake_delay;
 273                         }
 274                         return false;
 275                 }
 276                 case "cmd":
 277                 {
 278                         switch(argv(0))
 279                         {
 280                                 case "move":
 281                                         snake_move(minigame, ...(0,entity), ((...(1,int)) >= 2 ? argv(1) : string_null), ((...(1,int)) == 3 ? argv(2) : string_null));
 282                                         return true;
 283                         }
 284
 285                         return false;
 286                 }
 287                 case "network_send":
 288                 {
 289                         entity sent = ...(0,entity);
 290                         int sf = ...(1,int);
 291                         if ( sent.classname == "minigame_board_piece" && (sf & MINIG_SF_UPDATE) )
 292                         {
 293                                 WriteByte(MSG_ENTITY,sent.cnt);
 294                                 WriteCoord(MSG_ENTITY,sent.snake_dir_x);
 295                                 WriteCoord(MSG_ENTITY,sent.snake_dir_y);
 296                         }
 297                         else if ( sent.classname == "minigame_player" && (sf & SNAKE_SF_PLAYERSCORE ) )
 298                         {
 299                                 WriteLong(MSG_ENTITY,sent.snake_score);
 300                         }
 301                         return false;
 302                 }
 303         }
 304
 305         return false;
 306 }
 307
 308
 309 #elif defined(CSQC)
 310
 311 vector snake_boardpos; // HUD board position
 312 vector snake_boardsize;// HUD board size
 313
 314 // Required function, draw the game board
 315 void snake_hud_board(vector pos, vector mySize)
 316 {
 317         minigame_hud_fitsqare(pos, mySize);
 318         snake_boardpos = pos;
 319         snake_boardsize = mySize;
 320
 321         minigame_hud_simpleboard(pos,mySize,minigame_texture("snake/board"));
 322
 323         vector tile_size = minigame_hud_denormalize_size('1 1 0' / SNAKE_TILE_SIZE,pos,mySize);
 324         vector tile_pos;
 325
 326         entity tail = world;
 327         int i;
 328         for(i = (SNAKE_NUM_CNT * SNAKE_LET_CNT); i >= 2; --i)
 329         {
 330                 entity piece = snake_find_cnt(active_minigame, i);
 331                 if(piece)
 332                 {
 333                         tail = piece;
 334                         break;
 335                 }
 336         }
 337
 338         entity e;
 339         FOREACH_MINIGAME_ENTITY(e)
 340         {
 341                 if ( e.classname == "minigame_board_piece" )
 342                 {
 343                         tile_pos = minigame_tile_pos(e.netname,SNAKE_NUM_CNT,SNAKE_LET_CNT);
 344                         tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
 345                         string thepiece = "snake/mouse";
 346                         if(e.cnt)
 347                                 thepiece = "snake/body";
 348                         if(tail && e.cnt == tail.cnt)
 349                                 thepiece = "snake/tail";
 350                         if(e.cnt == 1)
 351                         {
 352                                 int dx = minigame_tile_letter(e.netname) + e.snake_dir_x;
 353                                 int dy = minigame_tile_number(e.netname) + e.snake_dir_y;
 354                                 entity mouse = snake_find_piece(active_minigame, minigame_tile_buildname(dx, dy));
 355                                 thepiece = "snake/head";
 356                                 if(mouse && !mouse.cnt)
 357                                         thepiece = "snake/feed";
 358                         }
 359
 360                         minigame_drawpic_centered( tile_pos,
 361                                         minigame_texture(thepiece),
 362                                         tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
 363                 }
 364         }
 365
 366         if ( active_minigame.minigame_flags & SNAKE_TURN_LOSS )
 367         {
 368                 int scores = 0;
 369                 FOREACH_MINIGAME_ENTITY(e)
 370                         if(e.classname == "minigame_player")
 371                                 scores = e.snake_score;
 372
 373                 vector winfs = hud_fontsize*2;
 374                 string scores_text;
 375                 scores_text = strcat("Score: ", ftos(scores));
 376
 377                 vector win_pos = pos+eY*(mySize_y-winfs_y)/2;
 378                 vector win_sz;
 379                 win_sz = minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
 380                         sprintf("Game over! %s", scores_text),
 381                         winfs, 0, DRAWFLAG_NORMAL, 0.5);
 382
 383                 drawfill(win_pos-eY*hud_fontsize_y,win_sz+2*eY*hud_fontsize_y,'0.3 0.3 1',0.8,DRAWFLAG_ADDITIVE);
 384
 385                 minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
 386                         sprintf("Game over! %s", scores_text),
 387                         winfs, panel_fg_alpha, DRAWFLAG_NORMAL, 0.5);
 388         }
 389 }
 390
 391
 392 // Required function, draw the game status panel
 393 void snake_hud_status(vector pos, vector mySize)
 394 {
 395         HUD_Panel_DrawBg(1);
 396         vector ts;
 397         ts = minigame_drawstring_wrapped(mySize_x,pos,active_minigame.descriptor.message,
 398                 hud_fontsize * 2, '0.25 0.47 0.72', panel_fg_alpha, DRAWFLAG_NORMAL,0.5);
 399
 400         pos_y += ts_y;
 401         mySize_y -= ts_y;
 402
 403         vector player_fontsize = hud_fontsize * 1.75;
 404         ts_y = ( mySize_y - 2*player_fontsize_y ) / 2;
 405         ts_x = mySize_x;
 406         vector mypos;
 407         vector tile_size = '48 48 0';
 408
 409         mypos = pos;
 410         drawfill(mypos,eX*mySize_x+eY*player_fontsize_y,'1 1 1',0.5,DRAWFLAG_ADDITIVE);
 411         mypos_y += player_fontsize_y;
 412         drawfill(mypos,eX*mySize_x+eY*tile_size_y,'1 1 1',0.25,DRAWFLAG_ADDITIVE);
 413
 414         entity e;
 415         FOREACH_MINIGAME_ENTITY(e)
 416         {
 417                 if ( e.classname == "minigame_player" )
 418                 {
 419                         mypos = pos;
 420                         minigame_drawcolorcodedstring_trunc(mySize_x,mypos,
 421                                 GetPlayerName(e.minigame_playerslot-1),
 422                                 player_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
 423
 424                         mypos_y += player_fontsize_y;
 425                         //drawpic( mypos,
 426                         //              minigame_texture("snake/piece"),
 427                         //              tile_size, '1 0 0', panel_fg_alpha, DRAWFLAG_NORMAL );
 428
 429                         //mypos_x += tile_size_x;
 430
 431                         drawstring(mypos,ftos(e.snake_score),tile_size,
 432                                            '0.7 0.84 1', panel_fg_alpha, DRAWFLAG_NORMAL);
 433                 }
 434         }
 435 }
 436
 437 // Turn a set of flags into a help message
 438 string snake_turn_to_string(int turnflags)
 439 {
 440         if ( turnflags & SNAKE_TURN_LOSS )
 441                 return _("Game over!");
 442
 443         if ( turnflags & SNAKE_TURN_WAIT )
 444                 return _("Press an arrow key to begin the game");
 445
 446         if ( turnflags & SNAKE_TURN_MOVE )
 447                 return _("Avoid the walls and the snake's body, collect the mice!");
 448
 449         return "";
 450 }
 451
 452 // Make the correct move
 453 void snake_set_direction(entity minigame, int dx, int dy)
 454 {
 455         //if ( minigame.minigame_flags == SNAKE_TURN_MOVE )
 456         //{
 457                 minigame_cmd("move ",ftos(dx), " ", ftos(dy));
 458         //}
 459 }
 460
 461 // Required function, handle client events
 462 int snake_client_event(entity minigame, string event, ...)
 463 {
 464         switch(event)
 465         {
 466                 case "activate":
 467                 {
 468                         minigame.message = snake_turn_to_string(minigame.minigame_flags);
 469                         return false;
 470                 }
 471                 case "key_pressed":
 472                 {
 473                         //if((minigame.minigame_flags & SNAKE_TURN_TEAM) == minigame_self.team)
 474                         {
 475                                 switch ( ...(0,int) )
 476                                 {
 477                                         case K_RIGHTARROW:
 478                                         case K_KP_RIGHTARROW:
 479                                                 snake_set_direction(minigame, 1, 0);
 480                                                 return true;
 481                                         case K_LEFTARROW:
 482                                         case K_KP_LEFTARROW:
 483                                                 snake_set_direction(minigame, -1, 0);
 484                                                 return true;
 485                                         case K_UPARROW:
 486                                         case K_KP_UPARROW:
 487                                                 snake_set_direction(minigame, 0, 1);
 488                                                 return true;
 489                                         case K_DOWNARROW:
 490                                         case K_KP_DOWNARROW:
 491                                                 snake_set_direction(minigame, 0, -1);
 492                                                 return true;
 493                                 }
 494                         }
 495
 496                         return false;
 497                 }
 498                 case "network_receive":
 499                 {
 500                         entity sent = ...(0,entity);
 501                         int sf = ...(1,int);
 502                         if ( sent.classname == "minigame" )
 503                         {
 504                                 if ( sf & MINIG_SF_UPDATE )
 505                                 {
 506                                         sent.message = snake_turn_to_string(sent.minigame_flags);
 507                                         //if ( sent.minigame_flags & minigame_self.team )
 508                                                 minigame_prompt();
 509                                 }
 510                         }
 511                         else if(sent.classname == "minigame_board_piece")
 512                         {
 513                                 if(sf & MINIG_SF_UPDATE)
 514                                 {
 515                                         sent.cnt = ReadByte();
 516                                         sent.snake_dir_x = ReadCoord();
 517                                         sent.snake_dir_y = ReadCoord();
 518                                         sent.snake_dir_z = 0;
 519                                         if(sent.cnt == 1)
 520                                                 minigame.snake_head = sent; // hax
 521                                 }
 522                         }
 523                         else if ( sent.classname == "minigame_player" && (sf & SNAKE_SF_PLAYERSCORE ) )
 524                         {
 525                                 sent.snake_score = ReadLong();
 526                         }
 527
 528                         return false;
 529                 }
 530         }
 531
 532         return false;
 533 }
 534
 535 #endif