ps.qc File Reference

#include "ps.qh"

Include dependency graph for ps.qc:

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

Go to the source code of this file.

Functions
bool	ps_draw (entity minigame)
entity	ps_find_piece (entity minig, string tile)
void	ps_move (entity minigame, entity player, string thepiece, string pos)
bool	ps_move_piece (entity minigame, entity piece, string pos, int leti, int numb)
int	ps_server_event (entity minigame, string event,...)
void	ps_setup_pieces (entity minigame)
bool	ps_tile_blacklisted (string tile)
bool	ps_valid_tile (string tile)
bool	ps_winning_piece (entity minigame)
	REGISTER_MINIGAME (ps, _("Peg Solitaire"))

Variables
const int	PS_LET_CNT = 7
const int	PS_NUM_CNT = 7
const int	PS_SPECTATOR_TEAM = 255
const int	PS_TILE_SIZE = 8
const float	PS_TURN_DRAW = 0x0400
const float	PS_TURN_MOVE = 0x0100
const float	PS_TURN_TYPE = 0x0f00
const float	PS_TURN_WIN = 0x0200

Function Documentation

ps_draw()

bool ps_draw

(

entity

minigame

)

Definition at line 26 of file ps.qc.

{
    entity e = NULL;
    while( ( e = findentity(e,owner,minigame) ) )
        if( e.classname == "minigame_board_piece" )
        {
            return true;
        }
 
    return false;
}

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

Referenced by ps_move().

ps_find_piece()

entity ps_find_piece	(	entity	minig,
		string	tile )

Definition at line 17 of file ps.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 ps_move(), ps_move_piece(), and ps_winning_piece().

ps_move()

void ps_move	(	entity	minigame,
		entity	player,
		string	thepiece,
		string	pos )

Definition at line 158 of file ps.qc.

{
    if ( (minigame.minigame_flags & PS_TURN_MOVE) )
    if ( pos )
    {
        if ( ps_valid_tile(pos) )
        if ( !ps_find_piece(minigame, pos) && ps_find_piece(minigame, thepiece) )
        {
            entity piece = ps_find_piece(minigame, thepiece);
            int number = minigame_tile_number(thepiece);
            int letter = minigame_tile_letter(thepiece);
            bool done = false;
            string try;
 
            try = minigame_tile_buildname(letter-1,number);
            if(ps_find_piece(minigame,try))
            {
                try = minigame_tile_buildname(letter-2,number);
                if(ps_valid_tile(try) && try == pos)
                    done = ps_move_piece(minigame, piece, pos, letter - 1, number);
            }
            try = minigame_tile_buildname(letter+1,number);
            if(!done && ps_find_piece(minigame,try))
            {
                try = minigame_tile_buildname(letter+2,number);
                if(ps_valid_tile(try) && try == pos)
                    done = ps_move_piece(minigame, piece, pos, letter + 1, number);
            }
            try = minigame_tile_buildname(letter,number-1);
            if(!done && ps_find_piece(minigame,try))
            {
                try = minigame_tile_buildname(letter,number-2);
                if(ps_valid_tile(try) && try == pos)
                    done = ps_move_piece(minigame, piece, pos, letter, number - 1);
            }
            try = minigame_tile_buildname(letter,number+1);
            if(!done && ps_find_piece(minigame,try))
            {
                try = minigame_tile_buildname(letter,number+2);
                if(ps_valid_tile(try) && try == pos)
                    done = ps_move_piece(minigame, piece, pos, letter, number + 1);
            }
 
            if(!done)
                return; // didn't make a move
 
            minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
 
            if ( ps_winning_piece(minigame) )
            {
                if(ps_draw(minigame))
                    minigame.minigame_flags = PS_TURN_DRAW;
                else
                    minigame.minigame_flags = PS_TURN_WIN;
            }
            else
                minigame.minigame_flags = PS_TURN_MOVE;
        }
    }
}

