void teamoverlay( )
{
    int votes;

    if ( match_in_progress )
    {
        G_sprint(self, 2, "%s %s\n", redtext("Teamoverlay"), OnOff(cvar("k_teamoverlay")));
        return;
    }

	// admin may turn this status alone on server...
	if ( !is_adm( self ) )
	{
		// Dont need to bother if less than 2 players
		if ( CountPlayers() < 2 )
		{
			G_sprint(self, 2, "You need at least 2 players to do this.\n");
			return;
		}
	}

	self->v.teamoverlay = !self->v.teamoverlay;

	G_bprint(2, "%s %s!%s\n", self->netname, 
			(self->v.teamoverlay ? redtext(va("votes for teamoverlay %s", OnOff(!cvar("k_teamoverlay")))) : 
							       redtext(va("withdraws %s teamoverlay vote", g_his(self)))),
			((votes = get_votes_req( OV_TEAMOVERLAY, true )) ? va(" (%d)", votes) : ""));

    vote_check_teamoverlay ();
}

//=======================================
// TG Stuff
void Eng_SGUp(  )
{
    gedict_t *sg;
//    int numupg = 0;

    for ( sg = world; (sg = trap_find( sg, FOFS( s.v.classname ), "building_sentrygun" )); )
    {
	if ( sg->s.v.weapon == 3 && sg->s.v.ammo_shells == 144 && sg->s.v.ammo_rockets == 20
	     && sg->s.v.health == sg->s.v.max_health )
	    continue;

	sg->s.v.weapon = 3;
	sg->s.v.max_health = 216;
	sg->maxammo_shells = 144;
	sg->s.v.health = sg->s.v.max_health;
	sound( sg, 3, "weapons/turrset.wav", 1, 1 );
	sg->s.v.think = ( func_t ) lvl3_sentry_stand;
	sg->s.v.skin = 2;
	G_sprint( self, 2, "You have upgraded/fixed/reloaded sentrygun\n" );
	sg->s.v.ammo_shells = 144;
	sg->s.v.ammo_rockets = 20;
	return;
    }
    G_sprint( self, 2, "no sg to upgrade\n" );
}

void ResupplySetBot()
{
        int argc;
        char    value[1024];

        argc = trap_CmdArgc();
        if( argc != 3 )
        {
                if( tf_data.botResupplyBetweenKills)
                        G_sprint( self, 2, "Bot Resupply Between Kills: On\n" );
                else
                        G_sprint( self, 2, "Bot Resupply Between Kills: Off\n" );
		return;
        }

        if( tf_data.arena_mode )
        {
                tf_data.botResupplyBetweenKills = 0;
        }else
        {
              trap_CmdArgv( 2, value, sizeof( value ) );
              if( !strcmp(value,"on") )
                      tf_data.botResupplyBetweenKills = 1;
              else
                      tf_data.botResupplyBetweenKills = 0;
        }
        if( tf_data.botResupplyBetweenKills)
                G_sprint( self, 2, "Bot Resupply Between Kills: On\n" );
        else
                G_sprint( self, 2, "Bot Resupply Between Kills: Off\n" );

}

void mctf()
{
	if( match_in_progress && !k_matchLess )
		return;

	if ( !isCTF() ) {
		G_sprint ( self, 2, "Can't do this in non CTF mode\n" );
		return;
	}

	if ( !cvar("k_ctf_hook") && !cvar("k_ctf_runes") ) {
		G_sprint ( self, 2, "Already done\n" );
		return;
	}

	cvar_fset("k_ctf_hook", 0);
	cvar_fset("k_ctf_runes", 0);

	G_sprint ( self, 2, "%s turn off: %s\n", getname(self), redtext("hook & runes") );

	// In matchless mode, toggling runes and hook normally won't do anything since match is already in progress. Call this to handle this scenario.
	if (k_matchLess)
	{
		// If a player is carrying a rune when runes are disabled, get rid of it
		if (!cvar("k_ctf_runes")) {
			gedict_t * p;
			for (p = world; (p = find_plr(p)); ) {
				p->ctf_flag -= (p->ctf_flag & (CTF_RUNE_MASK));
				p->maxspeed = cvar("sv_maxspeed"); // Reset speed, in case was carrying haste
			}
		}
		SpawnRunes( 0 );
		AddHook ( false );
	}
}

