Play_network.cpp

Go to the documentation of this file.

#include "Play.h"

void Play::networkLoop() {
        unsigned int i;

        GE_PlayerJoined *ge_playerJoined = NULL;
        GE_Attack *ge_attack = NULL;
        GE_PlayerPos *ge_playerPos = NULL;
        GE_State *ge_state = NULL;
        GE_PlayerAction *ge_playerAction = NULL;
        GE_PlayerDeath *ge_playerDeath = NULL;
        GE_PlayerScore *ge_playerScore = NULL;
        GE_PlayerDisconnected *ge_playerDisconnected = NULL;
        GE_PlayerExtras *ge_playerExtras = NULL;
        GE_DealExtras *ge_dealExtras = NULL;

        //Player *p;
        int playerID;
        int type;

        float dist;

        //-----------------------------------------------------------------##
        // Network event handler
        //-----------------------------------------------------------------##
        while (i = gne->nextEventPending()) {
                //console.addEx(Vec3(1.0f, 1.0f, 1.0f), "Event pending [%d]", i);

                switch(i) {
                        //-----------------------------------------------------------------#
                        // Player joined (this will not be here but in the menu instead)
                        //-----------------------------------------------------------------#
                        //-----------------------------------------------------------------#
                        // Player disconnected!
                        //-----------------------------------------------------------------#
                        case E_PLAYER_DISCONNECTED:
                                ge_playerDisconnected = (GE_PlayerDisconnected *)gne->getNextEvent();
                                playerID = ge_playerDisconnected->getId();
                                console.addEx(Vec3(1.0f, 0.0f, 0.0f), "'%s' disconnected!", g_players[playerID].name);
                                g_players[playerID].state = PLAYER_STATE_OFFLINE;

                                if (ge_playerDisconnected) delete ge_playerDisconnected;
                                break;

                        //-----------------------------------------------------------------#
                        // Attack
                        //-----------------------------------------------------------------#
                        case E_ATTACK:
                                ge_attack = (GE_Attack *)gne->getNextEvent();
                                type = ge_attack->getAttackType();
                                if (type == WEAPON_GRENADE) {
                                        throwGrenade(ge_attack->getId(), ge_attack->getPos(), ge_attack->getDir(), 3.0f, 1.0f);
                                }
                                else {
                                        SWeapon weapon;
                                        Weapon::set(weapon, type);
                                        fireProjectile(ge_attack->getId(), ge_attack->getPos(), ge_attack->getDir(), weapon.power);
                                }

                                if (ge_attack) delete ge_attack;
                                break;

                        //-----------------------------------------------------------------#
                        // Player position
                        //-----------------------------------------------------------------#
                        case E_PLAYER_POS:
                                ge_playerPos = (GE_PlayerPos *)gne->getNextEvent();
                                playerID = ge_playerPos->getId();
                                g_players[playerID].rotation = ge_playerPos->getRotation();
                                g_players[playerID].moving = ge_playerPos->getMove();

                                if (g_players[playerID].rotation == PLAYER_ROTATION_NONE || g_players[playerID].moving == PLAYER_MOVING_NONE) {
                                        g_players[playerID].angle = ge_playerPos->getAngle();
                                        g_players[playerID].pos = Vec3(ge_playerPos->getX(), 0.0f, ge_playerPos->getY());
                                }

                                if (playerID == g_myPlayerID)
                                        setPlayerCam(g_myPlayerID);

                                if (ge_playerPos) delete ge_playerPos;
                                break;

                        //-----------------------------------------------------------------#
                        // Player state
                        //-----------------------------------------------------------------#
                        case E_PLAYER_STATE:
                                ge_state = (GE_State *)gne->getNextEvent();
                                playerID = ge_state->getId();
                                g_players[playerID].state = ge_state->getState();

                                if (ge_state) delete ge_state;
                                break;

                        //-----------------------------------------------------------------#
                        // Player MDK (killed by onother player)
                        //-----------------------------------------------------------------#
                        case E_PLAYER_DEATH:
                                ge_playerDeath = (GE_PlayerDeath *)gne->getNextEvent();
                                playerID = ge_playerDeath->getId();
                                type = ge_playerDeath->getKillerID();

                                g_players[playerID].state = PLAYER_STATE_INVISIBLE;

                                dist = (g_players[g_myPlayerID].pos - g_players[playerID].pos).length();
                                if (dist < 1.0f) dist = 1.0f;

                                m_sounds[PLAY_SOUND_DEATH].play((int)255/dist);

                                this->createExplosion(g_players[playerID].pos, 1.5f, false);

                                if (type == playerID) {
                                        g_players[playerID].frags--;
                                        g_players[playerID].deaths++;

                                        console.addEx(Vec3(0.0f, 1.0f, 1.0f), "'%s' got tired of life", g_players[playerID].name);
                                }
                                else {
                                        g_players[type].frags++;
                                        g_players[type].kills++;
                                        g_players[playerID].deaths++;

                                        console.addEx(Vec3(0.0f, 1.0f, 1.0f), "'%s' killed by '%s'", g_players[playerID].name, g_players[type].name);
                                }

                                if (gne->isServer()) {  // server
                                        g_players[playerID].spawnTime = g_time + 2000.0f;

                                        gne->setPlayerScore(playerID, g_players[playerID].frags, g_players[playerID].kills, g_players[playerID].deaths);
                                        gne->setPlayerScore(type, g_players[type].frags, g_players[type].kills, g_players[type].deaths);
                                }

                                if (ge_playerDeath) delete ge_playerDeath;

                                break;

                        //-----------------------------------------------------------------#
                        // Player score
                        //-----------------------------------------------------------------#
                        case E_PLAYER_SCORE:
                                ge_playerScore = (GE_PlayerScore *)gne->getNextEvent();
                                playerID = ge_playerScore->getId();
                                g_players[playerID].frags = ge_playerScore->getFrags();
                                g_players[playerID].kills = ge_playerScore->getKills();
                                g_players[playerID].deaths = ge_playerScore->getDeaths();

                                if (ge_playerScore) delete ge_playerScore;
                                break;

                        //-----------------------------------------------------------------#
                        // Deal extras
                        //-----------------------------------------------------------------#
                        case E_DEAL_EXTRAS:
                                ge_dealExtras = (GE_DealExtras *)gne->getNextEvent();
                                type = ge_dealExtras->getDEType();

                                // add
                                if (ge_dealExtras->getFlag() != 0) {
                                        newExtras(type, ge_dealExtras->getX(), ge_dealExtras->getY());
                                        //console.addEx(Vec3(0.0f, 1.0f, 1.0f), "New type %d extras", ge_dealExtras->getDEType());
                                }
                                // remove
                                else {
                                        float x = ge_dealExtras->getX();
                                        float z = ge_dealExtras->getY();
                                        Vec3 v(x, 0.0f, z);
                                        float dist;

                                        for (i=0; i<PLAY_EXTRAS_SIMULTANEOUS; i++) {
                                                if (m_extras[i].type == type) {
                                                        dist = (m_extras[i].pos - v).length();
                                                        if (dist < 0.01f) {
                                                                m_extras[i].type = PLAY_EXTRAS_NONE;
                                                                //console.addEx(Vec3(0.0f, 1.0f, 0.0f), "Removed type %d extras", ge_dealExtras->getDEType());
                                                                break;
                                                        }
                                                }
                                        }
                                }

                                if (ge_dealExtras) delete ge_dealExtras;
                                break;

                        //-----------------------------------------------------------------#
                        // Extras
                        //-----------------------------------------------------------------#
                        case E_PLAYER_EXTRAS:
                                ge_playerExtras = (GE_PlayerExtras *)gne->getNextEvent();
                                playerID = ge_playerExtras->getId();

                                //------------------------------
                                // START GAME
                                //------------------------------
                                if (playerID == PLAY_NET_START_GAME) {
                                        g_gameInfo.gameState = GAME_STATE_RUNNING;
                                        //g_players[g_myPlayerID].state = PLAYER_STATE_INVISIBLE;

                                        m_timeStart = g_time;
                                        m_timeEnd = m_timeStart + 300000.0f;    // 5 min matches

                                        // set spawn time (on server)
                                        if (gne->isServer()) {
                                                for (i=0; i<SPLAYER_MAX_PLAYERS; i++) {
                                                        if (g_players[i].state == PLAYER_STATE_READY) {
                                                                g_players[i].state = PLAYER_STATE_INVISIBLE;
                                                                g_players[i].spawnTime = g_time + 500.0f + (float)RANDOM_NUM*250.0f;
                                                        }
                                                }
                                        }

                                }
                                //------------------------------
                                // GAME OVER
                                //------------------------------
                                else if (playerID == PLAY_NET_GAME_OVER) {
                                        g_gameInfo.gameState = GAME_STATE_GAME_OVER;
                                        m_timeEnd = g_time;
                                        //g_players[g_myPlayerID].state = PLAYER_STATE_INVISIBLE;

                                        //console.addEx(Vec3(0.0f, 0.0f, 1.0f), "Game Over!");
                                        //g_selectedScene = SCENE_SCORES;
                                }
                                //------------------------------
                                // Extras
                                //------------------------------
                                else {
                                        applyExtras(playerID, ge_playerExtras->getExtras(), ((ge_playerExtras->getValue() == 0) ? false : true));

                                        if (playerID == g_myPlayerID && ge_playerExtras->getValue() != 0) {
                                                m_sounds[13-ge_playerExtras->getExtras()].play(255);
                                        }
                                }

                                //if (ge_playerExtras->getValue() != 0)
                                //      console.addEx(Vec3(1.0f, 1.0f, 0.0f), "#%d got new %d type extras", ge_playerExtras->getId(), ge_playerExtras->getExtras());
                                //else
                                //      console.addEx(Vec3(1.0f, 1.0f, 0.0f), "#%d extras type %d remove", ge_playerExtras->getId(), ge_playerExtras->getExtras());

                                if (ge_playerExtras) delete ge_playerExtras;
                                break;

                        //-----------------------------------------------------------------#
                        // Player action (actions is sent also sent to sending client/server)
                        //-----------------------------------------------------------------#
                        case E_PLAYER_ACTION:
                                ge_playerAction = (GE_PlayerAction *)gne->getNextEvent();
                                playerID = ge_playerAction->getId();
                                type = ge_playerAction->getAction();

                                switch (type) {
                                        //---------------------------------------------------------
                                        // Player exploded
                                        //---------------------------------------------------------
                                        case PLAY_ACTION_PLAYER_EXPLODE:
                                                g_players[playerID].state = PLAYER_STATE_INVISIBLE;

                                                dist = (g_players[g_myPlayerID].pos - g_players[playerID].pos).length();
                                                if (dist < 1.0f) dist = 1.0f;

                                                m_sounds[PLAY_SOUND_DEATH].play((int)255/dist);
                                                this->createExplosion(g_players[playerID].pos, 1.5f, false);

                                                if (gne->isServer()) {  // server
                                                        g_players[playerID].spawnTime = g_time + 2000.0f;
                                                }
                                                break;

                                        //---------------------------------------------------------
                                        // Player drowned
                                        //---------------------------------------------------------
                                        case PLAY_ACTION_PLAYER_DROWN:
                                                g_players[playerID].state = PLAYER_STATE_INVISIBLE;

                                                dist = (g_players[g_myPlayerID].pos - g_players[playerID].pos).length();
                                                if (dist < 1.0f) dist = 1.0f;

                                                m_sounds[PLAY_SOUND_DROWN].play((int)255/dist);
                                                createExplosion(g_players[playerID].pos, 1.5f, false);

                                                console.addEx(Vec3(1.0f, 1.0f, 0.0f), "'%s' ended his life in the pool", g_players[playerID].name);

                                                if (gne->isServer()) {  // server
                                                        g_players[playerID].spawnTime = g_time + 2000.0f;

                                                        g_players[playerID].frags--;
                                                        g_players[playerID].deaths++;

                                                        gne->setPlayerScore(playerID, g_players[playerID].frags, g_players[playerID].kills, g_players[playerID].deaths);
                                                }

                                                break;

                                        //---------------------------------------------------------
                                        // Spawn player
                                        //---------------------------------------------------------
                                        case PLAY_ACTION_PLAYER_SPAWN:
                                                g_players[playerID].state = PLAYER_STATE_SPAWNING;

                                                //console.addEx(Vec3(1.0f, 0.0f, 1.0f), "'%s' spawned", g_players[playerID].name);

                                                // reset
                                                g_players[playerID].dir = Vec3(0.0f, 0.0f, 1.0f);
                                                g_players[playerID].angle = 0.0f;
                                                g_players[playerID].life = 100.0f;
                                                Weapon::set(g_players[playerID].weapon, WEAPON_GUN);

                                                // particles
                                                if (g_players[playerID].ownsParticleSystem > 0 && m_particleSystems[g_players[playerID].ownsParticleSystem].isAlive())
                                                        m_particleSystems[g_players[playerID].ownsParticleSystem].die();
                                                g_players[playerID].ownsParticleSystem = startParticleSystem(g_players[playerID].pos + Vec3(0.0f, -0.25f, 0.0f), PARTICLESYSTEM_SPAWN);

                                                dist = (g_players[g_myPlayerID].pos - g_players[playerID].pos).length();
                                                if (dist < 1.0f) dist = 1.0f;

                                                m_sounds[PLAY_SOUND_SPAWN].play((int)255/dist); // spawn sound

                                                // update camera
                                                if (playerID == g_myPlayerID)
                                                        setPlayerCam(playerID);

                                                break;

                                        //---------------------------------------------------------
                                        // Spawn player
                                        //---------------------------------------------------------
                                        case PLAY_ACTION_PLAYER_SPAWNED:
                                                g_players[playerID].state = PLAYER_STATE_USER;
                                                g_players[playerID].spawnTime = 0.0f;

                                                m_particleSystems[g_players[playerID].ownsParticleSystem].die();
                                                g_players[playerID].ownsParticleSystem = -1;

                                                break;

                                        //---------------------------------------------------------
                                        // Not defined
                                        //---------------------------------------------------------
                                        default:
                                                // throw away
                                                break;
                                }

                                if (ge_playerAction) delete ge_playerAction;
                                break;


                        //-----------------------------------------------------------------#
                        // No valid event
                        //-----------------------------------------------------------------#
                        default:
                                gne->getNextEvent();
                                break;
                }
        }
}

---