ttt.qc File Reference

#include "ttt.qh"

Include dependency graph for ttt.qc:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
	REGISTER_MINIGAME (ttt, _("Tic Tac Toe"))
entity	ttt_find_piece (entity minig, string tile)
void	ttt_move (entity minigame, entity player, string pos)
void	ttt_next_match (entity minigame, entity player)
int	ttt_server_event (entity minigame, string event,...)
bool	ttt_valid_tile (string tile)
bool	ttt_winning_piece (entity piece)

Variables
int	ttt_ai
const int	TTT_LET_CNT = 3
int	ttt_nexteam
int	ttt_npieces
const int	TTT_NUM_CNT = 3
const int	TTT_SF_PLAYERSCORE = MINIG_SF_CUSTOM
const int	TTT_SF_SINGLEPLAYER = MINIG_SF_CUSTOM<<1
const int	TTT_SPECTATOR_TEAM = 255
const int	TTT_TILE_SIZE = 3
const int	TTT_TURN_DRAW = 0x0400
const int	TTT_TURN_NEXT = 0x0800
const int	TTT_TURN_PLACE = 0x0100
const int	TTT_TURN_TEAM = 0x000f
const int	TTT_TURN_TEAM1 = 0x0001
const int	TTT_TURN_TEAM2 = 0x0002
const int	TTT_TURN_TYPE = 0x0f00
const int	TTT_TURN_WIN = 0x0200

Function Documentation

REGISTER_MINIGAME()

REGISTER_MINIGAME	(	ttt	,
		_("Tic Tac Toe")	)

ttt_find_piece()

entity ttt_find_piece	(	entity	minig,
		string	tile )

Definition at line 29 of file ttt.qc.

{
    entity e = NULL;
    while ( ( e = findentity(e,owner,minig) ) )
        if ( e.classname == "minigame_board_piece" && e.netname == tile )
            return e;
    return NULL;
}

References entity(), findentity(), NULL, and owner.

Referenced by ttt_move(), and ttt_winning_piece().

ttt_move()

void ttt_move	(	entity	minigame,
		entity	player,
		string	pos )

Definition at line 80 of file ttt.qc.

{
    if ( minigame.minigame_flags & TTT_TURN_PLACE )
    if ( pos && player.team == (minigame.minigame_flags & TTT_TURN_TEAM) )
    {
        if ( ttt_valid_tile(pos) )
        if ( !ttt_find_piece(minigame,pos) )
        {
            entity piece = msle_spawn(minigame,new(minigame_board_piece));
            piece.team = player.team;
            piece.netname = strzone(pos);
            minigame_server_sendflags(piece,MINIG_SF_ALL);
            minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
            minigame.ttt_npieces++;
            minigame.ttt_nexteam = minigame_next_team(player.team,2);
            if ( ttt_winning_piece(piece) )
            {
                player.minigame_flags++;
                minigame_server_sendflags(player, TTT_SF_PLAYERSCORE);
                minigame.minigame_flags = TTT_TURN_WIN | player.team;
            }
            else if ( minigame.ttt_npieces >= (TTT_LET_CNT * TTT_NUM_CNT) )
                minigame.minigame_flags = TTT_TURN_DRAW;
            else
                minigame.minigame_flags = TTT_TURN_PLACE | minigame.ttt_nexteam;
        }
    }
}

References entity(), MINIG_SF_ALL, MINIG_SF_UPDATE, minigame_next_team(), minigame_server_sendflags(), msle_spawn(), strzone(), ttt_find_piece(), TTT_LET_CNT, TTT_NUM_CNT, TTT_SF_PLAYERSCORE, TTT_TURN_DRAW, TTT_TURN_PLACE, TTT_TURN_TEAM, TTT_TURN_WIN, ttt_valid_tile(), and ttt_winning_piece().

Referenced by ttt_server_event().

ttt_next_match()

void ttt_next_match	(	entity	minigame,
		entity	player )

Definition at line 110 of file ttt.qc.