//=========================================================================
// Engineer has used a Spanner on the SentryGun
void Engineer_UseSentryGun( gedict_t * gun )
{
    gedict_t *dist_checker;

    G_sprint( self, 2, "Level %.0f Sentry Gun has %.0f health, %.0f shells",
	      gun->s.v.weapon, gun->s.v.health, gun->s.v.ammo_shells );
    if ( gun->s.v.weapon == 3 )
    {
	G_sprint( self, 2, ", %.0f rockets", gun->s.v.ammo_rockets );
    }

    if ( gun->has_sentry &&  tg_data.tg_enabled )
	G_sprint( self, 2, ", static" );

    G_sprint( self, 2, "\n" );
    self->current_menu = MENU_ENGINEER_FIX_SENTRYGUN;
    self->menu_count = MENU_REFRESH_RATE;
    self->building = gun;
    dist_checker = spawn(  );
    dist_checker->s.v.classname = "timer";
    dist_checker->s.v.owner = EDICT_TO_PROG( self );
    dist_checker->s.v.enemy = EDICT_TO_PROG( gun );
    dist_checker->s.v.think = ( func_t ) CheckDistance;
    dist_checker->s.v.nextthink = g_globalvars.time + 0.3;
}

void BotSet()
{
        char    cmd_command[50];
        int argc;

        argc = trap_CmdArgc();

        if( argc < 3 )
        {
                return;
        }
        trap_CmdArgv( 2, cmd_command, sizeof( cmd_command ) );

        if( !strncmp(cmd_command,"max_yaw_speed",sizeof(cmd_command)))
        {
                if( argc == 3 )
                        G_sprint(self,2,"max_yaw_speed = %3.0f\n",max_yaw_per_sek);
                else
                {
                        trap_CmdArgv( 3, cmd_command, sizeof( cmd_command ) );
                        max_yaw_per_sek = atof(cmd_command);
                        if( max_yaw_per_sek < 10 )
                                max_yaw_per_sek = 10;

                        G_sprint(self,2,"max_yaw_speed set to %3.0f\n",max_yaw_per_sek);
                }
        
        }
        

}

void ToggleMapLock ()
{
    float tmp;

    if( !is_adm( self ) )
        return;

    tmp = cvar( "k_lockmap" );

    if( tmp )
    {
		cvar_fset( "k_lockmap", 0 );

        if( !match_in_progress )
            G_bprint(2, "%s unlocks map\n", self->netname);
        else
            G_sprint(self, 2, "Map unlocked\n");

        return;
    }

	cvar_fset( "k_lockmap", 1 );

    if( !match_in_progress )
        G_bprint(2, "%s locks map\n", self->netname);
    else
        G_sprint(self, 2, "Map is locked\n");
}

void TeamFortress_TeamShowMemberClasses( gedict_t * Player )
{
	gedict_t *e;
	int     found = 0;

	found = 0;

	for ( e = world; ( e = trap_find( e, FOFS( s.v.classname ), "player" ) ); )
	{
		if ( ( e->team_no == Player->team_no || !e->team_no ) && e != Player )
		{
			if ( e->s.v.model && e->s.v.model[0] )
			{
				if ( !found )
				{
					found = 1;
					G_sprint( Player, 2, "The other members of your team are:\n" );
				}
				G_sprint( Player, 2, "%s : ", e->s.v.netname );
				TeamFortress_PrintClassName( Player, e->playerclass, e->tfstate & 8 );
			}
		}
	}
	if ( !found )
		G_sprint( Player, 2, "There are no other players on your team.\n" );
}

qbool DoKick(gedict_t *victim, gedict_t *kicker)
{
	if (!victim || !kicker)
		return false;

	if( victim == kicker )
	{
		G_bprint(2, "%s kicked %s\n", getname(kicker), g_himself( kicker ));

		// hehe
		G_sprint(kicker, 2, "Say \"bye\" and then type \"disconnect\" next time\n");

		stuffcmd(kicker, "disconnect\n");  // FIXME: stupid way

		if ( !FTE_sv )
			localcmd( "addip %s ban +30\n", cl_ip( victim ) ); // BAN for 30 seconds
	}
	else
	{
		if ( !is_can_kick(victim, kicker) )
			return false;

		G_bprint(2, "%s was kicked by %s\n", getname(victim), getname(kicker));

		G_sprint(victim, 2, "You were kicked from the server\n");

		stuffcmd(victim, "disconnect\n"); // FIXME: stupid way

		if ( !FTE_sv )
			localcmd( "addip %s ban +30\n", cl_ip( victim ) ); // BAN for 30 seconds
	}

	return true;
}

