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_WIN   = 0x0200; // multiplayer victory
   5 const float SNAKE_TURN_LOSS  = 0x0400; // they did it?!
   6 const float SNAKE_TURN_TYPE  = 0x0f00; // turn type mask
   7
   8 const int SNAKE_TURN_TEAM  = 0x000f; // turn team mask
   9
  10 const int SNAKE_SF_PLAYERSCORE = MINIG_SF_CUSTOM;
  11
  12 const int SNAKE_LET_CNT = 15;
  13 const int SNAKE_NUM_CNT = 15;
  14
  15 const int SNAKE_TILE_SIZE = 15;
  16
  17 const int SNAKE_TEAMS = 6;
  18
  19 bool autocvar_sv_minigames_snake_wrap = false;
  20 float autocvar_sv_minigames_snake_delay_initial = 0.7;
  21 float autocvar_sv_minigames_snake_delay_multiplier = 50;
  22 float autocvar_sv_minigames_snake_delay_min = 0.1;
  23 int autocvar_sv_minigames_snake_lives = 3;
  24
  25 .int snake_score;
  26
  27 .float snake_delay;
  28 .vector snake_dir;
  29
  30 .bool snake_tail;
  31
  32 .int snake_lives;
  33
  34 .int snake_lost_teams;
  35
  36 bool snake_alone(entity minig)
  37 {
  38         int headcount = 0;
  39         entity e = world;
  40         while ( ( e = findentity(e,owner,minig) ) )
  41                 if ( e.classname == "minigame_board_piece" && e.cnt == 1 )
  42                         ++headcount;
  43
  44         return headcount <= 1;
  45 }
  46
  47 // find same game piece given its tile name
  48 entity snake_find_piece(entity minig, string tile)
  49 {
  50         entity e = world;
  51         while ( ( e = findentity(e,owner,minig) ) )
  52                 if ( e.classname == "minigame_board_piece" && e.netname == tile )
  53                         return e;
  54         return world;
  55 }
  56
  57 // find same game piece given its cnt
  58 entity snake_find_cnt(entity minig, int steam, int tile)
  59 {
  60         entity e = world;
  61         while ( ( e = findentity(e,owner,minig) ) )
  62                 if ( e.classname == "minigame_board_piece" && e.cnt == tile && e.team == steam )
  63                         return e;
  64         return world;
  65 }
  66
  67 // check if the tile name is valid (15x15 grid)
  68 bool snake_valid_tile(string tile)
  69 {
  70         if ( !tile )
  71                 return false;
  72         int number = minigame_tile_number(tile);
  73         int letter = minigame_tile_letter(tile);
  74         return 0 <= number && number < SNAKE_NUM_CNT && 0 <= letter && letter < SNAKE_LET_CNT;
  75 }
  76
  77 entity snake_find_head(entity minig, int steam)
  78 {
  79         entity e = world;
  80         while ( ( e = findentity(e,owner,minig) ) )
  81                 if ( e.classname == "minigame_board_piece" && e.cnt == 1 && e.team == steam )
  82                         return e;
  83         return world;
  84 }
  85
  86 void snake_new_mouse(entity minigame)
  87 {
  88         RandomSelection_Init();
  89         int i, j;
  90         for(i = 0; i < SNAKE_LET_CNT; ++i)
  91         for(j = 0; j < SNAKE_NUM_CNT; ++j)
  92         {
  93                 string pos = minigame_tile_buildname(i, j);
  94                 if(!snake_find_piece(minigame, pos))
  95                         RandomSelection_Add(world, 0, pos, 1, 1);
  96         }
  97
  98         entity piece = msle_spawn(minigame,"minigame_board_piece");
  99         piece.team = 0;
 100         piece.netname = strzone(RandomSelection_chosen_string);
 101         minigame_server_sendflags(piece,MINIG_SF_ALL);
 102
 103         minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 104 }
 105
 106 entity snake_get_player(entity minigame, int pteam);
 107 int snake_winning_team(entity minigame)
 108 {
 109         int winning_team = 0;
 110         for(int i = 1; i <= SNAKE_TEAMS; ++i)
 111         {
 112                 entity pl = snake_get_player(minigame, i);
 113                 if(pl)
 114                 if(pl.snake_lives > 0)
 115                 {
 116                         if(winning_team)
 117                                 return 0;
 118                         winning_team = pl.team;
 119                 }
 120         }
 121
 122         return winning_team;
 123 }
 124
 125 void snake_check_winner(entity minigame)
 126 {
 127         if(snake_alone(minigame) && !minigame.snake_lost_teams)
 128                 return;
 129
 130         int winner = snake_winning_team(minigame);
 131
 132         int alivecnt = 0;
 133         for(int i = 1; i <= SNAKE_TEAMS; ++i)
 134         {
 135                 entity pl = snake_get_player(minigame, i);
 136                 if(pl)
 137                 if(pl.snake_lives > 0)
 138                         ++alivecnt;
 139         }
 140
 141         if(!alivecnt)
 142         {
 143                 minigame.minigame_flags = SNAKE_TURN_LOSS;
 144                 minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 145                 return;
 146         }
 147
 148         if(winner)
 149         {
 150                 minigame.minigame_flags = SNAKE_TURN_WIN | winner;
 151                 minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 152         }
 153 }
 154
 155 void snake_move_head(entity minigame, entity head);
 156 void snake_head_think()
 157 {
 158         entity minigame = self.owner;
 159
 160         if(minigame.minigame_flags & SNAKE_TURN_MOVE)
 161                 snake_move_head(minigame, self);
 162
 163         snake_check_winner(minigame);
 164
 165         self.nextthink = time + self.snake_delay;
 166 }
 167
 168 void minigame_setup_snake(entity minigame, int pteam)
 169 {
 170         RandomSelection_Init();
 171         int i, j;
 172         for(i = 1; i < SNAKE_LET_CNT - 1; ++i)
 173         for(j = 1; j < SNAKE_NUM_CNT - 1; ++j)
 174         {
 175                 string pos = minigame_tile_buildname(i, j);
 176                 if(!snake_find_piece(minigame, pos))
 177                         RandomSelection_Add(world, 0, pos, 1, 1);
 178         }
 179
 180         entity piece = msle_spawn(minigame,"minigame_board_piece");
 181         piece.team = pteam;
 182         piece.netname = strzone(RandomSelection_chosen_string);
 183         piece.cnt = 1;
 184         piece.think = snake_head_think;
 185         piece.snake_delay = autocvar_sv_minigames_snake_delay_initial;
 186         piece.nextthink = time + 0.1;
 187         minigame_server_sendflags(piece,MINIG_SF_ALL);
 188 }
 189
 190 void snake_setup_pieces(entity minigame)
 191 {
 192         snake_new_mouse(minigame);
 193
 194         minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 195 }
 196
 197 entity snake_get_player(entity minigame, int pteam)
 198 {
 199         entity e;
 200 #ifdef SVQC
 201         for(e = minigame.minigame_players; e; e = e.list_next)
 202 #elif defined(CSQC)
 203         e = world;
 204         while( (e = findentity(e,owner,minigame)) )
 205                 if ( e.classname == "minigame_player" )
 206 #endif
 207         if(e.team == pteam)
 208                 return e;
 209         return world;
 210 }
 211
 212 void snake_add_score(entity minigame, int pteam, .int score_field, int thescore)
 213 {
 214 #ifdef SVQC
 215         if(!minigame)
 216                 return;
 217         entity pl = snake_get_player(minigame, pteam);
 218         if(pl)
 219         {
 220                 pl.score_field += thescore;
 221                 pl.SendFlags |= SNAKE_SF_PLAYERSCORE;
 222         }
 223 #endif
 224 }
 225
 226 void snake_move_body(entity minigame, entity head, bool ate_mouse)
 227 {
 228         entity tail = world;
 229         string tailpos = string_null;
 230         vector taildir = '0 0 0';
 231
 232         int i, pieces = 0;
 233         for(i = (SNAKE_NUM_CNT * SNAKE_LET_CNT); i >= 2; --i)
 234         {
 235                 entity piece = snake_find_cnt(minigame, head.team, i);
 236                 entity nextpiece = snake_find_cnt(minigame, head.team, i - 1);
 237                 if(!piece)
 238                         continue;
 239
 240                 pieces++;
 241
 242                 if(!tail)
 243                 {
 244                         tail = piece;
 245                         tailpos = piece.netname;
 246                         taildir = piece.snake_dir;
 247                 }
 248
 249                 if(piece.netname) { strunzone(piece.netname); }
 250                 piece.netname = strzone(nextpiece.netname);
 251                 piece.snake_dir = nextpiece.snake_dir;
 252                 minigame_server_sendflags(piece, MINIG_SF_ALL);
 253         }
 254
 255         // just a head
 256         if(!pieces)
 257         {
 258                 tail = head;
 259                 tailpos = head.netname;
 260                 taildir = head.snake_dir;
 261         }
 262
 263         if(tail && ate_mouse)
 264         {
 265                 tail.snake_tail = false;
 266
 267                 int newcnt = tail.cnt + 1;
 268                 head.snake_delay = max(autocvar_sv_minigames_snake_delay_min, autocvar_sv_minigames_snake_delay_initial - (newcnt / autocvar_sv_minigames_snake_delay_multiplier));
 269                 snake_add_score(minigame, head.team, snake_score, 1);
 270
 271                 entity piece = msle_spawn(minigame,"minigame_board_piece");
 272                 piece.cnt = newcnt;
 273                 piece.team = head.team;
 274                 piece.snake_dir = taildir;
 275                 piece.snake_tail = true;
 276                 piece.netname = strzone(tailpos);
 277                 minigame_server_sendflags(piece,MINIG_SF_ALL);
 278
 279                 minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 280         }
 281 }
 282
 283 void snake_eat_team(entity minigame, int pteam)
 284 {
 285         entity head = snake_find_head(minigame, pteam);
 286         if(!head) { return; }
 287
 288         snake_add_score(minigame, pteam, snake_lives, -1);
 289         head.nextthink = time + 1; // make sure they don't to eat us somehow
 290
 291         entity e = world;
 292         while ( ( e = findentity(e,owner,minigame) ) )
 293                 if ( e.classname == "minigame_board_piece" && e.cnt && e.team == pteam )
 294                 {
 295                         if(e.netname) { strunzone(e.netname); }
 296                         remove(e);
 297                 }
 298
 299         entity pl = snake_get_player(minigame, pteam);
 300         if(pl.snake_lives > 0)
 301                 minigame_setup_snake(minigame, pteam);
 302         else
 303                 minigame.snake_lost_teams |= BIT(pteam);
 304 }
 305
 306 void snake_move_head(entity minigame, entity head)
 307 {
 308         if(!head.snake_dir_x && !head.snake_dir_y)
 309                 return; // nope!
 310
 311         string newpos;
 312
 313         if(autocvar_sv_minigames_snake_wrap)
 314                 newpos = minigame_relative_tile(head.netname, head.snake_dir_x, head.snake_dir_y, SNAKE_NUM_CNT, SNAKE_LET_CNT);
 315         else
 316         {
 317                 int myx = minigame_tile_letter(head.netname);
 318                 int myy = minigame_tile_number(head.netname);
 319
 320                 myx += head.snake_dir_x;
 321                 myy += head.snake_dir_y;
 322
 323                 newpos = minigame_tile_buildname(myx, myy);
 324         }
 325
 326         entity hit = snake_find_piece(minigame, newpos);
 327
 328         if(!snake_valid_tile(newpos) || (hit && hit.cnt && hit.team == head.team))
 329         {
 330                 if(snake_alone(minigame))
 331                 {
 332                         minigame.minigame_flags = SNAKE_TURN_LOSS;
 333                         minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 334                 }
 335                 else
 336                 {
 337                         snake_add_score(minigame, head.team, snake_score, -1);
 338                         snake_eat_team(minigame, head.team);
 339                 }
 340
 341                 return;
 342         }
 343
 344         bool ate_mouse = (hit && !hit.cnt);
 345
 346         // move the body first, then set the new head position?
 347         snake_move_body(minigame, head, ate_mouse);
 348
 349         if(head.netname) { strunzone(head.netname); }
 350         head.netname = strzone(newpos);
 351         minigame_server_sendflags(head,MINIG_SF_ALL);
 352
 353         // above check makes sure it's not our team
 354         if(hit.cnt)
 355         {
 356                 snake_eat_team(minigame, hit.team);
 357                 snake_add_score(minigame, head.team, snake_score, 1);
 358         }
 359
 360         if(ate_mouse)
 361         {
 362                 if(hit.netname) { strunzone(hit.netname); }
 363                 remove(hit);
 364
 365                 snake_new_mouse(minigame);
 366         }
 367 }
 368
 369 // make a move
 370 void snake_move(entity minigame, entity player, string dxs, string dys )
 371 {
 372         if ( minigame.minigame_flags & SNAKE_TURN_MOVE )
 373         if ( dxs || dys )
 374         {
 375                 //if ( snake_valid_tile(pos) )
 376                 //if ( snake_find_piece(minigame, pos) )
 377                 {
 378                         entity head = snake_find_head(minigame, player.team);
 379                         if(!head)
 380                                 return; // their head is already dead
 381
 382                         int dx = ((dxs) ? bound(-1, stof(dxs), 1) : 0);
 383                         int dy = ((dys) ? bound(-1, stof(dys), 1) : 0);
 384
 385                         int myl = minigame_tile_letter(head.netname);
 386                         int myn = minigame_tile_number(head.netname);
 387
 388                         entity check_piece = snake_find_piece(minigame, minigame_tile_buildname(myl + dx, myn + dy));
 389                         if(check_piece && check_piece.cnt == 2)
 390                                 return; // nope!
 391
 392                         if(head.snake_dir == '0 0 0')
 393                                 head.nextthink = time; // TODO: make sure this can't be exploited!
 394                         head.snake_dir_x = dx;
 395                         head.snake_dir_y = dy;
 396                         head.snake_dir_z = 0;
 397                         minigame_server_sendflags(head,MINIG_SF_UPDATE);
 398                         minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 399                 }
 400         }
 401 }
 402
 403 #ifdef SVQC
 404
 405
 406 // required function, handle server side events
 407 int snake_server_event(entity minigame, string event, ...)
 408 {
 409         switch(event)
 410         {
 411                 case "start":
 412                 {
 413                         snake_setup_pieces(minigame);
 414                         minigame.minigame_flags = SNAKE_TURN_MOVE;
 415                         minigame.snake_lost_teams = 0;
 416                         return true;
 417                 }
 418                 case "end":
 419                 {
 420                         entity e = world;
 421                         while( (e = findentity(e, owner, minigame)) )
 422                         if(e.classname == "minigame_board_piece")
 423                         {
 424                                 if(e.netname) { strunzone(e.netname); }
 425                                 remove(e);
 426                         }
 427                         return false;
 428                 }
 429                 case "join":
 430                 {
 431                         int pl_num = minigame_count_players(minigame);
 432
 433                         if(pl_num >= SNAKE_TEAMS) { return false; }
 434
 435                         int t = 1; // Team 1 by default
 436
 437                         for(int i = 1; i <= SNAKE_TEAMS; ++i)
 438                         {
 439                                 entity e = snake_get_player(minigame, i);
 440                                 if(!e)
 441                                 {
 442                                         t = i;
 443                                         break;
 444                                 }
 445                         }
 446
 447                         if(!snake_find_head(minigame, t) && !(minigame.snake_lost_teams & BIT(t)))
 448                         {
 449                                 entity pl = ...(1,entity);
 450                                 if(pl)
 451                                 {
 452                                         pl.snake_lives = ((SNAKE_TEAMS > 1) ? autocvar_sv_minigames_snake_lives : 1);
 453                                         pl.SendFlags |= SNAKE_SF_PLAYERSCORE;
 454                                 }
 455                                 minigame_setup_snake(minigame, t);
 456                         }
 457
 458                         return t;
 459                 }
 460                 case "cmd":
 461                 {
 462                         switch(argv(0))
 463                         {
 464                                 case "move":
 465                                         snake_move(minigame, ...(0,entity), ((...(1,int)) >= 2 ? argv(1) : string_null), ((...(1,int)) == 3 ? argv(2) : string_null));
 466                                         return true;
 467                         }
 468
 469                         return false;
 470                 }
 471                 case "network_send":
 472                 {
 473                         entity sent = ...(0,entity);
 474                         int sf = ...(1,int);
 475                         if ( sent.classname == "minigame_board_piece" && (sf & MINIG_SF_UPDATE) )
 476                         {
 477                                 WriteByte(MSG_ENTITY,sent.cnt);
 478                                 WriteByte(MSG_ENTITY,sent.snake_tail);
 479                                 WriteCoord(MSG_ENTITY,sent.snake_dir_x);
 480                                 WriteCoord(MSG_ENTITY,sent.snake_dir_y);
 481                         }
 482                         else if ( sent.classname == "minigame_player" && (sf & SNAKE_SF_PLAYERSCORE ) )
 483                         {
 484                                 WriteLong(MSG_ENTITY,sent.snake_score);
 485                                 WriteByte(MSG_ENTITY,max(0, sent.snake_lives));
 486                         }
 487                         else if ( sent.classname == "minigame" && (sf & MINIG_SF_UPDATE ) )
 488                         {
 489                                 WriteByte(MSG_ENTITY,autocvar_sv_minigames_snake_wrap);
 490                         }
 491                         return false;
 492                 }
 493         }
 494
 495         return false;
 496 }
 497
 498
 499 #elif defined(CSQC)
 500
 501 vector snake_boardpos; // HUD board position
 502 vector snake_boardsize;// HUD board size
 503
 504 bool snake_wrap;
 505
 506 vector snake_teamcolor(int steam)
 507 {
 508         switch(steam)
 509         {
 510                 case 1: return '1 0 0';
 511                 case 2: return '0 0 1';
 512                 case 3: return '1 1 0';
 513                 case 4: return '1 0 1';
 514                 case 5: return '0 1 0';
 515                 case 6: return '0 1 1';
 516         }
 517
 518         return '1 1 1';
 519 }
 520
 521 // Required function, draw the game board
 522 void snake_hud_board(vector pos, vector mySize)
 523 {
 524         minigame_hud_fitsqare(pos, mySize);
 525         snake_boardpos = pos;
 526         snake_boardsize = mySize;
 527
 528         minigame_hud_simpleboard(pos,mySize,minigame_texture("snake/board"));
 529
 530         vector tile_size = minigame_hud_denormalize_size('1 1 0' / SNAKE_TILE_SIZE,pos,mySize);
 531         vector tile_pos;
 532
 533         entity e;
 534         FOREACH_MINIGAME_ENTITY(e)
 535         {
 536                 if ( e.classname == "minigame_board_piece" )
 537                 {
 538                         tile_pos = minigame_tile_pos(e.netname,SNAKE_NUM_CNT,SNAKE_LET_CNT);
 539                         tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
 540
 541                         vector tile_color = snake_teamcolor(e.team);
 542
 543                         string thepiece = "snake/mouse";
 544                         if(e.cnt)
 545                                 thepiece = "snake/body";
 546                         if(e.snake_tail)
 547                                 thepiece = "snake/tail";
 548                         if(e.cnt == 1)
 549                         {
 550                                 int dx = minigame_tile_letter(e.netname) + e.snake_dir_x * 2;
 551                                 int dy = minigame_tile_number(e.netname) + e.snake_dir_y * 2;
 552                                 entity mouse = snake_find_piece(active_minigame, minigame_tile_buildname(dx, dy));
 553                                 thepiece = "snake/head";
 554                                 if(mouse && mouse.team != e.team)
 555                                 {
 556                                         float myang = 0;
 557                                         int myx = minigame_tile_letter(e.netname);
 558                                         int myy = minigame_tile_number(e.netname);
 559                                         if(myx - 2 == dx)
 560                                                 myang = M_PI*3/2;
 561                                         if(myx + 2 == dx)
 562                                                 myang = M_PI/2;
 563                                         if(myy - 2 == dy)
 564                                                 myang = M_PI;
 565
 566                                         int newx = minigame_tile_letter(e.netname) + e.snake_dir_x;
 567                                         int newy = minigame_tile_number(e.netname) + e.snake_dir_y;
 568                                         string newpos = minigame_tile_buildname(newx, newy);
 569
 570                                         vector my_pos = minigame_tile_pos(newpos,SNAKE_NUM_CNT,SNAKE_LET_CNT);
 571                                         my_pos = minigame_hud_denormalize(my_pos,pos,mySize);
 572
 573                                         drawrotpic(my_pos, myang, minigame_texture("snake/tongue"),
 574                                                         tile_size, tile_size/2, tile_color,
 575                                                         panel_fg_alpha, DRAWFLAG_NORMAL );
 576                                 }
 577                         }
 578
 579                         if(e.cnt == 1 || e.snake_tail)
 580                         {
 581                                 vector thedir = e.snake_dir;
 582                                 float theang = 0;
 583                                 if(e.snake_tail)
 584                                 {
 585                                         int thex = minigame_tile_letter(e.netname);
 586                                         int they = minigame_tile_number(e.netname);
 587                                         entity t = snake_find_cnt(active_minigame, minigame_self.team, e.cnt - 1);
 588                                         int tx = minigame_tile_letter(t.netname);
 589                                         int ty = minigame_tile_number(t.netname);
 590
 591                                         if(thex - 1 == tx)
 592                                         {
 593                                                 thedir_y = 0;
 594                                                 thedir_x = -1;
 595                                         }
 596                                         if(they + 1 == ty)
 597                                         {
 598                                                 thedir_x = 0;
 599                                                 thedir_y = 1;
 600                                         }
 601                                         if(they - 1 == ty)
 602                                         {
 603                                                 thedir_x = 0;
 604                                                 thedir_y = -1;
 605                                         }
 606                                 }
 607
 608                                 if(thedir_y == -1)
 609                                         theang = M_PI;
 610                                 if(thedir_x == 1)
 611                                         theang = M_PI/2;
 612                                 if(thedir_x == -1)
 613                                         theang = M_PI*3/2;
 614
 615                                 drawrotpic(tile_pos, theang, minigame_texture(thepiece),
 616                                                         tile_size, tile_size/2, tile_color,
 617                                                         panel_fg_alpha, DRAWFLAG_NORMAL );
 618                         }
 619                         else
 620                         {
 621                                 minigame_drawpic_centered( tile_pos,
 622                                                 minigame_texture(thepiece),
 623                                                 tile_size, tile_color, panel_fg_alpha, DRAWFLAG_NORMAL );
 624                         }
 625                 }
 626         }
 627
 628         if ( (active_minigame.minigame_flags & SNAKE_TURN_LOSS) || (active_minigame.minigame_flags & SNAKE_TURN_WIN) || (minigame_self.snake_lives <= 0) )
 629         {
 630                 int scores = minigame_self.snake_score;
 631
 632                 vector winfs = hud_fontsize*2;
 633                 string scores_text, victory_text;
 634                 victory_text = "Game over!";
 635                 scores_text = strcat("Score: ", ftos(scores));
 636
 637                 if(active_minigame.minigame_flags & SNAKE_TURN_WIN)
 638                 if((active_minigame.minigame_flags & SNAKE_TURN_TEAM) == minigame_self.team)
 639                         victory_text = "You win!";
 640                 if(minigame_self.snake_lives <= 0)
 641                         victory_text = "You ran out of lives!";
 642
 643                 vector win_pos = pos+eY*(mySize_y-winfs_y)/2;
 644                 vector win_sz;
 645                 win_sz = minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
 646                         sprintf("%s %s", victory_text, scores_text),
 647                         winfs, 0, DRAWFLAG_NORMAL, 0.5);
 648
 649                 drawfill(win_pos-eY*hud_fontsize_y,win_sz+2*eY*hud_fontsize_y,'0.3 0.3 1',0.8,DRAWFLAG_ADDITIVE);
 650
 651                 minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
 652                         sprintf("%s %s", victory_text, scores_text),
 653                         winfs, panel_fg_alpha, DRAWFLAG_NORMAL, 0.5);
 654         }
 655 }
 656
 657
 658 // Required function, draw the game status panel
 659 void snake_hud_status(vector pos, vector mySize)
 660 {
 661         HUD_Panel_DrawBg(1);
 662         vector ts;
 663         ts = minigame_drawstring_wrapped(mySize_x,pos,active_minigame.descriptor.message,
 664                 hud_fontsize * 2, '0.25 0.47 0.72', panel_fg_alpha, DRAWFLAG_NORMAL,0.5);
 665
 666         pos_y += ts_y;
 667         mySize_y -= ts_y;
 668
 669         vector player_fontsize = hud_fontsize * 1.75;
 670         ts_y = ( mySize_y - 2*player_fontsize_y ) / SNAKE_TEAMS;
 671         ts_x = mySize_x;
 672         vector mypos;
 673         vector tile_size = '48 48 0';
 674
 675         mypos = pos;
 676         if ( minigame_self.team > 1 )
 677                 mypos_y  += player_fontsize_y + (ts_y * (minigame_self.team - 1));
 678         drawfill(mypos,eX*mySize_x+eY*player_fontsize_y,'1 1 1',0.5,DRAWFLAG_ADDITIVE);
 679         mypos_y += player_fontsize_y;
 680         drawfill(mypos,eX*mySize_x+eY*tile_size_y,'1 1 1',0.25,DRAWFLAG_ADDITIVE);
 681
 682         entity e;
 683         FOREACH_MINIGAME_ENTITY(e)
 684         {
 685                 if ( e.classname == "minigame_player" )
 686                 {
 687                         mypos = pos;
 688                         if ( e.team > 1 )
 689                                 mypos_y  += player_fontsize_y + (ts_y * (e.team - 1));
 690                         minigame_drawcolorcodedstring_trunc(mySize_x,mypos,
 691                                 GetPlayerName(e.minigame_playerslot-1),
 692                                 player_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
 693
 694                         vector tile_color = snake_teamcolor(e.team);
 695
 696                         mypos_y += player_fontsize_y;
 697                         drawpic( mypos,
 698                                         minigame_texture("snake/head"),
 699                                         tile_size * 0.7, tile_color, panel_fg_alpha, DRAWFLAG_NORMAL );
 700
 701                         mypos_x += tile_size_x;
 702
 703                         drawstring(mypos,ftos(e.snake_score),tile_size,
 704                                            '0.7 0.84 1', panel_fg_alpha, DRAWFLAG_NORMAL);
 705
 706                         mypos_x += tile_size_x;
 707
 708                         drawstring(mypos,strcat("1UP: ", ftos(e.snake_lives)),tile_size * 0.6,
 709                                                          '0.7 0.84 1', panel_fg_alpha, DRAWFLAG_NORMAL);
 710                 }
 711         }
 712 }
 713
 714 // Turn a set of flags into a help message
 715 string snake_turn_to_string(int turnflags)
 716 {
 717         if ( turnflags & SNAKE_TURN_LOSS )
 718                 return _("Game over!");
 719
 720         if ( turnflags & SNAKE_TURN_WIN )
 721         {
 722                 if ( (turnflags&SNAKE_TURN_TEAM) != minigame_self.team )
 723                         return _("You ran out of lives!");
 724                 return _("You win!");
 725         }
 726
 727         if(minigame_self.snake_lives <= 0)
 728                 return _("You ran out of lives!");
 729
 730         if ( (snake_find_head(active_minigame, minigame_self.team)).snake_dir == '0 0 0' )
 731                 return _("Press an arrow key to begin the game");
 732
 733         if ( turnflags & SNAKE_TURN_MOVE )
 734                 if(snake_wrap)
 735                         return _("Avoid the snake's body, collect the mice!");
 736                 else
 737                         return _("Avoid the screen edges and the snake's body, collect the mice!");
 738
 739         return "";
 740 }
 741
 742 // Make the correct move
 743 void snake_set_direction(entity minigame, int dx, int dy)
 744 {
 745         //if ( minigame.minigame_flags == SNAKE_TURN_MOVE )
 746         //{
 747                 minigame_cmd("move ",ftos(dx), " ", ftos(dy));
 748         //}
 749 }
 750
 751 // Required function, handle client events
 752 int snake_client_event(entity minigame, string event, ...)
 753 {
 754         switch(event)
 755         {
 756                 case "activate":
 757                 {
 758                         minigame.message = snake_turn_to_string(minigame.minigame_flags);
 759                         return false;
 760                 }
 761                 case "key_pressed":
 762                 {
 763                         //if((minigame.minigame_flags & SNAKE_TURN_TEAM) == minigame_self.team)
 764                         {
 765                                 switch ( ...(0,int) )
 766                                 {
 767                                         case K_RIGHTARROW:
 768                                         case K_KP_RIGHTARROW:
 769                                                 snake_set_direction(minigame, 1, 0);
 770                                                 return true;
 771                                         case K_LEFTARROW:
 772                                         case K_KP_LEFTARROW:
 773                                                 snake_set_direction(minigame, -1, 0);
 774                                                 return true;
 775                                         case K_UPARROW:
 776                                         case K_KP_UPARROW:
 777                                                 snake_set_direction(minigame, 0, 1);
 778                                                 return true;
 779                                         case K_DOWNARROW:
 780                                         case K_KP_DOWNARROW:
 781                                                 snake_set_direction(minigame, 0, -1);
 782                                                 return true;
 783                                 }
 784                         }
 785
 786                         return false;
 787                 }
 788                 case "network_receive":
 789                 {
 790                         entity sent = ...(0,entity);
 791                         int sf = ...(1,int);
 792                         if ( sent.classname == "minigame" )
 793                         {
 794                                 if ( sf & MINIG_SF_UPDATE )
 795                                 {
 796                                         snake_wrap = ReadByte();
 797                                         sent.message = snake_turn_to_string(sent.minigame_flags);
 798                                         //if ( sent.minigame_flags & minigame_self.team )
 799                                                 minigame_prompt();
 800                                 }
 801                         }
 802                         else if(sent.classname == "minigame_board_piece")
 803                         {
 804                                 if(sf & MINIG_SF_UPDATE)
 805                                 {
 806                                         sent.cnt = ReadByte();
 807                                         sent.snake_tail = ReadByte();
 808                                         sent.snake_dir_x = ReadCoord();
 809                                         sent.snake_dir_y = ReadCoord();
 810                                         sent.snake_dir_z = 0;
 811                                 }
 812                         }
 813                         else if ( sent.classname == "minigame_player" && (sf & SNAKE_SF_PLAYERSCORE ) )
 814                         {
 815                                 sent.snake_score = ReadLong();
 816                                 sent.snake_lives = ReadByte();
 817                         }
 818
 819                         return false;
 820                 }
 821         }
 822
 823         return false;
 824 }
 825
 826 #endif