1 REGISTER_MINIGAME(snake, "Snake"); // SNAAAAKE
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
8 const int SNAKE_TURN_TEAM = 0x000f; // turn team mask
10 const int SNAKE_SF_PLAYERSCORE = MINIG_SF_CUSTOM;
12 const int SNAKE_LET_CNT = 15;
13 const int SNAKE_NUM_CNT = 15;
15 const int SNAKE_TILE_SIZE = 15;
17 const int SNAKE_TEAMS = 6;
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;
30 .entity snake_next, snake_last, snake_prev;
34 .int snake_lives[SNAKE_TEAMS + 1];
36 .int snake_lost_teams;
38 bool snake_alone(entity minig)
42 while ( ( e = findentity(e,owner,minig) ) )
43 if ( e.classname == "minigame_board_piece" && e.cnt == 1 )
46 return headcount <= 1;
49 // find same game piece given its tile name
50 entity snake_find_piece(entity minig, string tile)
53 while ( ( e = findentity(e,owner,minig) ) )
54 if ( e.classname == "minigame_board_piece" && e.netname == tile )
59 // find same game piece given its cnt
60 entity snake_find_cnt(entity minig, int steam, int tile)
63 while ( ( e = findentity(e,owner,minig) ) )
64 if ( e.classname == "minigame_board_piece" && e.cnt == tile && e.team == steam )
69 // check if the tile name is valid (15x15 grid)
70 bool snake_valid_tile(string tile)
74 int number = minigame_tile_number(tile);
75 int letter = minigame_tile_letter(tile);
76 return 0 <= number && number < SNAKE_NUM_CNT && 0 <= letter && letter < SNAKE_LET_CNT;
79 entity snake_find_head(entity minig, int steam)
82 while ( ( e = findentity(e,owner,minig) ) )
83 if ( e.classname == "minigame_board_piece" && e.cnt == 1 && e.team == steam )
88 void snake_new_mouse(entity minigame)
90 RandomSelection_Init();
92 for(i = 0; i < SNAKE_LET_CNT; ++i)
93 for(j = 0; j < SNAKE_NUM_CNT; ++j)
95 string pos = minigame_tile_buildname(i, j);
96 if(!snake_find_piece(minigame, pos))
97 RandomSelection_Add(world, 0, pos, 1, 1);
100 entity piece = msle_spawn(minigame,"minigame_board_piece");
102 piece.netname = strzone(RandomSelection_chosen_string);
103 minigame_server_sendflags(piece,MINIG_SF_ALL);
105 minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
108 entity snake_get_player(entity minigame, int pteam);
109 int snake_winning_team(entity minigame)
111 int winning_team = 0;
112 for(int i = 1; i <= SNAKE_TEAMS; ++i)
114 entity pl = snake_get_player(minigame, i);
115 if(pl && minigame.snake_lives[i] > 0)
126 void snake_check_winner(entity minigame)
128 if(snake_alone(minigame) && !minigame.snake_lost_teams)
131 int winner = snake_winning_team(minigame);
134 for(int i = 1; i <= SNAKE_TEAMS; ++i)
136 entity pl = snake_get_player(minigame, i);
137 if(pl && minigame.snake_lives[i] > 0)
143 minigame.minigame_flags = SNAKE_TURN_LOSS;
144 minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
150 minigame.minigame_flags = SNAKE_TURN_WIN | winner;
151 minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
155 void snake_move_head(entity minigame, entity head);
156 void snake_head_think()
159 entity minigame = self.owner;
161 if(minigame.minigame_flags & SNAKE_TURN_MOVE)
162 snake_move_head(minigame, self);
164 snake_check_winner(minigame);
166 self.nextthink = time + self.snake_delay;
169 void minigame_setup_snake(entity minigame, int pteam)
171 RandomSelection_Init();
173 for(i = 1; i < SNAKE_LET_CNT - 1; ++i)
174 for(j = 1; j < SNAKE_NUM_CNT - 1; ++j)
176 string pos = minigame_tile_buildname(i, j);
177 if(!snake_find_piece(minigame, pos))
178 RandomSelection_Add(world, 0, pos, 1, 1);
181 entity piece = msle_spawn(minigame,"minigame_board_piece");
183 piece.netname = strzone(RandomSelection_chosen_string);
185 piece.snake_next = world;
186 piece.snake_prev = world;
187 piece.snake_last = piece;
188 piece.think = snake_head_think;
189 piece.snake_delay = autocvar_sv_minigames_snake_delay_initial;
190 piece.nextthink = time + 0.1;
191 minigame_server_sendflags(piece,MINIG_SF_ALL);
194 void snake_setup_pieces(entity minigame)
196 snake_new_mouse(minigame);
198 minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
201 entity snake_get_player(entity minigame, int pteam)
205 for(e = minigame.minigame_players; e; e = e.list_next)
208 while( (e = findentity(e,owner,minigame)) )
209 if ( e.classname == "minigame_player" )
216 void snake_add_score(entity minigame, int pteam, int thescore)
221 entity pl = snake_get_player(minigame, pteam);
224 pl.snake_score += thescore;
225 pl.SendFlags |= SNAKE_SF_PLAYERSCORE;
230 void snake_move_body(entity minigame, entity head, bool ate_mouse)
232 for(entity e = head.snake_last; e; e = e.snake_prev)
234 if(!e || e == head) { break; }
236 entity nextpiece = e.snake_prev; // can be head
238 if(e.netname) { strunzone(e.netname); }
239 e.netname = strzone(nextpiece.netname);
240 e.snake_dir = nextpiece.snake_dir;
241 minigame_server_sendflags(e, MINIG_SF_UPDATE);
246 entity tail = head.snake_last;
248 tail.snake_tail = false;
250 int newcnt = tail.cnt + 1;
251 head.snake_delay = max(autocvar_sv_minigames_snake_delay_min, autocvar_sv_minigames_snake_delay_initial - (newcnt / autocvar_sv_minigames_snake_delay_multiplier));
252 snake_add_score(minigame, head.team, 1);
254 entity piece = msle_spawn(minigame,"minigame_board_piece");
256 piece.team = head.team;
257 piece.snake_prev = tail;
258 piece.snake_dir = tail.snake_dir;
259 piece.snake_next = world;
260 piece.snake_tail = true;
261 piece.netname = strzone(tail.netname);
263 tail.snake_next = piece;
264 head.snake_last = piece;
266 minigame_server_sendflags(piece,MINIG_SF_UPDATE);
268 //minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
272 void snake_eat_team(entity minigame, int pteam)
274 entity head = snake_find_head(minigame, pteam);
275 if(!head) { return; }
277 minigame.snake_lives[pteam] -= 1;
279 entity pl = snake_get_player(minigame, pteam);
281 pl.SendFlags |= SNAKE_SF_PLAYERSCORE;
284 head.nextthink = time + 1; // make sure they don't to eat us somehow
287 while ( ( e = findentity(e,owner,minigame) ) )
288 if ( e.classname == "minigame_board_piece" && e.cnt && e.team == pteam )
290 if(e.netname) { strunzone(e.netname); }
294 if(minigame.snake_lives[pteam] <= 0)
295 minigame.snake_lost_teams |= BIT(pteam);
297 if(pl && minigame.snake_lives[pteam] > 0)
298 minigame_setup_snake(minigame, pteam);
301 void snake_move_head(entity minigame, entity head)
303 if(!head.snake_dir_x && !head.snake_dir_y)
308 if(autocvar_sv_minigames_snake_wrap)
309 newpos = minigame_relative_tile(head.netname, head.snake_dir_x, head.snake_dir_y, SNAKE_NUM_CNT, SNAKE_LET_CNT);
312 int myx = minigame_tile_letter(head.netname);
313 int myy = minigame_tile_number(head.netname);
315 myx += head.snake_dir_x;
316 myy += head.snake_dir_y;
318 newpos = minigame_tile_buildname(myx, myy);
321 entity hit = snake_find_piece(minigame, newpos);
323 if(!snake_valid_tile(newpos) || (hit && hit.cnt && hit.team == head.team))
325 if(snake_alone(minigame))
327 minigame.minigame_flags = SNAKE_TURN_LOSS;
328 minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
332 snake_add_score(minigame, head.team, -1);
333 snake_eat_team(minigame, head.team);
339 bool ate_mouse = (hit && !hit.cnt);
341 // move the body first, then set the new head position?
342 snake_move_body(minigame, head, ate_mouse);
344 if(head.netname) { strunzone(head.netname); }
345 head.netname = strzone(newpos);
346 minigame_server_sendflags(head,MINIG_SF_UPDATE);
348 // above check makes sure it's not our team
351 snake_eat_team(minigame, hit.team);
352 snake_add_score(minigame, head.team, 1);
357 if(hit.netname) { strunzone(hit.netname); }
360 snake_new_mouse(minigame);
365 void snake_move(entity minigame, entity player, string dxs, string dys )
367 if ( minigame.minigame_flags & SNAKE_TURN_MOVE )
370 //if ( snake_valid_tile(pos) )
371 //if ( snake_find_piece(minigame, pos) )
373 entity head = snake_find_head(minigame, player.team);
375 return; // their head is already dead
377 int dx = ((dxs) ? bound(-1, stof(dxs), 1) : 0);
378 int dy = ((dys) ? bound(-1, stof(dys), 1) : 0);
380 int myl = minigame_tile_letter(head.netname);
381 int myn = minigame_tile_number(head.netname);
383 entity check_piece = snake_find_piece(minigame, minigame_tile_buildname(myl + dx, myn + dy));
384 if(check_piece && check_piece.cnt == 2)
387 if(head.snake_dir == '0 0 0')
388 head.nextthink = time; // TODO: make sure this can't be exploited!
389 head.snake_dir_x = dx;
390 head.snake_dir_y = dy;
391 head.snake_dir_z = 0;
392 minigame_server_sendflags(head,MINIG_SF_UPDATE);
393 minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
401 // required function, handle server side events
402 int snake_server_event(entity minigame, string event, ...)
408 snake_setup_pieces(minigame);
409 minigame.minigame_flags = SNAKE_TURN_MOVE;
410 minigame.snake_lost_teams = 0;
414 for(int i = 1; i <= SNAKE_TEAMS; ++i)
415 minigame.snake_lives[i] = autocvar_sv_minigames_snake_lives;
418 minigame.snake_lives[1] = 1;
425 while( (e = findentity(e, owner, minigame)) )
426 if(e.classname == "minigame_board_piece")
428 if(e.netname) { strunzone(e.netname); }
435 int pl_num = minigame_count_players(minigame);
437 if(pl_num >= SNAKE_TEAMS) { return false; }
439 int t = 1; // Team 1 by default
441 for(int i = 1; i <= SNAKE_TEAMS; ++i)
443 entity e = snake_get_player(minigame, i);
451 if(!snake_find_head(minigame, t) && !(minigame.snake_lost_teams & BIT(t)))
453 entity pl = ...(1,entity);
456 //pl.snake_lives = ((SNAKE_TEAMS > 1) ? autocvar_sv_minigames_snake_lives : 1);
457 // send score anyway, lives are set
458 pl.SendFlags |= SNAKE_SF_PLAYERSCORE;
460 minigame_setup_snake(minigame, t);
470 snake_move(minigame, ...(0,entity), ((...(1,int)) >= 2 ? argv(1) : string_null), ((...(1,int)) == 3 ? argv(2) : string_null));
478 entity sent = ...(0,entity);
480 if ( sent.classname == "minigame_board_piece" && (sf & MINIG_SF_UPDATE) )
482 int letter = minigame_tile_letter(sent.netname);
483 int number = minigame_tile_number(sent.netname);
485 WriteByte(MSG_ENTITY,letter);
486 WriteByte(MSG_ENTITY,number);
488 WriteByte(MSG_ENTITY,sent.cnt);
489 WriteByte(MSG_ENTITY,sent.snake_tail);
491 int dx = sent.snake_dir_x;
492 int dy = sent.snake_dir_y;
495 WriteByte(MSG_ENTITY,dx);
496 WriteByte(MSG_ENTITY,dy);
498 else if ( sent.classname == "minigame_player" && (sf & SNAKE_SF_PLAYERSCORE ) )
500 WriteLong(MSG_ENTITY,sent.snake_score);
501 WriteByte(MSG_ENTITY,max(0, minigame.snake_lives[sent.team]));
503 else if ( sent.classname == "minigame" && (sf & MINIG_SF_UPDATE ) )
505 WriteByte(MSG_ENTITY,autocvar_sv_minigames_snake_wrap);
517 vector snake_boardpos; // HUD board position
518 vector snake_boardsize;// HUD board size
522 vector snake_teamcolor(int steam)
526 case 1: return '1 0 0';
527 case 2: return '0 0 1';
528 case 3: return '1 1 0';
529 case 4: return '1 0 1';
530 case 5: return '0 1 0';
531 case 6: return '0 1 1';
537 // Required function, draw the game board
538 void snake_hud_board(vector pos, vector mySize)
540 minigame_hud_fitsqare(pos, mySize);
541 snake_boardpos = pos;
542 snake_boardsize = mySize;
544 minigame_hud_simpleboard(pos,mySize,minigame_texture("snake/board"));
546 vector tile_size = minigame_hud_denormalize_size('1 1 0' / SNAKE_TILE_SIZE,pos,mySize);
550 FOREACH_MINIGAME_ENTITY(e)
552 if ( e.classname == "minigame_board_piece" )
554 tile_pos = minigame_tile_pos(e.netname,SNAKE_NUM_CNT,SNAKE_LET_CNT);
555 tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
557 vector tile_color = snake_teamcolor(e.team);
559 string thepiece = "snake/mouse";
561 thepiece = "snake/body";
563 thepiece = "snake/tail";
566 int dx = minigame_tile_letter(e.netname) + e.snake_dir_x * 2;
567 int dy = minigame_tile_number(e.netname) + e.snake_dir_y * 2;
568 entity mouse = snake_find_piece(active_minigame, minigame_tile_buildname(dx, dy));
569 thepiece = "snake/head";
570 if(mouse && mouse.team != e.team)
573 int myx = minigame_tile_letter(e.netname);
574 int myy = minigame_tile_number(e.netname);
582 int newx = minigame_tile_letter(e.netname) + e.snake_dir_x;
583 int newy = minigame_tile_number(e.netname) + e.snake_dir_y;
584 string newpos = minigame_tile_buildname(newx, newy);
586 vector my_pos = minigame_tile_pos(newpos,SNAKE_NUM_CNT,SNAKE_LET_CNT);
587 my_pos = minigame_hud_denormalize(my_pos,pos,mySize);
589 drawrotpic(my_pos, myang, minigame_texture("snake/tongue"),
590 tile_size, tile_size/2, tile_color,
591 panel_fg_alpha, DRAWFLAG_NORMAL );
595 if(e.cnt == 1 || e.snake_tail)
597 vector thedir = e.snake_dir;
601 int thex = minigame_tile_letter(e.netname);
602 int they = minigame_tile_number(e.netname);
603 entity t = snake_find_cnt(active_minigame, e.team, e.cnt - 1);
604 int tx = minigame_tile_letter(t.netname);
605 int ty = minigame_tile_number(t.netname);
631 drawrotpic(tile_pos, theang, minigame_texture(thepiece),
632 tile_size, tile_size/2, tile_color,
633 panel_fg_alpha, DRAWFLAG_NORMAL );
637 minigame_drawpic_centered( tile_pos,
638 minigame_texture(thepiece),
639 tile_size, tile_color, panel_fg_alpha, DRAWFLAG_NORMAL );
644 if ( (active_minigame.minigame_flags & SNAKE_TURN_LOSS) || (active_minigame.minigame_flags & SNAKE_TURN_WIN) || (active_minigame.snake_lives[minigame_self.team] <= 0) )
646 int scores = minigame_self.snake_score;
648 vector winfs = hud_fontsize*2;
649 string scores_text, victory_text;
650 victory_text = "Game over!";
651 scores_text = strcat("Score: ", ftos(scores));
653 if(active_minigame.minigame_flags & SNAKE_TURN_WIN)
654 if((active_minigame.minigame_flags & SNAKE_TURN_TEAM) == minigame_self.team)
655 victory_text = "You win!";
656 if(active_minigame.snake_lives[minigame_self.team] <= 0)
657 victory_text = "You ran out of lives!";
659 vector win_pos = pos+eY*(mySize_y-winfs_y)/2;
661 win_sz = minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
662 sprintf("%s %s", victory_text, scores_text),
663 winfs, 0, DRAWFLAG_NORMAL, 0.5);
665 drawfill(win_pos-eY*hud_fontsize_y,win_sz+2*eY*hud_fontsize_y,'0.3 0.3 1',0.8,DRAWFLAG_ADDITIVE);
667 minigame_drawcolorcodedstring_wrapped(mySize_x,win_pos,
668 sprintf("%s %s", victory_text, scores_text),
669 winfs, panel_fg_alpha, DRAWFLAG_NORMAL, 0.5);
674 // Required function, draw the game status panel
675 void snake_hud_status(vector pos, vector mySize)
679 ts = minigame_drawstring_wrapped(mySize_x,pos,active_minigame.descriptor.message,
680 hud_fontsize * 2, '0.25 0.47 0.72', panel_fg_alpha, DRAWFLAG_NORMAL,0.5);
681 ts_y += hud_fontsize_y;
685 vector player_fontsize = hud_fontsize * 1.75;
686 ts_y = ( mySize_y - SNAKE_TEAMS*player_fontsize_y ) / SNAKE_TEAMS;
691 FOREACH_MINIGAME_ENTITY(e)
693 if ( e.classname == "minigame_player" )
696 mypos_y += (e.team-1) * (player_fontsize_y + ts_y);
698 drawfill(mypos, ts, snake_teamcolor(e.team), 0.25, DRAWFLAG_ADDITIVE);
700 minigame_drawcolorcodedstring_trunc(mySize_x,mypos,
701 entcs_GetName(e.minigame_playerslot-1),
702 player_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
704 drawstring(mypos+eY*player_fontsize_y,ftos(e.snake_score),'48 48 0' * (SNAKE_TEAMS * 0.1),
705 '0.7 0.84 1', panel_fg_alpha, DRAWFLAG_NORMAL);
706 drawstring(mypos+(eY*player_fontsize_y) + (eX*player_fontsize_x),strcat("1UP: ", ftos(active_minigame.snake_lives[e.team])),'48 48 0' * (SNAKE_TEAMS * 0.1),
707 '1 0.44 0.54', panel_fg_alpha, DRAWFLAG_NORMAL);
709 if ( e == minigame_self )
710 drawborderlines(1, mypos, ts, snake_teamcolor(e.team), 1, DRAWFLAG_NORMAL);
715 // Turn a set of flags into a help message
716 string snake_turn_to_string(int turnflags)
718 if ( turnflags & SNAKE_TURN_LOSS )
719 return _("Game over!");
721 if ( turnflags & SNAKE_TURN_WIN )
723 if ( (turnflags&SNAKE_TURN_TEAM) != minigame_self.team )
724 return _("You ran out of lives!");
725 return _("You win!");
728 if(active_minigame.snake_lives[minigame_self.team] <= 0)
729 return _("You ran out of lives!");
731 if ( (snake_find_head(active_minigame, minigame_self.team)).snake_dir == '0 0 0' )
732 return _("Press an arrow key to begin the game");
734 if ( turnflags & SNAKE_TURN_MOVE )
736 return _("Avoid the snake's body, collect the mice!");
738 return _("Avoid the screen edges and the snake's body, collect the mice!");
743 // Make the correct move
744 void snake_set_direction(entity minigame, int dx, int dy)
746 //if ( minigame.minigame_flags == SNAKE_TURN_MOVE )
748 minigame_cmd("move ",ftos(dx), " ", ftos(dy));
752 // Required function, handle client events
753 int snake_client_event(entity minigame, string event, ...)
759 minigame.message = snake_turn_to_string(minigame.minigame_flags);
764 //if((minigame.minigame_flags & SNAKE_TURN_TEAM) == minigame_self.team)
766 switch ( ...(0,int) )
769 case K_KP_RIGHTARROW:
770 snake_set_direction(minigame, 1, 0);
774 snake_set_direction(minigame, -1, 0);
778 snake_set_direction(minigame, 0, 1);
782 snake_set_direction(minigame, 0, -1);
789 case "network_receive":
791 entity sent = ...(0,entity);
793 if ( sent.classname == "minigame" )
795 if ( sf & MINIG_SF_UPDATE )
797 snake_wrap = ReadByte();
798 sent.message = snake_turn_to_string(sent.minigame_flags);
799 //if ( sent.minigame_flags & minigame_self.team )
803 else if(sent.classname == "minigame_board_piece")
805 if(sf & MINIG_SF_UPDATE)
807 int letter = ReadByte();
808 int number = ReadByte();
809 if(sent.netname) { strunzone(sent.netname); }
810 sent.netname = strzone(minigame_tile_buildname(letter, number));
812 sent.cnt = ReadByte();
813 sent.snake_tail = ReadByte();
821 sent.snake_dir_x = dx;
822 sent.snake_dir_y = dy;
823 sent.snake_dir_z = 0;
826 else if ( sent.classname == "minigame_player" && (sf & SNAKE_SF_PLAYERSCORE ) )
828 sent.snake_score = ReadLong();
829 minigame.snake_lives[sent.team] = ReadByte();