void antilag( )
{
    int votes;
	
	if ( match_in_progress )
	{
        G_sprint(self, 2, "%s mode %s\n", redtext("Antilag"), OnOff(2 == cvar("sv_antilag")));
        return;
	}

	// admin may turn this status alone on server...
	if ( !is_adm( self ) )
	{
		// Dont need to bother if less than 2 players
		if ( CountPlayers() < 2 )
		{
			G_sprint(self, 2, "You need at least 2 players to do this.\n");
			return;
		}
	}

	self->v.antilag = !self->v.antilag;

	G_bprint(2, "%s %s!%s\n", self->s.v.netname, 
			(self->v.antilag ? redtext(va("votes for antilag %s", OnOff(!(2 == cvar("sv_antilag"))))) : 
							   redtext(va("withdraws %s antilag vote", g_his(self)))),
			((votes = get_votes_req( OV_ANTILAG, true )) ? va(" (%d)", votes) : ""));

	vote_check_antilag ();
}

void VoteYes()
{
	int votes;

	if( !get_votes( OV_ELECT ) )
		return;

	if( self->v.elect_type != etNone ) {
		G_sprint(self, 2, "You cannot vote for yourself\n");
		return;
	}

	if( self->v.elect ) {
		G_sprint(self, 2, "--- your vote is still good ---\n");
		return;
	}

// register the vote
	self->v.elect = 1;

	G_bprint(2, "%s gives %s vote\n", self->s.v.netname, g_his( self ));

// calculate how many more votes are needed
	if ( (votes = get_votes_req( OV_ELECT, true )) )
		G_bprint(2, "\x90%d\x91 more vote%s needed\n", votes, count_s( votes ));

	vote_check_elect ();
}

void nospecs( )
{
    int votes;
	
	if ( match_in_progress )
	{
        G_sprint(self, 2, "%s mode %s\n", redtext("No spectators"), OnOff(cvar("_k_nospecs")));
        return;
	}

	// admin may turn this status alone on server...
	if ( !is_adm( self ) )
	{
		// Dont need to bother if less than 2 players
		if ( CountPlayers() < 2 )
		{
			G_sprint(self, 2, "You need at least 2 players to do this.\n");
			return;
		}
	}

	self->v.nospecs = !self->v.nospecs;

	G_bprint(2, "%s %s!%s\n", self->s.v.netname, 
			(self->v.nospecs ? redtext(va("votes for nospecs %s", OnOff(!cvar("_k_nospecs")))) : 
							   redtext(va("withdraws %s nospecs vote", g_his(self)))),
			((votes = get_votes_req( OV_NOSPECS, true )) ? va(" (%d)", votes) : ""));

	vote_check_nospecs ();
}

void NextClient ()
{
	int from = 0;

	if( !self->k_kicking )
		return;

	self->k_playertokick = (self->k_playertokick ? self->k_playertokick : world);
	from = ( self->k_playertokick != world && self->k_playertokick->ct == ctSpec );
	self->k_playertokick = find_plrspc(self->k_playertokick, &from);

	if ( !self->k_playertokick ) {  // try find anyone at least
		from = 0;
		self->k_playertokick = find_plrspc(world, &from);
	}

	if ( !self->k_playertokick ) {
		G_sprint(self, 2, "Can't find anybody to kick\n");
		ExitKick ( self );
		return;
	}

    G_sprint(self, 2, "Kick %s %s?\n", 
					redtext(self->k_playertokick->ct == ctPlayer ? "player" : "spectator"),	getname(self->k_playertokick));
}

void Vote_Cmd()
{
        char    cmd_command[50];
        int argc,i;
        const vote_t*ucmd;

	if ( tf_data.cb_prematch_time > g_globalvars.time )
	{
		return;
	}

	argc = trap_CmdArgc();
	
	if( argc != 2 )
	{
	        G_sprint( self, 2, "Avaliable votes:\n");
		for ( ucmd = votes ; ucmd->command  ; ucmd++ )
		{
			G_sprint( self, 2, "%s\n",ucmd->command);
		}
		return;
	}

	trap_CmdArgv( 1, cmd_command, sizeof( cmd_command ) );
	if( current_vote != -1 )
	{
		if(!strcmp(cmd_command,"yes"))
		{
		        votes[current_vote].VoteYes();
			return;
		}

		if(!strcmp(cmd_command,"no"))
		{
		        votes[current_vote].VoteNo();
			return;
		}
		G_sprint( self, 2, "Vote %s in progress\n",votes[current_vote].command);
	        return;
	}
	if( g_globalvars.time < self->last_vote_time )
	{
		G_sprint( self, 2, "You cannot vote at this time.\n");
		return;
	}
	for ( ucmd = votes,i=0 ; ucmd->command  ; ucmd++,i++ )
	{
		if( !strcmp(cmd_command,ucmd->command) )
		{
		        current_vote = i;
		        self->last_vote_time = g_globalvars.time + votes[current_vote].pause * 60;
			ucmd->VoteInit();
			return;
		}
	}
	G_sprint( self, 2, "Unknown vote.\n");
}

