pp.qc File Reference

#include "pp.qh"

Include dependency graph for pp.qc:

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

Go to the source code of this file.

Functions
entity	pp_find_piece (entity minig, string tile)
void	pp_move (entity minigame, entity player, string pos)
void	pp_next_match (entity minigame, entity player)
int	pp_server_event (entity minigame, string event,...)
void	pp_setup_pieces (entity minigame)
bool	pp_valid_move (entity minigame, string pos)
bool	pp_valid_tile (string tile)
bool	pp_winning_piece (entity piece)
	REGISTER_MINIGAME (pp, _("Push-Pull"))

Variables
int	cnt
entity	pp_curr_piece
const int	PP_LET_CNT = 7
int	pp_nexteam
const int	PP_NUM_CNT = 7
const int	PP_SPECTATOR_TEAM = 255
int	pp_team1_score
int	pp_team2_score
const int	PP_TILE_SIZE = 7
const int	PP_TURN_DRAW = 0x0400
const int	PP_TURN_NEXT = 0x0800
const int	PP_TURN_PLACE = 0x0100
const int	PP_TURN_TEAM = 0x000f
const int	PP_TURN_TEAM1 = 0x0001
const int	PP_TURN_TEAM2 = 0x0002
const int	PP_TURN_TYPE = 0x0f00
const int	PP_TURN_WIN = 0x0200

Function Documentation

pp_find_piece()

entity pp_find_piece	(	entity	minig,
		string	tile )

Definition at line 31 of file pp.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 pp_move(), pp_valid_move(), and pp_winning_piece().

pp_move()

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

Definition at line 98 of file pp.qc.

{
    if ( minigame.minigame_flags & PP_TURN_PLACE )
    if ( pos && player.team == (minigame.minigame_flags & PP_TURN_TEAM) )
    {
        if ( pp_valid_move(minigame,pos))
        {
            entity existing = pp_find_piece(minigame,pos);
 
            if(existing && existing.team != 5)
            {
                if(existing.team == 1)
                    minigame.pp_team1_score++;
                if(existing.team == 2)
                    minigame.pp_team2_score++;
            }
 
            if(minigame.pp_curr_piece)
            {
                minigame.pp_curr_piece.cnt = 0;
                minigame.pp_curr_piece.team = 5;
                minigame_server_sendflags(minigame.pp_curr_piece,MINIG_SF_ALL);
            }
 
            if(existing)
            {
                strfree(existing.netname);
                delete(existing);
            }
 
            entity piece = msle_spawn(minigame,new(minigame_board_piece));
            piece.cnt = 1;
            piece.team = player.team; // temporary
            piece.netname = strzone(pos);
            minigame_server_sendflags(piece,MINIG_SF_ALL);
            minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
            minigame.pp_nexteam = minigame_next_team(player.team,2);
            minigame.pp_curr_piece = piece;
            if ( pp_winning_piece(piece) )
            {
                if(minigame.pp_team1_score == minigame.pp_team2_score)
                    minigame.minigame_flags = PP_TURN_DRAW;
                else
                    minigame.minigame_flags = PP_TURN_WIN | ((minigame.pp_team1_score > minigame.pp_team2_score) ? 1 : 2);
            }
            else
                minigame.minigame_flags = PP_TURN_PLACE | minigame.pp_nexteam;
        }
    }
}

References entity(), MINIG_SF_ALL, MINIG_SF_UPDATE, minigame_next_team(), minigame_server_sendflags(), msle_spawn(), pp_find_piece(), PP_TURN_DRAW, PP_TURN_PLACE, PP_TURN_TEAM, PP_TURN_WIN, pp_valid_move(), pp_winning_piece(), strfree, and strzone().

Referenced by pp_server_event().

pp_next_match()

void pp_next_match	(	entity	minigame,
		entity	player )

Definition at line 172 of file pp.qc.

{
#ifdef SVQC
    // on multiplayer matches, wait for both players to agree
    if ( minigame.minigame_flags & (PP_TURN_WIN|PP_TURN_DRAW) )
    {
        minigame.minigame_flags = PP_TURN_NEXT | player.team;
        minigame.SendFlags |= MINIG_SF_UPDATE;
    }
    else if ( (minigame.minigame_flags & PP_TURN_NEXT) &&
            !( minigame.minigame_flags & player.team ) )
#endif
    {
        minigame.minigame_flags = PP_TURN_PLACE | minigame.pp_nexteam;
        minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
        entity e = NULL;
        while ( ( e = findentity(e,owner,minigame) ) )
            if ( e.classname == "minigame_board_piece" )
                delete(e);
        minigame.pp_team1_score = 0;
        minigame.pp_team2_score = 0;
 
        pp_setup_pieces(minigame);
    }
}