{
#ifdef SVQC
    // on multiplayer matches, wait for both players to agree
    if ( minigame.minigame_flags & (TTT_TURN_WIN|TTT_TURN_DRAW) )
    {
        minigame.minigame_flags = TTT_TURN_NEXT | player.team;
        minigame.SendFlags |= MINIG_SF_UPDATE;
    }
    else if ( (minigame.minigame_flags & TTT_TURN_NEXT) &&
            !( minigame.minigame_flags & player.team ) )
#endif
    {
        minigame.minigame_flags = TTT_TURN_PLACE | minigame.ttt_nexteam;
        minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
        minigame.ttt_npieces = 0;
        entity e = NULL;
        while ( ( e = findentity(e,owner,minigame) ) )
            if ( e.classname == "minigame_board_piece" )
                delete(e);
    }
}

References entity(), findentity(), MINIG_SF_UPDATE, minigame_server_sendflags(), NULL, owner, TTT_TURN_DRAW, TTT_TURN_NEXT, TTT_TURN_PLACE, and TTT_TURN_WIN.

Referenced by ttt_server_event().

ttt_server_event()

int ttt_server_event	(	entity	minigame,
		string	event,
			... )

Definition at line 137 of file ttt.qc.

{
    switch(event)
    {
        case "start":
        {
            minigame.minigame_flags = (TTT_TURN_PLACE | TTT_TURN_TEAM1);
            return true;
        }
        case "end":
        {
            entity e = NULL;
            while( (e = findentity(e, owner, minigame)) )
            if(e.classname == "minigame_board_piece")
            {
                strfree(e.netname);
                delete(e);
            }
            return false;
        }
        case "join":
        {
            int pl_num = minigame_count_players(minigame);
 
            // Don't allow joining a single player match
            if ( (minigame.ttt_ai) && pl_num > 0 )
                return false;
 
            // Don't allow more than 2 players
            if(pl_num >= 2) { return TTT_SPECTATOR_TEAM; }
 
            // Get the right team
            if(minigame.minigame_players)
                return minigame_next_team(minigame.minigame_players.team, 2);
 
            // Team 1 by default
            return 1;
        }
        case "cmd":
        {
            entity player = ...(0,entity);
            bool event_blocked = (player.team == TTT_SPECTATOR_TEAM);
            switch(argv(0))
            {
                case "move":
                    if(event_blocked)
                        return true;
                    ttt_move(minigame, ...(0,entity), ...(1,int) == 2 ? argv(1) : string_null );
                    return true;
                case "next":
                    if(event_blocked)
                        return true;
                    ttt_next_match(minigame,...(0,entity));
                    return true;
                case "singleplayer":
                    if(event_blocked)
                        return true;
                    if ( minigame_count_players(minigame) == 1 )
                    {
                        minigame.ttt_ai = minigame_next_team(minigame.minigame_players.team, 2);
                        minigame.SendFlags = TTT_SF_SINGLEPLAYER;
                    }
                    return true;
            }
 
            return false;
        }
        case "network_send":
        {
            entity sent = ...(0,entity);
            int sf = ...(1,int);
            if ( sent.classname == "minigame_player" && (sf & TTT_SF_PLAYERSCORE ) )
            {
                WriteByte(MSG_ENTITY,sent.minigame_flags);
            }
            else if ( sent.classname == "minigame" && (sf & TTT_SF_SINGLEPLAYER) )
            {
                WriteByte(MSG_ENTITY,sent.ttt_ai);
            }
            return false;
        }
    }
 
    return false;
}

References argv(), entity(), findentity(), int, minigame_count_players(), minigame_next_team(), MSG_ENTITY, NULL, owner, strfree, string_null, ttt_move(), ttt_next_match(), TTT_SF_PLAYERSCORE, TTT_SF_SINGLEPLAYER, TTT_SPECTATOR_TEAM, TTT_TURN_PLACE, TTT_TURN_TEAM1, and WriteByte().

ttt_valid_tile()

bool ttt_valid_tile

(

string

tile

)

Definition at line 70 of file ttt.qc.

{
    if ( !tile )
        return 0;
    int number = minigame_tile_number(tile);
    int letter = minigame_tile_letter(tile);
    return 0 <= number && number < TTT_NUM_CNT && 0 <= letter && letter < TTT_LET_CNT;
}

References minigame_tile_letter(), minigame_tile_number(), number, TTT_LET_CNT, and TTT_NUM_CNT.

Referenced by ttt_move().

ttt_winning_piece()

bool ttt_winning_piece

(

entity

piece

)

Definition at line 39 of file ttt.qc.