References entity(), MINIG_SF_UPDATE, minigame_server_sendflags(), minigame_tile_buildname(), minigame_tile_letter(), minigame_tile_number(), number, ps_draw(), ps_find_piece(), ps_move_piece(), PS_TURN_DRAW, PS_TURN_MOVE, PS_TURN_WIN, ps_valid_tile(), and ps_winning_piece().

Referenced by ps_server_event().

ps_move_piece()

bool ps_move_piece	(	entity	minigame,
		entity	piece,
		string	pos,
		int	leti,
		int	numb )

Definition at line 137 of file ps.qc.

{
    if(!piece)
        return false;
    if(ps_find_piece(minigame, pos))
        return false;
    entity middle = ps_find_piece(minigame, minigame_tile_buildname(leti,numb));
    if(!middle)
        return false;
 
    strfree(middle.netname);
    delete(middle);
 
    strcpy(piece.netname, pos);
 
    minigame_server_sendflags(piece,MINIG_SF_ALL);
 
    return true;
}

References entity(), MINIG_SF_ALL, minigame_server_sendflags(), minigame_tile_buildname(), ps_find_piece(), strcpy, and strfree.

Referenced by ps_move().

ps_server_event()

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

Definition at line 223 of file ps.qc.

{
    switch(event)
    {
        case "start":
        {
            ps_setup_pieces(minigame);
            minigame.minigame_flags = PS_TURN_MOVE;
            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 more than 1 player
            if(pl_num >= 1) { return PS_SPECTATOR_TEAM; }
 
            // Team 1 by default
            return 1;
        }
        case "cmd":
        {
            entity player = ...(0,entity);
            bool event_blocked = (player.team == PS_SPECTATOR_TEAM);
            switch(argv(0))
            {
                case "move":
                    if(event_blocked)
                        return true;
                    ps_move(minigame, ...(0,entity), (...(1,int) == 3 ? argv(1) : string_null), (...(1,int) == 3 ? argv(2) : string_null));
                    return true;
            }
 
            return false;
        }
    }
 
    return false;
}

References argv(), entity(), findentity(), minigame_count_players(), NULL, owner, ps_move(), ps_setup_pieces(), PS_SPECTATOR_TEAM, PS_TURN_MOVE, strfree, and string_null.

ps_setup_pieces()

void ps_setup_pieces

(

entity

minigame

)

Definition at line 117 of file ps.qc.

{
    int i, t;
    for(i = 0; i < PS_NUM_CNT; ++i)
    for(t = 0; t < PS_LET_CNT; ++t)
    {
        string try = minigame_tile_buildname(i,t);
        if(!ps_valid_tile(try))
            continue;
        if(i == floor(PS_NUM_CNT * 0.5) && t == floor(PS_LET_CNT * 0.5))
            continue; // middle piece is empty
        entity piece = msle_spawn(minigame,new(minigame_board_piece));
        piece.team = 1; // init default team?
        piece.netname = strzone(minigame_tile_buildname(t,i));
        minigame_server_sendflags(piece,MINIG_SF_ALL);
    }
 
    minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
}

References entity(), floor(), MINIG_SF_ALL, MINIG_SF_UPDATE, minigame_server_sendflags(), minigame_tile_buildname(), msle_spawn(), PS_LET_CNT, PS_NUM_CNT, ps_valid_tile(), and strzone().

Referenced by ps_server_event().

ps_tile_blacklisted()

bool ps_tile_blacklisted

(

string

tile

)

Definition at line 38 of file ps.qc.

{
    int number = minigame_tile_number(tile);
    int letter = minigame_tile_letter(tile);
    if(letter < 2)
    {
        if(number < 2)
            return true;
        else if(number > PS_NUM_CNT - 3)
            return true;
    }
    if(letter > PS_LET_CNT - 3)
    {
        if(number < 2)
            return true;
        else if(number > PS_NUM_CNT - 3)
            return true;
    }
 
    return false;
}

References minigame_tile_letter(), minigame_tile_number(), number, PS_LET_CNT, and PS_NUM_CNT.

Referenced by ps_valid_tile().

ps_valid_tile()

