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