{
    int number = minigame_tile_number(piece.netname);
    int letter = minigame_tile_letter(piece.netname);
 
    if ( ttt_find_piece(piece.owner,minigame_tile_buildname(0,number)).team == piece.team )
    if ( ttt_find_piece(piece.owner,minigame_tile_buildname(1,number)).team == piece.team )
    if ( ttt_find_piece(piece.owner,minigame_tile_buildname(2,number)).team == piece.team )
        return true;
 
    if ( ttt_find_piece(piece.owner,minigame_tile_buildname(letter,0)).team == piece.team )
    if ( ttt_find_piece(piece.owner,minigame_tile_buildname(letter,1)).team == piece.team )
    if ( ttt_find_piece(piece.owner,minigame_tile_buildname(letter,2)).team == piece.team )
        return true;
 
    if ( number == letter )
    if ( ttt_find_piece(piece.owner,minigame_tile_buildname(0,0)).team == piece.team )
    if ( ttt_find_piece(piece.owner,minigame_tile_buildname(1,1)).team == piece.team )
    if ( ttt_find_piece(piece.owner,minigame_tile_buildname(2,2)).team == piece.team )
        return true;
 
    if ( number == 2-letter )
    if ( ttt_find_piece(piece.owner,minigame_tile_buildname(0,2)).team == piece.team )
    if ( ttt_find_piece(piece.owner,minigame_tile_buildname(1,1)).team == piece.team )
    if ( ttt_find_piece(piece.owner,minigame_tile_buildname(2,0)).team == piece.team )
        return true;
 
    return false;
}

References entity(), minigame_tile_buildname(), minigame_tile_letter(), minigame_tile_number(), number, team, and ttt_find_piece().

Referenced by ttt_move().

Variable Documentation

ttt_ai

int ttt_ai

Definition at line 26 of file ttt.qc.

TTT_LET_CNT

const int TTT_LET_CNT = 3

Definition at line 20 of file ttt.qc.

Referenced by ttt_move(), and ttt_valid_tile().

ttt_nexteam

int ttt_nexteam

Definition at line 25 of file ttt.qc.

ttt_npieces

int ttt_npieces

Definition at line 24 of file ttt.qc.

TTT_NUM_CNT

const int TTT_NUM_CNT = 3

Definition at line 21 of file ttt.qc.

Referenced by ttt_move(), and ttt_valid_tile().

TTT_SF_PLAYERSCORE

const int TTT_SF_PLAYERSCORE = MINIG_SF_CUSTOM

Definition at line 15 of file ttt.qc.

Referenced by ttt_move(), and ttt_server_event().

TTT_SF_SINGLEPLAYER

const int TTT_SF_SINGLEPLAYER = MINIG_SF_CUSTOM<<1

Definition at line 16 of file ttt.qc.

Referenced by ttt_server_event().

TTT_SPECTATOR_TEAM

const int TTT_SPECTATOR_TEAM = 255

Definition at line 18 of file ttt.qc.

Referenced by ttt_server_event().

TTT_TILE_SIZE

const int TTT_TILE_SIZE = 3

Definition at line 22 of file ttt.qc.

TTT_TURN_DRAW

const int TTT_TURN_DRAW = 0x0400

Definition at line 6 of file ttt.qc.

Referenced by ttt_move(), and ttt_next_match().

TTT_TURN_NEXT

const int TTT_TURN_NEXT = 0x0800

Definition at line 7 of file ttt.qc.

Referenced by ttt_next_match().

TTT_TURN_PLACE

const int TTT_TURN_PLACE = 0x0100

Definition at line 4 of file ttt.qc.

Referenced by ttt_move(), ttt_next_match(), and ttt_server_event().

TTT_TURN_TEAM

const int TTT_TURN_TEAM = 0x000f

Definition at line 12 of file ttt.qc.

Referenced by ttt_move().

TTT_TURN_TEAM1

const int TTT_TURN_TEAM1 = 0x0001

Definition at line 10 of file ttt.qc.

Referenced by ttt_server_event().

TTT_TURN_TEAM2

const int TTT_TURN_TEAM2 = 0x0002

Definition at line 11 of file ttt.qc.

TTT_TURN_TYPE

const int TTT_TURN_TYPE = 0x0f00

Definition at line 8 of file ttt.qc.

TTT_TURN_WIN

const int TTT_TURN_WIN = 0x0200

Definition at line 5 of file ttt.qc.

Referenced by ttt_move(), and ttt_next_match().