References entity(), findentity(), MINIG_SF_UPDATE, minigame_server_sendflags(), NULL, owner, pp_setup_pieces(), PP_TURN_DRAW, PP_TURN_NEXT, PP_TURN_PLACE, and PP_TURN_WIN.

Referenced by pp_server_event().

pp_server_event()

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

Definition at line 202 of file pp.qc.

{
    switch(event)
    {
        case "start":
        {
            minigame.minigame_flags = (PP_TURN_PLACE | PP_TURN_TEAM1);
            pp_setup_pieces(minigame);
            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 2 players
            if(pl_num >= 2) { return PP_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 == PP_SPECTATOR_TEAM);
            switch(argv(0))
            {
                case "move":
                    if(event_blocked)
                        return true;
                    pp_move(minigame, ...(0,entity), ...(1,int) == 2 ? argv(1) : string_null );
                    return true;
                case "next":
                    if(event_blocked)
                        return true;
                    pp_next_match(minigame,...(0,entity));
                    return true;
            }
 
            return false;
        }
        case "network_send":
        {
            entity sent = ...(0,entity);
            int sf = ...(1,int);
            if ( sent.classname == "minigame" && (sf & MINIG_SF_UPDATE ) )
            {
                WriteByte(MSG_ENTITY,sent.pp_team1_score);
                WriteByte(MSG_ENTITY,sent.pp_team2_score);
            }
            else if(sent.classname == "minigame_board_piece")
                WriteByte(MSG_ENTITY,sent.cnt);
            return false;
        }
    }
 
    return false;
}

References argv(), entity(), findentity(), int, MINIG_SF_UPDATE, minigame_count_players(), minigame_next_team(), MSG_ENTITY, NULL, owner, pp_move(), pp_next_match(), pp_setup_pieces(), PP_SPECTATOR_TEAM, PP_TURN_PLACE, PP_TURN_TEAM1, strfree, string_null, and WriteByte().

pp_setup_pieces()

void pp_setup_pieces

(

entity

minigame

)

Definition at line 149 of file pp.qc.

{
    int i, t; // letter, number
    for(i = 0; i < PP_LET_CNT; ++i)
    for(t = 0; t < PP_NUM_CNT; ++t)
    {
        bool t2_true = ((i == 0 || i == 6) && t > 0 && t < 6);
        bool t1_true = (i > 0 && i < 6 && (t == 0 || t == 6));
 
        if(t1_true || t2_true)
        {
            entity piece = msle_spawn(minigame,new(minigame_board_piece));
            piece.team = ((t1_true) ? 1 : 2);
            piece.netname = strzone(minigame_tile_buildname(i,t));
            minigame_server_sendflags(piece,MINIG_SF_ALL);
            minigame_server_sendflags(minigame,MINIG_SF_UPDATE);
        }
    }
 
    minigame.pp_curr_piece = NULL;
}

References entity(), MINIG_SF_ALL, MINIG_SF_UPDATE, minigame_server_sendflags(), minigame_tile_buildname(), msle_spawn(), NULL, PP_LET_CNT, PP_NUM_CNT, and strzone().

Referenced by pp_next_match(), and pp_server_event().

pp_valid_move()

bool pp_valid_move	(	entity	minigame,
		string	pos )

Definition at line 70 of file pp.qc.

{
    if(!pp_valid_tile(pos))
        return false;
    if(pp_find_piece(minigame,pos).team == 5)
        return false;
 
    entity current = minigame.pp_curr_piece;
    if(!current)
        return true; // no current piece? allow the move anywhere
 
    int number = minigame_tile_number(pos);
    int letter = minigame_tile_letter(pos);
 
    if( (pp_find_piece(minigame,minigame_tile_buildname(letter-1,number)) == current)
    ||  (pp_find_piece(minigame,minigame_tile_buildname(letter+1,number)) == current)
    ||  (pp_find_piece(minigame,minigame_tile_buildname(letter,number-1)) == current)
    ||  (pp_find_piece(minigame,minigame_tile_buildname(letter,number+1)) == current)
    ||  (pp_find_piece(minigame,minigame_tile_buildname(letter+1,number+1)) == current)
    ||  (pp_find_piece(minigame,minigame_tile_buildname(letter-1,number-1)) == current)
    ||  (pp_find_piece(minigame,minigame_tile_buildname(letter+1,number-1)) == current)
    ||  (pp_find_piece(minigame,minigame_tile_buildname(letter-1,number+1)) == current)
    ) { return true; }
 
    return false;
}

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