bool ps_valid_tile

(

string

tile

)

Definition at line 61 of file ps.qc.

{
    if ( !tile )
        return false;
    if(ps_tile_blacklisted(tile))
        return false;
    float number = minigame_tile_number(tile);
    float letter = minigame_tile_letter(tile);
    return 0 <= number && number < PS_NUM_CNT && 0 <= letter && letter < PS_LET_CNT;
}

References minigame_tile_letter(), minigame_tile_number(), number, PS_LET_CNT, PS_NUM_CNT, and ps_tile_blacklisted().

Referenced by ps_move(), ps_setup_pieces(), and ps_winning_piece().

ps_winning_piece()

bool ps_winning_piece

(

entity

minigame

)

Definition at line 73 of file ps.qc.

{
    //int number = minigame_tile_number(piece.netname);
    //int letter = minigame_tile_letter(piece.netname);
 
    entity e = NULL;
    while ( ( e = findentity(e,owner,minigame) ) )
        if ( e.classname == "minigame_board_piece" )
        {
            int number = minigame_tile_number(e.netname);
            int letter = minigame_tile_letter(e.netname);
            string try = minigame_tile_buildname(letter - 1, number);
            if(ps_find_piece(minigame,try))
            {
                try = minigame_tile_buildname(letter - 2, number);
                if(ps_valid_tile(try) && !ps_find_piece(minigame,try))
                    return false; // a move is valid, abort!
            }
            try = minigame_tile_buildname(letter + 1, number);
            if(ps_find_piece(minigame,try))
            {
                try = minigame_tile_buildname(letter + 2, number);
                if(ps_valid_tile(try) && !ps_find_piece(minigame,try))
                    return false; // a move is valid, abort!
            }
            try = minigame_tile_buildname(letter, number - 1);
            if(ps_find_piece(minigame,try))
            {
                try = minigame_tile_buildname(letter, number - 2);
                if(ps_valid_tile(try) && !ps_find_piece(minigame,try))
                    return false; // a move is valid, abort!
            }
            try = minigame_tile_buildname(letter, number + 1);
            if(ps_find_piece(minigame,try))
            {
                try = minigame_tile_buildname(letter, number + 2);
                if(ps_valid_tile(try) && !ps_find_piece(minigame,try))
                    return false; // a move is valid, abort!
            }
        }
 
    return true;
}

References entity(), findentity(), minigame_tile_buildname(), minigame_tile_letter(), minigame_tile_number(), NULL, number, owner, ps_find_piece(), and ps_valid_tile().

Referenced by ps_move().

REGISTER_MINIGAME()

REGISTER_MINIGAME	(	ps	,
		_("Peg Solitaire")	)

Variable Documentation

PS_LET_CNT

const int PS_LET_CNT = 7

Definition at line 11 of file ps.qc.

Referenced by ps_setup_pieces(), ps_tile_blacklisted(), and ps_valid_tile().

PS_NUM_CNT

const int PS_NUM_CNT = 7

Definition at line 12 of file ps.qc.

Referenced by ps_setup_pieces(), ps_tile_blacklisted(), and ps_valid_tile().

PS_SPECTATOR_TEAM

const int PS_SPECTATOR_TEAM = 255

Definition at line 9 of file ps.qc.

Referenced by ps_server_event().

PS_TILE_SIZE

const int PS_TILE_SIZE = 8

Definition at line 14 of file ps.qc.

PS_TURN_DRAW

const float PS_TURN_DRAW = 0x0400

Definition at line 6 of file ps.qc.

Referenced by ps_move().

PS_TURN_MOVE

const float PS_TURN_MOVE = 0x0100

Definition at line 4 of file ps.qc.

Referenced by ps_move(), and ps_server_event().

PS_TURN_TYPE

const float PS_TURN_TYPE = 0x0f00

Definition at line 7 of file ps.qc.

PS_TURN_WIN

const float PS_TURN_WIN = 0x0200

Definition at line 5 of file ps.qc.

Referenced by ps_move().