qcsrc/common/minigames/minigame/snake.qc

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