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