cac11744000155e987161b0a8197c4e121048395
[xonotic/xonotic-data.pk3dir.git] / qcsrc / common / minigames / minigame / ttt.qc
1 REGISTER_MINIGAME(ttt, "Tic Tac Toe");
2
3 const int TTT_TURN_PLACE = 0x0100; // player has to place a piece on the board
4 const int TTT_TURN_WIN   = 0x0200; // player has won
5 const int TTT_TURN_DRAW  = 0x0400; // no moves are possible
6 const int TTT_TURN_NEXT  = 0x0800; // a player wants to start a new match
7 const int TTT_TURN_TYPE  = 0x0f00; // turn type mask
8
9 const int TTT_TURN_TEAM1 = 0x0001;
10 const int TTT_TURN_TEAM2 = 0x0002;
11 const int TTT_TURN_TEAM  = 0x000f; // turn team mask
12
13 // send flags
14 const int TTT_SF_PLAYERSCORE  = MINIG_SF_CUSTOM;   // send minigame_player scores (won matches)
15 const int TTT_SF_SINGLEPLAYER = MINIG_SF_CUSTOM<<1;// send minigame.ttt_ai
16
17 const int TTT_LET_CNT = 3;
18 const int TTT_NUM_CNT = 3;
19 const int TTT_TILE_SIZE = 3;
20
21 .int ttt_npieces; // (minigame) number of pieces on the board (simplifies checking a draw)
22 .int ttt_nexteam; // (minigame) next team (used to change the starting team on following matches)
23 .int ttt_ai;      // (minigame) when non-zero, singleplayer vs AI
24
25 // find tic tac toe piece given its tile name
26 entity ttt_find_piece(entity minig, string tile)
27 {
28         entity e = NULL;
29         while ( ( e = findentity(e,owner,minig) ) )
30                 if ( e.classname == "minigame_board_piece" && e.netname == tile )
31                         return e;
32         return NULL;
33 }
34
35 // Checks if the given piece completes a row
36 bool ttt_winning_piece(entity piece)
37 {
38         int number = minigame_tile_number(piece.netname);
39         int letter = minigame_tile_letter(piece.netname);
40
41         if ( ttt_find_piece(piece.owner,minigame_tile_buildname(0,number)).team == piece.team )
42         if ( ttt_find_piece(piece.owner,minigame_tile_buildname(1,number)).team == piece.team )
43         if ( ttt_find_piece(piece.owner,minigame_tile_buildname(2,number)).team == piece.team )
44                 return true;
45
46         if ( ttt_find_piece(piece.owner,minigame_tile_buildname(letter,0)).team == piece.team )
47         if ( ttt_find_piece(piece.owner,minigame_tile_buildname(letter,1)).team == piece.team )
48         if ( ttt_find_piece(piece.owner,minigame_tile_buildname(letter,2)).team == piece.team )
49                 return true;
50
51         if ( number == letter )
52         if ( ttt_find_piece(piece.owner,minigame_tile_buildname(0,0)).team == piece.team )
53         if ( ttt_find_piece(piece.owner,minigame_tile_buildname(1,1)).team == piece.team )
54         if ( ttt_find_piece(piece.owner,minigame_tile_buildname(2,2)).team == piece.team )
55                 return true;
56
57         if ( number == 2-letter )
58         if ( ttt_find_piece(piece.owner,minigame_tile_buildname(0,2)).team == piece.team )
59         if ( ttt_find_piece(piece.owner,minigame_tile_buildname(1,1)).team == piece.team )
60         if ( ttt_find_piece(piece.owner,minigame_tile_buildname(2,0)).team == piece.team )
61                 return true;
62
63         return false;
64 }
65
66 // check if the tile name is valid (3x3 grid)
67 bool ttt_valid_tile(string tile)
68 {
69         if ( !tile )
70                 return 0;
71         int number = minigame_tile_number(tile);
72         int letter = minigame_tile_letter(tile);
73         return 0 <= number && number < TTT_NUM_CNT && 0 <= letter && letter < TTT_LET_CNT;
74 }
75
76 // make a move
77 void ttt_move(entity minigame, entity player, string pos )
78 {
79         if ( minigame.minigame_flags & TTT_TURN_PLACE )
80         if ( pos && player.team == (minigame.minigame_flags & TTT_TURN_TEAM) )
81         {
82                 if ( ttt_valid_tile(pos) )
83                 if ( !ttt_find_piece(minigame,pos) )
84                 {
85                         entity piece = msle_spawn(minigame,"minigame_board_piece");
86                         piece.team = player.team;
87                         piece.netname = strzone(pos);
88                         minigame_server_sendflags(piece,MINIG_SF_ALL);
89                         minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
90                         minigame.ttt_npieces++;
91                         minigame.ttt_nexteam = minigame_next_team(player.team,2);
92                         if ( ttt_winning_piece(piece) )
93                         {
94                                 player.minigame_flags++;
95                                 minigame_server_sendflags(player, TTT_SF_PLAYERSCORE);
96                                 minigame.minigame_flags = TTT_TURN_WIN | player.team;
97                         }
98                         else if ( minigame.ttt_npieces >= (TTT_LET_CNT * TTT_NUM_CNT) )
99                                 minigame.minigame_flags = TTT_TURN_DRAW;
100                         else
101                                 minigame.minigame_flags = TTT_TURN_PLACE | minigame.ttt_nexteam;
102                 }
103         }
104 }
105
106 // request a new match
107 void ttt_next_match(entity minigame, entity player)
108 {
109 #ifdef SVQC
110         // on multiplayer matches, wait for both players to agree
111         if ( minigame.minigame_flags & (TTT_TURN_WIN|TTT_TURN_DRAW) )
112         {
113                 minigame.minigame_flags = TTT_TURN_NEXT | player.team;
114                 minigame.SendFlags |= MINIG_SF_UPDATE;
115         }
116         else if ( (minigame.minigame_flags & TTT_TURN_NEXT) &&
117                         !( minigame.minigame_flags & player.team ) )
118 #endif
119         {
120                 minigame.minigame_flags = TTT_TURN_PLACE | minigame.ttt_nexteam;
121                 minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
122                 minigame.ttt_npieces = 0;
123                 entity e = NULL;
124                 while ( ( e = findentity(e,owner,minigame) ) )
125                         if ( e.classname == "minigame_board_piece" )
126                                 delete(e);
127         }
128 }
129
130 #ifdef SVQC
131
132
133 // required function, handle server side events
134 int ttt_server_event(entity minigame, string event, ...)
135 {
136         switch(event)
137         {
138                 case "start":
139                 {
140                         minigame.minigame_flags = (TTT_TURN_PLACE | TTT_TURN_TEAM1);
141                         return true;
142                 }
143                 case "end":
144                 {
145                         entity e = NULL;
146                         while( (e = findentity(e, owner, minigame)) )
147                         if(e.classname == "minigame_board_piece")
148                         {
149                                 if(e.netname) { strunzone(e.netname); }
150                                 delete(e);
151                         }
152                         return false;
153                 }
154                 case "join":
155                 {
156                         int pl_num = minigame_count_players(minigame);
157
158                         // Don't allow joining a single player match
159                         if ( (minigame.ttt_ai) && pl_num > 0 )
160                                 return false;
161
162                         // Don't allow more than 2 players
163                         if(pl_num >= 2) { return false; }
164
165                         // Get the right team
166                         if(minigame.minigame_players)
167                                 return minigame_next_team(minigame.minigame_players.team, 2);
168
169                         // Team 1 by default
170                         return 1;
171                 }
172                 case "cmd":
173                 {
174                         switch(argv(0))
175                         {
176                                 case "move":
177                                         ttt_move(minigame, ...(0,entity), ...(1,int) == 2 ? argv(1) : string_null );
178                                         return true;
179                                 case "next":
180                                         ttt_next_match(minigame,...(0,entity));
181                                         return true;
182                                 case "singleplayer":
183                                         if ( minigame_count_players(minigame) == 1 )
184                                         {
185                                                 minigame.ttt_ai = minigame_next_team(minigame.minigame_players.team, 2);
186                                                 minigame.SendFlags = TTT_SF_SINGLEPLAYER;
187                                         }
188                                         return true;
189                         }
190
191                         return false;
192                 }
193                 case "network_send":
194                 {
195                         entity sent = ...(0,entity);
196                         int sf = ...(1,int);
197                         if ( sent.classname == "minigame_player" && (sf & TTT_SF_PLAYERSCORE ) )
198                         {
199                                 WriteByte(MSG_ENTITY,sent.minigame_flags);
200                         }
201                         else if ( sent.classname == "minigame" && (sf & TTT_SF_SINGLEPLAYER) )
202                         {
203                                 WriteByte(MSG_ENTITY,sent.ttt_ai);
204                         }
205                         return false;
206                 }
207         }
208
209         return false;
210 }
211
212
213 #elif defined(CSQC)
214
215 string ttt_curr_pos; // identifier of the tile under the mouse
216 vector ttt_boardpos; // HUD board position
217 vector ttt_boardsize;// HUD board size
218 .int ttt_checkwin; // Used to optimize checks to display a win
219
220 // Required function, draw the game board
221 void ttt_hud_board(vector pos, vector mySize)
222 {
223         minigame_hud_fitsqare(pos, mySize);
224         ttt_boardpos = pos;
225         ttt_boardsize = mySize;
226
227         minigame_hud_simpleboard(pos,mySize,minigame_texture("ttt/board"));
228
229         vector tile_size = minigame_hud_denormalize_size('1 1 0'/TTT_TILE_SIZE,pos,mySize);
230         vector tile_pos;
231
232         if ( (active_minigame.minigame_flags & TTT_TURN_TEAM) == minigame_self.team )
233         if ( ttt_valid_tile(ttt_curr_pos) )
234         {
235                 tile_pos = minigame_tile_pos(ttt_curr_pos,TTT_LET_CNT,TTT_NUM_CNT);
236                 tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
237                 minigame_drawpic_centered( tile_pos,
238                                 minigame_texture(strcat("ttt/piece",ftos(minigame_self.team))),
239                                 tile_size, '1 1 1', panel_fg_alpha/2, DRAWFLAG_NORMAL );
240         }
241
242         entity e;
243         FOREACH_MINIGAME_ENTITY(e)
244         {
245                 if ( e.classname == "minigame_board_piece" )
246                 {
247                         tile_pos = minigame_tile_pos(e.netname,TTT_LET_CNT,TTT_NUM_CNT);
248                         tile_pos = minigame_hud_denormalize(tile_pos,pos,mySize);
249
250                         if ( active_minigame.minigame_flags & TTT_TURN_WIN )
251                         if ( !e.ttt_checkwin )
252                                 e.ttt_checkwin = ttt_winning_piece(e) ? 1 : -1;
253
254                         float icon_color = 1;
255                         if ( e.ttt_checkwin == -1 )
256                                 icon_color = 0.4;
257                         else if ( e.ttt_checkwin == 1 )
258                         {
259                                 icon_color = 2;
260                                 minigame_drawpic_centered( tile_pos, minigame_texture("ttt/winglow"),
261                                                 tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_ADDITIVE );
262                         }
263
264                         minigame_drawpic_centered( tile_pos,
265                                         minigame_texture(strcat("ttt/piece",ftos(e.team))),
266                                         tile_size, '1 1 1'*icon_color, panel_fg_alpha, DRAWFLAG_NORMAL );
267                 }
268         }
269 }
270
271
272 // Required function, draw the game status panel
273 void ttt_hud_status(vector pos, vector mySize)
274 {
275         HUD_Panel_DrawBg();
276         vector ts;
277         ts = minigame_drawstring_wrapped(mySize_x,pos,active_minigame.descriptor.message,
278                 hud_fontsize * 2, '0.25 0.47 0.72', panel_fg_alpha, DRAWFLAG_NORMAL,0.5);
279
280         pos_y += ts_y;
281         mySize_y -= ts_y;
282
283         vector player_fontsize = hud_fontsize * 1.75;
284         ts_y = ( mySize_y - 2*player_fontsize_y ) / 2;
285         ts_x = mySize_x;
286         vector mypos;
287         vector tile_size = '48 48 0';
288
289         entity e;
290         FOREACH_MINIGAME_ENTITY(e)
291         {
292                 if ( e.classname == "minigame_player" )
293                 {
294                         mypos = pos;
295                         if ( e.team == 2 )
296                                 mypos_y  += player_fontsize_y + ts_y;
297                         minigame_drawcolorcodedstring_trunc(mySize_x,mypos,
298                                 (e.minigame_playerslot ? entcs_GetName(e.minigame_playerslot-1) : _("AI")),
299                                 player_fontsize, panel_fg_alpha, DRAWFLAG_NORMAL);
300
301                         mypos_y += player_fontsize_y;
302                         drawpic( mypos,
303                                         minigame_texture(strcat("ttt/piece",ftos(e.team))),
304                                         tile_size, '1 1 1', panel_fg_alpha, DRAWFLAG_NORMAL );
305
306                         mypos_x += tile_size_x;
307
308                         drawstring(mypos,ftos(e.minigame_flags),tile_size,
309                                            '0.7 0.84 1', panel_fg_alpha, DRAWFLAG_NORMAL);
310                 }
311         }
312 }
313
314 // Turn a set of flags into a help message
315 string ttt_turn_to_string(int turnflags)
316 {
317         if ( turnflags & TTT_TURN_DRAW )
318                 return _("Draw");
319
320         if ( turnflags & TTT_TURN_WIN )
321         {
322                 if ( (turnflags&TTT_TURN_TEAM) != minigame_self.team )
323                         return _("You lost the game!\nSelect \"^1Next Match^7\" on the menu for a rematch!");
324                 return _("You win!\nSelect \"^1Next Match^7\" on the menu to start a new match!");
325         }
326
327         if ( turnflags & TTT_TURN_NEXT )
328         {
329                 if ( (turnflags&TTT_TURN_TEAM) != minigame_self.team )
330                         return _("Select \"^1Next Match^7\" on the menu to start a new match!");
331                 return _("Wait for your opponent to confirm the rematch");
332         }
333
334         if ( (turnflags & TTT_TURN_TEAM) != minigame_self.team )
335                 return _("Wait for your opponent to make their move");
336
337         if ( turnflags & TTT_TURN_PLACE )
338                 return _("Click on the game board to place your piece");
339
340         return "";
341 }
342
343 const int TTT_AI_POSFLAG_A1 = 0x0001;
344 const int TTT_AI_POSFLAG_A2 = 0x0002;
345 const int TTT_AI_POSFLAG_A3 = 0x0004;
346 const int TTT_AI_POSFLAG_B1 = 0x0008;
347 const int TTT_AI_POSFLAG_B2 = 0x0010;
348 const int TTT_AI_POSFLAG_B3 = 0x0020;
349 const int TTT_AI_POSFLAG_C1 = 0x0040;
350 const int TTT_AI_POSFLAG_C2 = 0x0080;
351 const int TTT_AI_POSFLAG_C3 = 0x0100;
352
353 // convert a flag to a position
354 string ttt_ai_piece_flag2pos(int pieceflag)
355 {
356         switch(pieceflag)
357         {
358                 case TTT_AI_POSFLAG_A1:
359                         return "a1";
360                 case TTT_AI_POSFLAG_A2:
361                         return "a2";
362                 case TTT_AI_POSFLAG_A3:
363                         return "a3";
364
365                 case TTT_AI_POSFLAG_B1:
366                         return "b1";
367                 case TTT_AI_POSFLAG_B2:
368                         return "b2";
369                 case TTT_AI_POSFLAG_B3:
370                         return "b3";
371
372                 case TTT_AI_POSFLAG_C1:
373                         return "c1";
374                 case TTT_AI_POSFLAG_C2:
375                         return "c2";
376                 case TTT_AI_POSFLAG_C3:
377                         return "c3";
378
379                 default:
380                         return string_null;
381         }
382 }
383
384 bool ttt_ai_checkmask(int piecemask, int checkflags)
385 {
386         return checkflags && (piecemask & checkflags) == checkflags;
387 }
388
389 // get the third flag if the mask matches two of them
390 int ttt_ai_1of3(int piecemask, int flag1, int flag2, int flag3)
391 {
392         if ( ttt_ai_checkmask(piecemask,flag1|flag2|flag3) )
393                 return 0;
394
395         if ( ttt_ai_checkmask(piecemask,flag1|flag2) )
396                 return flag3;
397
398         if ( ttt_ai_checkmask(piecemask,flag3|flag2) )
399                 return flag1;
400
401         if ( ttt_ai_checkmask(piecemask,flag3|flag1) )
402                 return flag2;
403
404         return 0;
405 }
406
407 // Select a random flag in the mask
408 int ttt_ai_random(int piecemask)
409 {
410         if ( !piecemask )
411                 return 0;
412
413         int f = 1;
414
415         RandomSelection_Init();
416
417         for ( int i = 0; i < 9; i++ )
418         {
419                 if ( piecemask & f )
420                         RandomSelection_Add(NULL, f, string_null, 1, 1);
421                 f <<= 1;
422         }
423
424         LOG_TRACE(sprintf("TTT AI: selected %x from %x",
425                         RandomSelection_chosen_float, piecemask) );
426         return RandomSelection_chosen_float;
427 }
428
429 // Block/complete a 3 i na row
430 int ttt_ai_block3 ( int piecemask, int piecemask_free )
431 {
432         int r = 0;
433
434         r |= ttt_ai_1of3(piecemask,TTT_AI_POSFLAG_A1,TTT_AI_POSFLAG_A2,TTT_AI_POSFLAG_A3);
435         r |= ttt_ai_1of3(piecemask,TTT_AI_POSFLAG_B1,TTT_AI_POSFLAG_B2,TTT_AI_POSFLAG_B3);
436         r |= ttt_ai_1of3(piecemask,TTT_AI_POSFLAG_C1,TTT_AI_POSFLAG_C2,TTT_AI_POSFLAG_C3);
437         r |= ttt_ai_1of3(piecemask,TTT_AI_POSFLAG_A1,TTT_AI_POSFLAG_B1,TTT_AI_POSFLAG_C1);
438         r |= ttt_ai_1of3(piecemask,TTT_AI_POSFLAG_A2,TTT_AI_POSFLAG_B2,TTT_AI_POSFLAG_C2);
439         r |= ttt_ai_1of3(piecemask,TTT_AI_POSFLAG_A3,TTT_AI_POSFLAG_B3,TTT_AI_POSFLAG_C3);
440         r |= ttt_ai_1of3(piecemask,TTT_AI_POSFLAG_A1,TTT_AI_POSFLAG_B2,TTT_AI_POSFLAG_C3);
441         r |= ttt_ai_1of3(piecemask,TTT_AI_POSFLAG_A3,TTT_AI_POSFLAG_B2,TTT_AI_POSFLAG_C1);
442         LOG_TRACE(sprintf("TTT AI: possible 3 in a rows in %x: %x (%x)",piecemask,r, r&piecemask_free));
443         r &= piecemask_free;
444         return ttt_ai_random(r);
445 }
446
447 // Simple AI
448 // 1) tries to win the game if possible
449 // 2) tries to block the opponent if they have 2 in a row
450 // 3) places a piece randomly
451 string ttt_ai_choose_simple(int piecemask_self, int piecemask_opponent, int piecemask_free )
452 {
453         int move = 0;
454
455         LOG_TRACE("TTT AI: checking winning move");
456         if (( move = ttt_ai_block3(piecemask_self,piecemask_free) ))
457                 return ttt_ai_piece_flag2pos(move); // place winning move
458
459         LOG_TRACE("TTT AI: checking opponent's winning move");
460         if (( move = ttt_ai_block3(piecemask_opponent,piecemask_free) ))
461                 return ttt_ai_piece_flag2pos(move); // block opponent
462
463         LOG_TRACE("TTT AI: random move");
464         return ttt_ai_piece_flag2pos(ttt_ai_random(piecemask_free));
465 }
466
467 // AI move (if it's AI's turn)
468 void ttt_aimove(entity minigame)
469 {
470         if ( minigame.minigame_flags == (TTT_TURN_PLACE|minigame.ttt_ai) )
471         {
472                 entity aiplayer = NULL;
473                 while ( ( aiplayer = findentity(aiplayer,owner,minigame) ) )
474                         if ( aiplayer.classname == "minigame_player" && !aiplayer.minigame_playerslot )
475                                 break;
476
477                 /*
478                  * Build bit masks for the board pieces
479                  * .---.---.---.
480                  * | 4 | 32|256| 3
481                  * |---+---+---|
482                  * | 2 | 16|128| 2
483                  * |---+---+---|
484                  * | 1 | 8 | 64| 1
485                  * '---'---'---'
486                  *   A   B   C
487                  */
488                 int piecemask_self = 0;
489                 int piecemask_opponent = 0;
490                 int piecemask_free = 0;
491                 int pieceflag = 1;
492                 string pos;
493                 for ( int i = 0; i < 3; i++ )
494                 {
495                         for ( int j = 0; j < 3; j++ )
496                         {
497                                 pos = minigame_tile_buildname(i,j);
498                                 entity piece = ttt_find_piece(minigame,pos);
499                                 if ( piece )
500                                 {
501                                         if ( piece.team == aiplayer.team )
502                                                 piecemask_self |= pieceflag;
503                                         else
504                                                 piecemask_opponent |= pieceflag;
505                                 }
506                                 else
507                                         piecemask_free |= pieceflag;
508                                 pieceflag <<= 1;
509                         }
510                 }
511
512                 // TODO multiple AI difficulties
513                 LOG_TRACE(sprintf("TTT AI: self: %x opponent: %x free: %x",
514                                 piecemask_self, piecemask_opponent, piecemask_free));
515                 pos = ttt_ai_choose_simple(piecemask_self, piecemask_opponent, piecemask_free);
516                 LOG_TRACE("TTT AI: chosen move: ", pos);
517                 if ( !pos )
518                         LOG_TRACE("Tic Tac Toe AI has derped!");
519                 else
520                         ttt_move(minigame,aiplayer,pos);
521         }
522         minigame.message = ttt_turn_to_string(minigame.minigame_flags);
523 }
524
525 // Make the correct move
526 void ttt_make_move(entity minigame)
527 {
528         if ( minigame.minigame_flags == (TTT_TURN_PLACE|minigame_self.team) )
529         {
530                 if ( minigame.ttt_ai  )
531                 {
532                         ttt_move(minigame, minigame_self, ttt_curr_pos );
533                         ttt_aimove(minigame);
534                 }
535                 else
536                         minigame_cmd("move ",ttt_curr_pos);
537         }
538 }
539
540 void ttt_set_curr_pos(string s)
541 {
542         if ( ttt_curr_pos )
543                 strunzone(ttt_curr_pos);
544         if ( s )
545                 s = strzone(s);
546         ttt_curr_pos = s;
547 }
548
549 // Required function, handle client events
550 int ttt_client_event(entity minigame, string event, ...)
551 {
552         switch(event)
553         {
554                 case "activate":
555                 {
556                         ttt_set_curr_pos("");
557                         minigame.message = ttt_turn_to_string(minigame.minigame_flags);
558                         return false;
559                 }
560                 case "key_pressed":
561                 {
562                         if((minigame.minigame_flags & TTT_TURN_TEAM) == minigame_self.team)
563                         {
564                                 switch ( ...(0,int) )
565                                 {
566                                         case K_RIGHTARROW:
567                                         case K_KP_RIGHTARROW:
568                                                 if ( ! ttt_curr_pos )
569                                                         ttt_set_curr_pos("a3");
570                                                 else
571                                                         ttt_set_curr_pos(minigame_relative_tile(ttt_curr_pos,1,0,TTT_LET_CNT,TTT_NUM_CNT));
572                                                 return true;
573                                         case K_LEFTARROW:
574                                         case K_KP_LEFTARROW:
575                                                 if ( ! ttt_curr_pos )
576                                                         ttt_set_curr_pos("c3");
577                                                 else
578                                                         ttt_set_curr_pos(minigame_relative_tile(ttt_curr_pos,-1,0,TTT_LET_CNT,TTT_NUM_CNT));
579                                                 return true;
580                                         case K_UPARROW:
581                                         case K_KP_UPARROW:
582                                                 if ( ! ttt_curr_pos )
583                                                         ttt_set_curr_pos("a1");
584                                                 else
585                                                         ttt_set_curr_pos(minigame_relative_tile(ttt_curr_pos,0,1,TTT_LET_CNT,TTT_NUM_CNT));
586                                                 return true;
587                                         case K_DOWNARROW:
588                                         case K_KP_DOWNARROW:
589                                                 if ( ! ttt_curr_pos )
590                                                         ttt_set_curr_pos("a3");
591                                                 else
592                                                         ttt_set_curr_pos(minigame_relative_tile(ttt_curr_pos,0,-1,TTT_LET_CNT,TTT_NUM_CNT));
593                                                 return true;
594                                         case K_ENTER:
595                                         case K_KP_ENTER:
596                                         case K_SPACE:
597                                                 ttt_make_move(minigame);
598                                                 return true;
599                                 }
600                         }
601
602                         return false;
603                 }
604                 case "mouse_pressed":
605                 {
606                         if(...(0,int) == K_MOUSE1)
607                         {
608                                 ttt_make_move(minigame);
609                                 return true;
610                         }
611
612                         return false;
613                 }
614                 case "mouse_moved":
615                 {
616                         vector mouse_pos = minigame_hud_normalize(mousepos,ttt_boardpos,ttt_boardsize);
617                         if ( minigame.minigame_flags == (TTT_TURN_PLACE|minigame_self.team) )
618                                 ttt_set_curr_pos(minigame_tile_name(mouse_pos,TTT_LET_CNT,TTT_NUM_CNT));
619                         if ( ! ttt_valid_tile(ttt_curr_pos) )
620                                 ttt_set_curr_pos("");
621
622                         return true;
623                 }
624                 case "network_receive":
625                 {
626                         entity sent = ...(0,entity);
627                         int sf = ...(1,int);
628                         if ( sent.classname == "minigame" )
629                         {
630                                 if ( sf & MINIG_SF_UPDATE )
631                                 {
632                                         sent.message = ttt_turn_to_string(sent.minigame_flags);
633                                         if ( sent.minigame_flags & minigame_self.team )
634                                                 minigame_prompt();
635                                 }
636
637                                 if ( (sf & TTT_SF_SINGLEPLAYER) )
638                                 {
639                                         int ai = ReadByte();
640                                         bool spawnai = ai && !sent.ttt_ai;
641                                         sent.ttt_ai = ai;
642
643                                         if ( spawnai )
644                                         {
645                                                 entity aiplayer = new(minigame_player);
646                                                 aiplayer.owner = minigame;
647                                                 aiplayer.team = ai;
648                                                 aiplayer.minigame_playerslot = 0;
649                                                 aiplayer.minigame_autoclean = 1;
650                                                 ttt_aimove(minigame);
651                                         }
652
653                                 }
654                         }
655                         else if ( sent.classname == "minigame_player" && (sf & TTT_SF_PLAYERSCORE ) )
656                         {
657                                 sent.minigame_flags = ReadByte();
658                         }
659
660                         return false;
661                 }
662                 case "menu_show":
663                 {
664                         HUD_MinigameMenu_CustomEntry(...(0,entity),_("Next Match"),"next");
665                         HUD_MinigameMenu_CustomEntry(...(0,entity),_("Single Player"),"singleplayer");
666                         return false;
667                 }
668                 case "menu_click":
669                 {
670                         if(...(0,string) == "next")
671                         {
672                                 if ( minigame.ttt_ai )
673                                 {
674                                         ttt_next_match(minigame,minigame_self);
675                                         ttt_aimove(minigame);
676                                 }
677                                 else
678                                         minigame_cmd("next");
679                         }
680                         else if ( ...(0,string) == "singleplayer" && !minigame.ttt_ai )
681                         {
682                                 if ( minigame_count_players(minigame) == 1 )
683                                         minigame_cmd("singleplayer");
684                         }
685                         return false;
686                 }
687         }
688
689         return false;
690 }
691
692 #endif