//=========================================================================
// If its a net game, the SPY goes invisible.
// If its a LAN game, the class/skin changing menu pops up.
void TeamFortress_SpyGoUndercover(  )
{
	gedict_t *te;


	if ( tf_data.invis_only == 1 )
	{
	        // If the spy is already invisible, become visible
		if ( ( int ) self->s.v.effects & ( EF_DIMLIGHT | EF_BRIGHTLIGHT ) )
		{
			G_sprint( self, 1, "You cannot disguise while glowing.\n" );
			return;
		}
		if ( self->is_unabletospy == 1 )
		{
			G_sprint( self, 2, "You can't go undercover right now.\n" );
			return;
		}
		if ( self->is_undercover == 1 )
		{
			self->is_undercover = 0;
			self->s.v.modelindex = modelindex_player; // return to normal
			self->s.v.items = ( int ) self->s.v.items - ( ( int ) self->s.v.items & IT_INVISIBILITY );
		} else
		{
			if ( self->is_undercover == 2 )
			{
				G_sprint( self, 2, "You stop going undercover.\n" );
				self->is_undercover = 0;
			} else
			{
				if ( self->s.v.ammo_cells > 1 )
				{
					G_sprint( self, 2, "Going undercover...\n" );
					self->is_undercover = 2;
					te = spawn(  );
					te->s.v.classname = "timer";
					te->s.v.owner = EDICT_TO_PROG( self );
					te->s.v.think = ( func_t ) TeamFortress_SpyUndercoverThink;
					te->s.v.nextthink = g_globalvars.time + .01;
				}
			}
		}
		self->StatusRefreshTime = g_globalvars.time + 0.1;
	} else
	{
		if ( self->is_undercover != 2 )
		{
			self->current_menu = MENU_SPY;
			self->menu_count = MENU_REFRESH_RATE;
		} else
		{
			G_sprint( self, 2, "You stop going undercover.\n" );
			self->is_undercover = 0;
		}
	}
}

void Vote_Elect_Init()
{
	int f1;
	int needed_votes;
	gedict_t* voteguard;

	elect_percentage = GetSVInfokeyInt(  "electpercentage", NULL, 50 );
	elect_level  = GetSVInfokeyInt(  "electlevel", NULL, 1 );
	elect_player = self;
	if(!elect_percentage || !elect_level)
	{
		G_sprint( self, 2, "Admin election disabled\n",self->s.v.netname);
		return;
	}

	if ( self->is_admin >= elect_level ) 
	{
		G_sprint(self, 2, "You are already an admin\n");
		return;
	}

	if( elect_percentage < 5 || elect_percentage > 95)
		elect_percentage = 50;

	f1 = CountPlayers();
	
	if(  elect_percentage * f1 < 100 ) 
	{
		G_bprint(2,  "%s ηαιξσ αδνιξ στατυσ!\n", elect_player->s.v.netname);
		G_sprint(elect_player, 2, "Type γνδ αδνιξ for admin commands.\n");
		current_vote = -1;
		elect_player->is_admin = elect_level;
		return;	
	}

	
	G_bprint(2, "%s has requested admin rights!\n",self->s.v.netname);

	k_vote = 1;
	self->k_voted = 1;
	needed_votes = (int)(f1 * elect_percentage / 100)+1 - k_vote;

	if( needed_votes > 1 )
		G_bprint(2, "%d‘ total votes needed\nType ",needed_votes);
	else
		G_bprint(2, "%d‘ total vote needed\nType ", needed_votes);

	G_bprint(3, "γνδ φοτε ωεσ");
	G_bprint(2, " in console to approve\n");

	voteguard = spawn(); // Check the 1 minute timeout for voting
	voteguard->s.v.owner = EDICT_TO_PROG(world);
	voteguard->s.v.classname  = "voteguard";
	voteguard->s.v.think = (func_t) VoteThink;
	voteguard->s.v.nextthink = g_globalvars.time + votes[current_vote].timeout;
}