Referenced by pp_move().

pp_valid_tile()

bool pp_valid_tile

(

string

tile

)

Definition at line 41 of file pp.qc.

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

References minigame_tile_letter(), minigame_tile_number(), number, PP_LET_CNT, and PP_NUM_CNT.

Referenced by pp_valid_move(), and pp_winning_piece().

pp_winning_piece()

bool pp_winning_piece

(

entity

piece

)

Definition at line 51 of file pp.qc.

{
    int number = minigame_tile_number(piece.netname);
    int letter = minigame_tile_letter(piece.netname);
 
    // here goes
    if(!pp_valid_tile(minigame_tile_buildname(letter-1,number)) || pp_find_piece(piece.owner,minigame_tile_buildname(letter-1,number)).team == 5)
    if(!pp_valid_tile(minigame_tile_buildname(letter+1,number)) || pp_find_piece(piece.owner,minigame_tile_buildname(letter+1,number)).team == 5)
    if(!pp_valid_tile(minigame_tile_buildname(letter,number-1)) || pp_find_piece(piece.owner,minigame_tile_buildname(letter,number-1)).team == 5)
    if(!pp_valid_tile(minigame_tile_buildname(letter,number+1)) || pp_find_piece(piece.owner,minigame_tile_buildname(letter,number+1)).team == 5)
    if(!pp_valid_tile(minigame_tile_buildname(letter+1,number+1)) || pp_find_piece(piece.owner,minigame_tile_buildname(letter+1,number+1)).team == 5)
    if(!pp_valid_tile(minigame_tile_buildname(letter-1,number-1)) || pp_find_piece(piece.owner,minigame_tile_buildname(letter-1,number-1)).team == 5)
    if(!pp_valid_tile(minigame_tile_buildname(letter+1,number-1)) || pp_find_piece(piece.owner,minigame_tile_buildname(letter+1,number-1)).team == 5)
    if(!pp_valid_tile(minigame_tile_buildname(letter-1,number+1)) || pp_find_piece(piece.owner,minigame_tile_buildname(letter-1,number+1)).team == 5)
        return true;
 
    return false;
}

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

Referenced by pp_move().

REGISTER_MINIGAME()

REGISTER_MINIGAME	(	pp	,
		_("Push-Pull")	)

Variable Documentation

cnt

int cnt

Definition at line 21 of file pp.qc.

pp_curr_piece

entity pp_curr_piece

Definition at line 28 of file pp.qc.

PP_LET_CNT

const int PP_LET_CNT = 7

Definition at line 16 of file pp.qc.

Referenced by pp_setup_pieces(), and pp_valid_tile().

pp_nexteam

int pp_nexteam

Definition at line 26 of file pp.qc.

PP_NUM_CNT

const int PP_NUM_CNT = 7

Definition at line 17 of file pp.qc.

Referenced by pp_setup_pieces(), and pp_valid_tile().

PP_SPECTATOR_TEAM

const int PP_SPECTATOR_TEAM = 255

Definition at line 14 of file pp.qc.

Referenced by pp_server_event().

pp_team1_score

int pp_team1_score

Definition at line 23 of file pp.qc.

pp_team2_score

int pp_team2_score

Definition at line 24 of file pp.qc.

PP_TILE_SIZE

const int PP_TILE_SIZE = 7

Definition at line 19 of file pp.qc.

PP_TURN_DRAW

const int PP_TURN_DRAW = 0x0400

Definition at line 6 of file pp.qc.

Referenced by pp_move(), and pp_next_match().

PP_TURN_NEXT

const int PP_TURN_NEXT = 0x0800

Definition at line 7 of file pp.qc.

Referenced by pp_next_match().

PP_TURN_PLACE

const int PP_TURN_PLACE = 0x0100

Definition at line 4 of file pp.qc.

Referenced by pp_move(), pp_next_match(), and pp_server_event().

PP_TURN_TEAM

const int PP_TURN_TEAM = 0x000f

Definition at line 12 of file pp.qc.

Referenced by pp_move().

PP_TURN_TEAM1

const int PP_TURN_TEAM1 = 0x0001

Definition at line 10 of file pp.qc.

Referenced by pp_server_event().

PP_TURN_TEAM2

const int PP_TURN_TEAM2 = 0x0002

Definition at line 11 of file pp.qc.

PP_TURN_TYPE

const int PP_TURN_TYPE = 0x0f00

Definition at line 8 of file pp.qc.

PP_TURN_WIN

const int PP_TURN_WIN = 0x0200

Definition at line 5 of file pp.qc.

Referenced by pp_move(), and pp_next_match().