// Throw Toaster
void Toaster ( )
{
	gedict_t *missile;
	if ( self->no_grenades_2 < 2 ) {
		G_sprint( self, 1, "Not enough type 2 grenades... get more\n" );
		return;
	}
	if (!tf_data.drop2)
	{
		G_sprint (self, 2, "Toasters have been disabled by the admin!\n");
		return;
	}
	self->no_grenades_2 = self->no_grenades_2 - 2;
	sound( self, CHAN_WEAPON, "misc/power.wav", 1, ATTN_NORM );
	missile = spawn(  );
	missile->s.v.owner = EDICT_TO_PROG( self );
	missile->s.v.movetype = 10;
	missile->s.v.solid = 2;
	missile->s.v.classname = "grenade";
	missile->s.v.effects = 8;

	// throw that toaster!
	makevectors( self->s.v.v_angle );
	if (self->s.v.v_angle[0]) {
		missile->s.v.velocity[0] =
		    g_globalvars.v_forward[0] * 600 + g_globalvars.v_up[0] * 200 +
		    crandom(  ) * g_globalvars.v_right[0] * 10 + crandom(  ) * g_globalvars.v_up[0] * 10;
		missile->s.v.velocity[1] =
		    g_globalvars.v_forward[1] * 600 + g_globalvars.v_up[1] * 200 +
		    crandom(  ) * g_globalvars.v_right[1] * 10 + crandom(  ) * g_globalvars.v_up[1] * 10;
		missile->s.v.velocity[2] =
		    g_globalvars.v_forward[2] * 600 + g_globalvars.v_up[2] * 200 +
		    crandom(  ) * g_globalvars.v_right[2] * 10 + crandom(  ) * g_globalvars.v_up[0] * 10;
	}
	else {
		//missile->s.v.velocity = aim(self, 10000);
		aim( self->s.v.velocity );	// = aim(self, 10000);
		missile->s.v.velocity[0] = missile->s.v.velocity[0] * 600;
		missile->s.v.velocity[1] = missile->s.v.velocity[1] * 600;
//		missile->s.v.velocity[2] = missile->s.v.velocity[2] * 600;
		missile->s.v.velocity[2] = 200;
	}
	SetVector( missile->s.v.avelocity, 300, 300, 300 );
	//missile.angles = vectoangles(missile.velocity);
	vectoangles( missile->s.v.velocity, missile->s.v.angles );
	missile->s.v.touch = ( func_t ) ToasterTouch;
	missile->s.v.nextthink = g_globalvars.time + 3;
	missile->s.v.think = ( func_t ) ToasterElec;
	setmodel( missile, "progs/v_spike.mdl" );
	setsize( missile, 0, 0, 0, 0, 0, 0 );
	setorigin( missile, self->s.v.origin[0], self->s.v.origin[1], self->s.v.origin[2]);
}

void AdminForceStart ()
{
    gedict_t *mess;

	if (match_in_progress || match_over || !is_adm(self)) {
		return;
	}

	// no forcestart in practice mode
	if ( k_practice ) {
		G_sprint(self, 2, "%s\n", redtext("Server in practice mode"));
		return;
	}

    if( self->ct == ctPlayer && !self->ready )
    {
		PlayerReady();

		if ( !self->ready ) {
        	G_sprint(self, 2, "Ready yourself first\n");
        	return;
		}
    }

	if( find(world, FOFCLSN, "mess") ) {
        G_sprint(self, 2, "forcestart already in progress!\n");
		return;
	}

	k_attendees = CountPlayers();

	if ( !isCanStart( self, true ) ) {
        G_sprint(self, 2, "Can't issue!\n");
		return;
	}

    if( k_attendees )
    {
        G_bprint(2, "%s forces matchstart!\n", self->netname);

        k_force = 1;

        mess = spawn();
        mess->classname = "mess";
        mess->s.v.owner = EDICT_TO_PROG( self );
        mess->think = ( func_t ) ReadyThink;
        mess->s.v.nextthink = g_globalvars.time + 0.1;
        mess->attack_finished = 10 + 1;
    }
    else
        G_sprint(self, 2, "Can't issue! More players needed.\n");
}

void TeamFortress_StatusQuery(  )
{

	G_sprint( self, 2, "players per team: %d %d %d %d\n",
		  TeamFortress_TeamGetNoPlayers( 1 ),
		  TeamFortress_TeamGetNoPlayers( 2 ),
		  TeamFortress_TeamGetNoPlayers( 3 ), TeamFortress_TeamGetNoPlayers( 4 ) );

	G_sprint( self, 2, "    equalisation: %.0f %.0f %.0f %.0f\n",
		  teamadvantage[1], teamadvantage[2], teamadvantage[3], teamadvantage[4] );

	G_sprint( self, 2, "Teamplay is %d\n", teamplay );
}

// pre-holo spawn
void MakeHolo ( )
{
	if ( self->playerclass == 0 )
		return;
	if ( self->has_holo != 1 )
	{
		G_sprint( self, 2, "holograph already running!\n" );
		return;
	}
	self->has_holo = 0;
	HoloDood ();
	G_sprint (self, 2, "Holographic replica active!\n" );
}