Play.cpp

Go to the documentation of this file.

#include "Play.h"

/********************************************************************
 * Constructor
 */
Play::Play() {
        unsigned int i;

        for (i=0; i<PLAY_OBJECTS; i++) {
                m_objects[i] = NULL;
        }

        m_objLevel = NULL;
}

/********************************************************************
 * Constructor
 */
Play::~Play() {
        unload();
}

/********************************************************************
 * Load
 */
bool Play::load(Application *parent) {

        g_drawConsole = true;

        if (!gne->isRunning())
                return false;

        g_gameInfo.gameState = GAME_STATE_WAITING;

        // --- THIS WONT BE NEEDED -----
        //g_myPlayerID = 0;
        //g_players[g_myPlayerID].name;
        //strcpy(g_players[g_myPlayerID].name, "Death Bringer");

        //---------

        //g_players[g_myPlayerID].life = 10.0f;

        //setSpawnPlayer(g_myPlayerID);
        
        
        if (parent != NULL)
                m_parent = parent;

        if (!loadTextures())
                return false;

        if (!loadObjects())
                return false;

        loadSounds();

        g_showFPS = false;

        //m_parent->camera.setPosition(Vec3(11.0f, 13.0f, 18.0f));
        //m_parent->camera.setPitch(55.0f);
        //m_parent->camera.setHeading(90.0f);

        // "bot" player
        //strcpy(g_players[1].name, "Bot1");
        //strcpy(g_players[2].name, "Bot2");
        //setSpawnPlayer(1);
        //setSpawnPlayer(2);


        // reset extras
        for (unsigned int i=0; i<PLAY_EXTRAS_SIMULTANEOUS; i++) {
                m_extras[i].type = PLAY_EXTRAS_NONE;
        }

        //if (m_parent->renderer->lockFlags & LF_SHADING) {
        //      if ((m_shader = m_parent->renderer->addShader("data\\shaders\\specular.cg")) == SHADER_NONE) return false;
        //}

        this->setPlayerCam(g_myPlayerID);


        if (!gne->isRunning()) {
                console.addEx(Vec3(1.0f, 1.0f, 1.0f), "Press ENTER to start console/chat");
                console.addEx(Vec3(1.0f, 0.0f, 1.0f), "/server - starts new server");
                console.addEx(Vec3(1.0f, 1.0f, 0.0f), "/connect IP - connects to server");
        }

        // Disable all old lights
        for (i=0; i<GL_MAX_LIGHTS; i++) {
                glDisable(GL_LIGHT0+i);
        }

        // notify network I'm ready
        g_players[g_myPlayerID].state = PLAYER_STATE_READY;
        gne->setPlayerState(g_myPlayerID, PLAYER_STATE_READY);

        LOG_SUCCESS(("Play game loaded"));
        m_loaded = true;
        return true;
}

/********************************************************************
 * Load textures
 */
bool Play::loadTextures() {
        
        unsigned int i;

        if ((m_textures[PLAY_TEX_SKIN] = 
                m_parent->renderer->addTexture("data\\textures\\skins\\arrow.bmp")) == TEXTURE_NONE) return false;

        if ((m_textures[PLAY_TEX_GRENADE] = 
                m_parent->renderer->addTexture("data\\textures\\planets\\earth.bmp")) == TEXTURE_NONE) return false;

        if ((m_textures[PLAY_TEX_PARTICLE] = 
                m_parent->renderer->addTexture("data\\textures\\particles\\flare.bmp")) == TEXTURE_NONE) return false;

        if ((m_textures[PLAY_TEX_SHADOW] = 
                m_parent->renderer->addTexture("data\\textures\\common\\shadow.bmp")) == TEXTURE_NONE) return false;

        if ((m_textures[PLAY_TEX_SPAWN_SPHERE] = 
                m_parent->renderer->addTexture("data\\textures\\common\\spawn_sphere.bmp")) == TEXTURE_NONE) return false;

        if ((m_textures[PLAY_TEX_MODEL_0] = 
                m_parent->renderer->addTexture("data\\textures\\avatars\\robot1.bmp")) == TEXTURE_NONE) return false;

        if ((m_textures[PLAY_TEX_LIFEBAR_FRAME] = 
                m_parent->renderer->addTexture("data\\textures\\play\\lifebar_frame.bmp")) == TEXTURE_NONE) return false;

        if ((m_textures[PLAY_TEX_LIFEBAR_BG] = 
                m_parent->renderer->addTexture("data\\textures\\play\\lifebar_bg.bmp")) == TEXTURE_NONE) return false;

        if ((m_textures[PLAY_TEX_LIFEBAR_GLOW] = 
                m_parent->renderer->addTexture("data\\textures\\play\\lifebar_glow.bmp")) == TEXTURE_NONE) return false;

        if ((m_textures[PLAY_TEX_EXTRAS_OTHER] = 
                m_parent->renderer->addTexture("data\\textures\\common\\extras_other.bmp")) == TEXTURE_NONE) return false;

        if ((m_textures[PLAY_TEX_GAME_OVER] = 
                m_parent->renderer->addTexture("data\\textures\\play\\game_over.bmp")) == TEXTURE_NONE) return false;


        // Player skins
        for (i=0; i<SPLAYER_MAX_PLAYERS; i++) {
                if ((g_players[i].textureID = 
                        m_parent->renderer->addTexture(g_allModels[g_players[i].model].skin)) == TEXTURE_NONE) return false;    
        }


        return true;
}

/********************************************************************
 * Load objects
 */
bool Play::loadObjects() {
        //--------------------
        // Level object
        //--------------------
                //if (!Level::load(m_lvl,"data\\lvls\\crystal1.lvl")) {
                //if (!Level::load(m_lvl,"data\\lvls\\radioactive1.lvl")) {
                //if (!Level::load(m_lvl,"data\\lvls\\lvl1.lvl")) {
        char file[256] = {0};
        //LOG_MISC(("Galaxy:%d, Level:%d",g_gameInfo.currLvl[0],g_gameInfo.currLvl[1]));
        sprintf(file, "data\\lvls\\%s",g_galaxies[g_gameInfo.currLvl[0]].lvls[g_gameInfo.currLvl[1]].file);
        //LOG_MISC(("Level file:%s",file));
        //console.addEx(Vec3(1.0f, 1.0f, 1.0f), "Level: %s", file);

        if (!Level::load(m_lvl,file)) {
                return false;
        }

        m_objLevel = new ObjLevel(m_lvl, m_parent->renderer);
        if (!m_objLevel->load()) return false;
        m_objLevel->createVertexBuffer();
        //--------------------
        //--------------------

        m_objects[PLAY_OBJ_GRENADE] = new Sphere(0.0f, 0.0f, 0.0f, 0.05f, 4);
        m_objects[PLAY_OBJ_SPHERE] = new Sphere(0.0f, 0.0f, 0.0f, 0.65f, 22);


        // models
        for (int i=0; i<SPLAYER_MAX_PLAYERS; i++) {
                if (!g_models[i].loadFromAsciiFile("data\\models\\", g_allModels[g_players[i].model].file))
                        return false;
                //if (!g_models[i].loadFromAsciiFile("data\\models\\", "robot.txt"))
                //      return false;
        }

        return true;
}

/********************************************************************
 * Load sounds
 */
bool Play::loadSounds() {
        m_sounds[PLAY_SOUND_GRENADE].load("data\\sounds\\weapon\\Grenade3.wav");
        m_sounds[PLAY_SOUND_SPAWN].load("data\\sounds\\spawn.wav");
        m_sounds[PLAY_SOUND_GUN].load("data\\sounds\\weapon\\gun.wav");
        m_sounds[PLAY_SOUND_DEATH].load("data\\sounds\\death.wav");
        m_sounds[PLAY_SOUND_GUN_HIT].load("data\\sounds\\weapon\\gun_hit.wav");
        m_sounds[PLAY_SOUND_DROWN].load("data\\sounds\\drown.wav");

        m_sounds[PLAY_SOUND_EXTRAS_LIFE].load("data\\sounds\\extras\\life.wav");
        m_sounds[PLAY_SOUND_EXTRAS_AMMO].load("data\\sounds\\extras\\ammo.wav");
        m_sounds[PLAY_SOUND_EXTRAS_SLOW].load("data\\sounds\\extras\\slow.wav");
        m_sounds[PLAY_SOUND_EXTRAS_SHAKE].load("data\\sounds\\extras\\shake.wav");
        m_sounds[PLAY_SOUND_EXTRAS_FAST].load("data\\sounds\\extras\\fast.wav");
        m_sounds[PLAY_SOUND_EXTRAS_FLIPVIEW].load("data\\sounds\\extras\\flipview.wav");
        m_sounds[PLAY_SOUND_EXTRAS_INVISIBLE].load("data\\sounds\\extras\\invisible.wav");
        m_sounds[PLAY_SOUND_EXTRAS_IMMORTAL].load("data\\sounds\\extras\\immortal.wav");

        m_music.load("data\\music\\exp.xm");
        m_music.play();

        return true;
}

/********************************************************************
 * Unload
 */
bool Play::unload() {
        if (!m_loaded)
                return false;

        unsigned int i;

        for (i=0; i<PLAY_SOUNDS; i++) {
                m_sounds[i].unload();
        }

        m_music.stop();
        m_music.unload();

        for (i=0; i<PLAY_OBJECTS; i++) {
                if (m_objects[i]) {
                        m_objects[i]->clearVertexBuffer();
                        delete m_objects[i];
                }
                m_objects[i] = NULL;
        }

        Level::unload(m_lvl);

        if (m_objLevel) delete m_objLevel;
        m_objLevel = NULL;

        for (i=0; i<PLAY_TEXTURES; i++) {
                m_parent->renderer->deleteTexture(m_textures[i]);
        }

        // Player skins
        for (i=0; i<SPLAYER_MAX_PLAYERS; i++) {
                if (strcmp(g_players[i].skin, "") != 0 && g_players[i].textureID != TEXTURE_NONE) {
                        m_parent->renderer->deleteTexture(g_players[i].textureID);
                }
        }


        //g_models[0].clear();
        //g_models[1].clear();
        //g_models[2].clear();

        // models
        for (i=0; i<SPLAYER_MAX_PLAYERS; i++) {
                g_models[i].clear();
        }

        //if (m_parent->renderer->lockFlags & LF_SHADING) {
        //      m_parent->renderer->deleteShader(m_shader);
        //}

        LOG_SUCCESS(("Play game unloaded"));
        m_loaded = false;
        return true;
}

/********************************************************************
 * Update
 */
bool Play::update() {
        if (!m_loaded)
                return false;

        unsigned int i, n;

        if (g_gameInfo.gameState == GAME_STATE_GAME_OVER) {
                if (g_time > m_timeEnd + 1500.0f) {
                        g_selectedScene = SCENE_SCORES;
                }
                return true;
        }

        handleKeys();

        //======= REMOVE ==========
        //this->bot(1);
        //this->bot(2);


        this->networkLoop();
        this->serverLoop();

        //if (g_gameInfo.gameState != PLAYER_STATE_RUNNING)
        //      return true;

        //-----------------------------------------------------------------#
        // Main player loop (move all players)
        //-----------------------------------------------------------------#
        float rotSpeed = g_frameTime*0.3f;
        bool rotationChanged = false;

        float maxSpeed;
        bool moveChanged = false;
        float friction = (m_lvl.friction*0.00005f)*g_frameTime*0.3f;
        float speed;
        Vec3 pos;
        SPlayer *player;

        for (i=0; i<SPLAYER_MAX_PLAYERS; i++) {
                if (g_players[i].state != PLAYER_STATE_USER)
                        continue;

                player = &g_players[i];

                maxSpeed = 0.004f + player->extras[PLAY_EXTRAS_FAST]*0.002f - player->extras[PLAY_EXTRAS_SLOW]*0.002f;
                if (maxSpeed < 0.001f) maxSpeed = 0.001f;

                moveChanged = false;

                //-------------------------------
                // Rotation
                //-------------------------------
                switch (player->rotation) {
                        case PLAYER_ROTATION_NONE:                                                      // no rotation
                                break;

                        case PLAYER_ROTATION_LEFT:                                                      // rotation left
                                player->angle += rotSpeed;
                                rotationChanged = true;
                                break;

                        case PLAYER_ROTATION_RIGHT:                                                     // rotation right
                                player->angle -= rotSpeed;
                                rotationChanged = true;
                                break;

                        default:
                                break;
                }

                //if (rotationChanged) {                                                                        // update angle and direction if needed
                        float angle = player->angle*PIdiv180;
                        float x = sinf(angle);
                        float z = cosf(angle);
                        player->dir = Vec3(x, 0.0f, z);
                        player->dir = player->dir.normalize();
                //}

                //-------------------------------
                // Moving
                //-------------------------------
                switch (player->moving) {
                        case PLAYER_MOVING_NONE:                                                        // no moving (slow down)
                                if (player->speed > 0.0f) {
                                        player->speed -= friction;

                                        if (player->speed < 0.0f) {
                                                player->speed = 0.0f;
                                        }
                                        else {
                                                moveChanged = true;
                                        }
                                }
                                break;

                        case PLAYER_MOVING_FORWARD:                                                     // move forward
                                player->speed = maxSpeed;
                                player->moveVal = -1;
                                moveChanged = true;
                                break;

                        case PLAYER_MOVING_BACKWARD:
                                player->speed = maxSpeed;                                               // move backward
                                player->moveVal = 1;
                                moveChanged = true;
                                break;
                }

                if (moveChanged) {                                                                              // update position
                        pos = player->pos;
                        speed = player->speed*player->moveVal*g_frameTime;

                                // x dir                                                                                // Collission detection
                                pos.x = player->pos.x + player->dir.x * speed;
                                if (!m_objLevel->collission(pos, 0.25f))
                                        player->pos.x = pos.x;

                                // z dir
                                pos = player->pos;
                                pos.z = player->pos.z + player->dir.z * speed;
                                if (!m_objLevel->collission(pos, 0.25f))
                                        player->pos.z = pos.z;

                                if (i == g_myPlayerID) {
                                        if (m_objLevel->isWater(player->pos)) {                 // drown
                                                player->state = PLAYER_STATE_INVISIBLE;
                                                gne->setPlayerAction(i, PLAY_ACTION_PLAYER_DROWN);
                                        }
                                }

                                player->pos.y = 0.0f;

                        g_models[i].advanceAnimation(g_frameTime*0.035f);
                }

                //-------------------------------
                // Server stuff (extras)
                //-------------------------------
                if (gne->isServer()) {
                        float dist;
                        for (n=0; n<PLAY_EXTRAS_SIMULTANEOUS; n++) {
                                if (m_extras[n].type == PLAY_EXTRAS_NONE)
                                        continue;

                                dist = (player->pos - m_extras[n].pos).length();

                                if (dist <= 0.40f) {
                                        gne->dealExtras(m_extras[n].type, m_extras[n].pos.x, m_extras[n].pos.z, 0);     // remove extras
                                        gne->setPlayerExtras(i, m_extras[n].type, 1);
                                        m_extras[n].type = PLAY_EXTRAS_NONE;
                                }
                        }

                        for (n=0; n<PLAY_EXTRAS; n++) {
                                if (player->extras[n] != 0 && player->timeExtras[n] <= g_time) {        // remove player extras
                                        //console.addEx(Vec3(0.0f, 0.0f, 1.0f), "Player %d extras type %d remove requested", i, n);
                                        gne->setPlayerExtras(i, n, 0);
                                }
                        }
                
                }

        }

        this->setPlayerCam(g_myPlayerID);

        return true;
}

/********************************************************************
 * Handle keys
 */
void Play::handleKeys() {
        static float lastGrenade = 0.0f;
        static float lastProjectile = 0.0f;
        static int gunPos = 0;

        static int lastRotation = 0;
        static int lastMove = 0;
        
        static float lastTime = 0.0f;

        bool rotationChanged = false;
        bool moveChanged = false;

        SPlayer *player = &g_players[g_myPlayerID];

        if (player->state != PLAYER_STATE_USER)
                return;

        if (g_time - lastTime < 75.0f)                                                          // Keep player update rate down!
                return;

        lastTime = g_time;

        if (m_parent->keys['O']) {
                gne->setPlayerExtras(PLAY_NET_GAME_OVER, 0, 0);
        }

        //if (m_parent->keys['O']) {
        //      Weapon::set(g_players[g_myPlayerID].weapon, WEAPON_ROCKET);
        //      m_parent->keys['O'] = false;
        //}

        //-----------------------------------------------------------------#
        // Rotation
        //-----------------------------------------------------------------#

        int rotation = 0;

        if (m_parent->keys[VK_LEFT])
                rotation--;

        if (m_parent->keys[VK_RIGHT])
                rotation++;

        if (rotation != lastRotation) {
                if (rotation == -1)
                        player->rotation = PLAYER_ROTATION_LEFT;
                else if (rotation == 1)
                        player->rotation = PLAYER_ROTATION_RIGHT;
                else
                        player->rotation = PLAYER_ROTATION_NONE;


                lastRotation = rotation;
                rotationChanged = true;
        }


        //-----------------------------------------------------------------#
        // Moving
        //-----------------------------------------------------------------#
        int move = 0;

        if (m_parent->keys[VK_UP])
                move++;

        if (m_parent->keys[VK_DOWN])
                move--;

        if (move != lastMove) {
                if (move == 1)
                        player->moving = PLAYER_MOVING_FORWARD;
                else if (move == -1)
                        player->moving = PLAYER_MOVING_BACKWARD;
                else
                        player->moving = PLAYER_MOVING_NONE;

                lastMove = move;
                moveChanged = true;
        }


        if (rotationChanged || moveChanged) {                                   // send move, rotation, position and angle to network
                //if (g_time - lastTime > 50.0f ||
                //              player->rotation == PLAYER_ROTATION_NONE ||
                //              player->moving == PLAYER_MOVING_NONE) {

                //      lastTime = g_time;
                        gne->setPlayerPos(g_myPlayerID, player->rotation, player->moving, player->pos.x, player->pos.z, player->angle);
                //}
        }

        float angle = -player->angle*PIdiv180;
        float cosA = cos(angle);
        float sinA = sin(angle);

        if (m_parent->keys['Z']) {                                                                                      // throw grenade!
                if (g_time - lastGrenade > 500.0f) {
                        Vec3 gunVec = Vec3(0.0f, 0.25f, 0.0f);
                        if (g_models[g_myPlayerID].numGuns > 0) {
                                if (++gunPos >= g_models[g_myPlayerID].numGuns) gunPos = 0;
                                
                                gunVec = g_models[g_myPlayerID].guns[gunPos];

                                Vec3 tmp = gunVec;
                                gunVec.x = tmp.x*cosA-tmp.z*sinA;
                                gunVec.z = tmp.x*sinA+tmp.z*cosA;
                        }

                        Vec3 pos = player->pos + gunVec;
                        Vec3 dir = -(player->dir*0.015f - player->dir*player->speed*2.0f*player->moveVal) * 150.0f + Vec3(0.0f, 6.0f, 0.0f);

                        gne->sendAttack(g_myPlayerID, WEAPON_GRENADE, pos.x, pos.y, pos.z, dir.x, dir.y, dir.z);

                        lastGrenade = g_time;
                        throwGrenade(g_myPlayerID, pos, dir, 3.0f, 1.0f);
                        //m_parent->keys['Z'] = false;
                }
        }

        if (m_parent->keys['X']) {                                                                                      // fire projectile
                if (g_time - lastProjectile > player->weapon.reload) {
                        Vec3 gunVec = Vec3(0.0f, 0.25f, 0.0f);
                        if (g_models[g_myPlayerID].numGuns > 0) {
                                if (++gunPos >= g_models[g_myPlayerID].numGuns) gunPos = 0;
                                
                                gunVec = g_models[g_myPlayerID].guns[gunPos];

                                Vec3 tmp = gunVec;
                                gunVec.x = tmp.x*cosA-tmp.z*sinA;
                                gunVec.z = tmp.x*sinA+tmp.z*cosA;
                        }

                        m_sounds[PLAY_SOUND_GUN].play(125);

                        Vec3 pos = player->pos + gunVec;
                        Vec3 dir = -player->dir*(150.0f*player->speed+1.0f)*6.0f*player->weapon.speed;

                        gne->sendAttack(g_myPlayerID, player->weapon.type, pos.x, pos.y, pos.z, dir.x, dir.y, dir.z);

                        lastProjectile = g_time;
                        fireProjectile(g_myPlayerID, pos, dir, player->weapon.power);
                        //m_parent->keys['X'] = false;
                }
        }

}

/********************************************************************
 * Draw frame
 */
bool Play::drawFrame() {
        if (!m_loaded)
                return false;

        unsigned int i = 0;

        if (!gne->isRunning())
                return true;

        if (g_gameInfo.gameState == GAME_STATE_WAITING) {
                m_parent->defaultFont->startTextMode();
                m_parent->defaultFont->setColor(0.0f, 0.0f, 1.0f, 1.0f);
                m_parent->defaultFont->print((float)g_width/2.0f - 75.0f, (float)g_height/2.0f, "WAITING FOR PLAYERS...");
                m_parent->defaultFont->endTextMode();
                return true;
        }

        m_parent->camera.setPrespective(g_frameTime*0.001f);
        m_parent->camera.updateFrustum();

        for (i=0; i<m_lvl.numLights; i++) {
                glLightfv(GL_LIGHT0+i, GL_AMBIENT, m_lvl.lights[i].ambient);
                glLightfv(GL_LIGHT0+i, GL_DIFFUSE, m_lvl.lights[i].color);
                glLightfv(GL_LIGHT0+i, GL_POSITION,Vec4(m_lvl.lights[i].pos, 1.0f));
                glLightf(GL_LIGHT0+i, GL_CONSTANT_ATTENUATION, m_lvl.lights[i].attenuation.x);
                glLightf(GL_LIGHT0+i, GL_LINEAR_ATTENUATION, m_lvl.lights[i].attenuation.y);
                glLightf(GL_LIGHT0+i, GL_QUADRATIC_ATTENUATION, m_lvl.lights[i].attenuation.z);
                glEnable(GL_LIGHT0+i);
        }

        glColor4f(1.0f, 1.0f, 1.0f, 1.0f);

        glEnable(GL_LIGHTING);
        glStencilMask(0xF);

        //------------------------------------------------------------
        // USE STENCIL BUFFER - (Two environment renders needed. Using z-pass algorithm)
        //------------------------------------------------------------
        if (g_stencilBuffer) {

                glDisable(GL_LIGHT0);

                        m_objLevel->drawFloor();
                        m_objLevel->drawWalls();
                        m_objLevel->drawWater();

                        //m_parent->renderer->setTextures(m_textures[PLAY_TEX_GRENADE]);
                        //m_parent->renderer->apply();
                        m_objLevel->drawObjects();

                        //drawPlayer(&player);
                        drawPlayers();

                glEnable(GL_LIGHT0);

                glEnable(GL_STENCIL_TEST);
                glPushAttrib(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_POLYGON_BIT | GL_STENCIL_BUFFER_BIT);
                {

                        m_parent->renderer->setMask(NONE);
                        m_parent->renderer->apply();

                        glEnable(GL_CULL_FACE);

                        glStencilFunc(GL_ALWAYS, 0, ~0);

                        glStencilOp(GL_KEEP, GL_KEEP, GL_INCR);
                        glCullFace(GL_FRONT);
                        m_objLevel->drawShadow();

                        glStencilOp(GL_KEEP, GL_KEEP, GL_DECR);
                        glCullFace(GL_BACK);
                        m_objLevel->drawShadow();

                        glDisable(GL_CULL_FACE);
                }
                glPopAttrib();

                m_parent->renderer->apply();

                glEnable(GL_STENCIL_TEST);
                glStencilFunc(GL_EQUAL, 0, ~0);
                glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);

                m_objLevel->drawFloor();
                m_objLevel->drawWalls();
                m_objLevel->drawWater();

                //m_parent->renderer->setTextures(m_textures[PLAY_TEX_GRENADE]);
                //m_parent->renderer->apply();
                m_objLevel->drawObjects();

                //drawPlayer(&player);
                drawPlayers();

                glDisable(GL_STENCIL_TEST);

        }
        //------------------------------------------------------------
        // Just render :) (no shadows)
        //------------------------------------------------------------
        else {

                glEnable(GL_LIGHTING);

                m_objLevel->drawFloor();
                m_objLevel->drawWalls();
                m_objLevel->drawWater();

                //m_parent->renderer->setTextures(m_textures[PLAY_TEX_GRENADE]);
                //m_parent->renderer->apply();
                m_objLevel->drawObjects();

                //drawPlayer(&g_players[m_selfID]);
                drawPlayers();
        }

        m_objLevel->drawWaterSurface();
        
        glDisable(GL_LIGHTING);

        drawGrenades();
        drawProjectiles();

        drawExtras();

        drawExplosions();
        drawParticleSystems();


        //------------------------------------------------------------
        // User stats, info and stuff
        //------------------------------------------------------------
        glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
        m_parent->defaultFont->startTextMode();
        //m_parent->defaultFont->setColor(1.0f, 1.0f, 1.0f, 1.0f);
        //m_parent->defaultFont->print(20.0f, 70.0f, "g_myPlayerID: %d", g_myPlayerID);
        //m_parent->defaultFont->print(20.0f, 90.0f, "networkID: %d", gne->getPlayerIdSelf());  // GUI (life etc)

        float timeLeft = (m_timeEnd - g_time)*0.001f;
        int timeLeftMin = (int)(timeLeft/60.0f);
        int timeLeftSec = (int)(timeLeft - timeLeftMin*60);
        m_parent->defaultFont->setColor(1.0f, 1.0f, 1.0f, 1.0f);
        m_parent->defaultFont->print((float)g_width/2.0f - 30.0f, 50.0f, "%d:%s%d", timeLeftMin, (timeLeftSec < 10 ? "0" : ""),timeLeftSec);

        if (g_players[g_myPlayerID].state == PLAYER_STATE_USER) {

                //drawAvatar(PLAY_TEX_MODEL_0, true);
                //drawAvatar(PLAY_TEX_MODEL_0);
                //drawAvatar(PLAY_TEX_MODEL_0);

                //m_parent->defaultFont->setColor(1.0f, 1.0f, 1.0f, 1.0f);
                //m_parent->defaultFont->print(20.0f, (g_fullscreen ? 30.0f : 50.0f), "Pitch: %f", m_parent->camera.m_pitchDegrees);
                //m_parent->defaultFont->print(20.0f, (g_fullscreen ? 50.0f : 70.0f), "Heading: %f", m_parent->camera.m_headingDegrees);

                //m_parent->defaultFont->print(20.0f, (g_fullscreen ? 30.0f : 50.0f), "Life: %f", g_players[g_myPlayerID].life);

                //m_parent->defaultFont->print(20.0f, 110.0f, "X: %f, Z: %f", g_players[g_myPlayerID].pos.x, g_players[g_myPlayerID].pos.z);

                this->drawLifebar();

        }

        //------------------------------------------------------------
        // Game Over
        //------------------------------------------------------------
        if (g_gameInfo.gameState == GAME_STATE_GAME_OVER) {
                float x = (float)g_width/2.0f;
                float y = (float)g_height/2.0f;
                float scale = ((m_timeEnd-g_time)/1500.0f);
                float w = 300.0f*scale;
                float h = w/2;

                float c = 1.0f+scale;
                glColor4f(c, c, c, c);

                m_parent->renderer->setMask(COLOR);
                m_parent->renderer->setTextures(m_textures[PLAY_TEX_GAME_OVER]);
                m_parent->renderer->setBlending(ONE, ONE);
                m_parent->renderer->apply();

                glBegin(GL_QUADS);
                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 1, 0);
                        glVertex2f(x-w, y-h);

                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 1, 1);
                        glVertex2f(x-w, y+h);

                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0, 1);
                        glVertex2f(x+w, y+h);

                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0, 0);
                        glVertex2f(x+w, y-h);
                glEnd();
        }

        m_parent->defaultFont->endTextMode();

        //------------------------------------------------------------
        // Score board
        //------------------------------------------------------------
        if (m_parent->keys[VK_TAB]) {
                m_parent->defaultFont->startTextMode();

                int x = g_width/2.0f - 200.0f;
                int y = 140.0f;

                m_parent->defaultFont->setColor(1.0f, 1.0f, 1.0f, 1.0f);
                m_parent->defaultFont->print(x, y, "[Name]               [Frags]      [Kills]      [Deaths]");

                y += 25.0f;
                
                SPlayer *player;
                for (i=0; i<SPLAYER_MAX_PLAYERS; i++) {
                        if (g_players[i].state != PLAYER_STATE_OFFLINE) {
                                player = &g_players[i];

                                m_parent->defaultFont->setColor(1.0f, 1.0f, 0.0f, 1.0f);
                                m_parent->defaultFont->print(x, y, "%s", player->name);

                                m_parent->defaultFont->setColor(0.0f, 0.0f, 1.0f, 1.0f);
                                m_parent->defaultFont->print(x+22.0f*7.65f, y, "[%d]", player->frags);

                                m_parent->defaultFont->setColor(0.0f, 1.0f, 0.0f, 1.0f);
                                m_parent->defaultFont->print(x+35.5f*7.65f, y, "[%d]", player->kills);

                                m_parent->defaultFont->setColor(1.0f, 0.0f, 0.0f, 1.0f);
                                m_parent->defaultFont->print(x+49.25f*7.65f, y, "[%d]", player->deaths);

                                y += 25.0f;
                        }
                }

                m_parent->defaultFont->endTextMode();
        }


        m_parent->renderer->apply();    // needed for what?

        return true;
}

/********************************************************************
 * Throw grenade
 */
void Play::throwGrenade(int playerID, Vec3 pos, Vec3 vel, float life, float strength) {
        for (unsigned int i=0; i<MAX_GRANADES; i++) {
                if (!m_granades[i].isAlive()) {
                        m_granades[i].create(pos, vel, life, strength);
                        m_granades[i].setPlayerID(playerID);
                        return;
                }
        }
}

/********************************************************************
 * Fire projectile
 */
void Play::fireProjectile(int playerID, Vec3 pos, Vec3 vel, float strength) {
        for (unsigned int i=0; i<MAX_PROJECTILES; i++) {
                if (!m_projectiles[i].isAlive()) {
                        m_projectiles[i].create(pos, vel, strength);
                        m_projectiles[i].setPlayerID(playerID);
                        return;
                }
        }
}

/********************************************************************
 * Create explosion
 */
void Play::createExplosion(Vec3 pos, float power, bool sphere) {
        for (unsigned int i=0; i<MAX_EXPLOSIONS; i++) {
                if (!m_explosions[i].isAlive()) {
                        m_explosions[i].explode(pos, power, sphere);
                        return;
                }
        }
}

/********************************************************************
 * Draw Grenades
 */
void Play::drawGrenades() {
        m_parent->renderer->setTextures(m_textures[PLAY_TEX_GRENADE]);
        m_parent->renderer->apply();
        Vec3 pos;
        float dTime = g_frameTime*0.001f;
        for (unsigned int i=0; i<MAX_GRANADES; i++) {
                if (m_granades[i].isAlive()) {
                        // wierd? :) (if update returns true, the granade explodes)
                        if (m_granades[i].update(dTime, m_objLevel)) {
                                pos = m_granades[i].getPos();
                                grenadeExplode(m_granades[i].getPlayerID(), pos, m_granades[i].getStrength());
                        }
                        else {
                                glPushMatrix();
                                {
                                        pos = m_granades[i].getPos();
                                        glTranslatef(pos.x, pos.y, pos.z);
                                        m_objects[PLAY_OBJ_GRENADE]->draw();
                                }
                                glPopMatrix();
                        }
                }
        }
}

/********************************************************************
 * Grenades Explode
 */
void Play::grenadeExplode(int ownerID, Vec3 pos, float strength) {
        float dist;

        strength *= 7.5;

        // (mostly) FOR SERVER!
        for (unsigned int i=0; i<SPLAYER_MAX_PLAYERS; i++) {
                if (g_players[i].state == PLAYER_STATE_OFFLINE)
                        continue;
                
                dist = (pos - g_players[i].pos).length();
                if (dist <= 2.5f) {
                        if (dist <= 0.01f) dist = 0.01f;
                        this->dealDamage(ownerID, i, strength * (2.5f/dist));
                }
        }

        // shake camera
        dist = (pos - g_players[g_myPlayerID].pos).length();
        if (dist < 0.5f) dist = 0.5f;
        m_parent->camera.shake(0.30f, 70.0f, 0.8f/(dist*dist));

        m_sounds[PLAY_SOUND_GRENADE].play((int)255/dist);
        createExplosion(pos + Vec3(0.0f, 0.25f, 0.0f), 1.0f);
}

/********************************************************************
 * Deal damage
 * This is FOR SERVER
 */
void Play::dealDamage(int ownerID, int playerID, float damage) {
        if (g_players[playerID].state == PLAYER_STATE_USER && !g_players[playerID].extras[PLAY_EXTRAS_IMMORTAL])
                g_players[playerID].life -= damage;

        // FOR SERVER
        if (gne->isServer() && g_players[playerID].life <= 0) {
                g_players[playerID].life = 100.0f;
                gne->setPlayerDeath(playerID, ownerID);
        }
}

/********************************************************************
 * Draw explosions
 */
void Play::drawExplosions() {
        for (unsigned int i=0; i<MAX_EXPLOSIONS; i++) {
                m_parent->renderer->setDepthFunc(LEQUAL);
                m_parent->renderer->setMask(COLOR);
                m_parent->renderer->setTextures(m_textures[PLAY_TEX_PARTICLE]);
                m_parent->renderer->setBlending(ONE, ONE);
                m_parent->renderer->apply();
                if (m_explosions[i].isAlive()) {
                        m_explosions[i].drawAndUpdate(g_frameTime*0.001f);
                }
        }
}

/********************************************************************
 * Draw projectiles
 */
void Play::drawProjectiles() {
        m_parent->renderer->setTextures(m_textures[PLAY_TEX_GRENADE]);
        m_parent->renderer->apply();
        Vec3 pos;
        float dTime = g_frameTime*0.001f;
        int playerID;

        float dist;

        for (unsigned int i=0; i<MAX_PROJECTILES; i++) {
                if (m_projectiles[i].isAlive()) {
                        m_projectiles[i].update(dTime);

                        pos = m_projectiles[i].getPos();

                        if (m_objLevel->collission(pos, 0.05f)) {
                                createExplosion(pos, m_projectiles[i].getStrength());
                                m_projectiles[i].die();
                                dist = (g_players[g_myPlayerID].pos - pos).length();
                                if (dist < 0.5f) dist = 0.5f;
                                m_sounds[PLAY_SOUND_GUN_HIT].play((int)255/dist);
                        }

                        // FOR SERVER
                        else if ((playerID = this->playerCollission(pos, 0.25f)) != -1) {
                                this->dealDamage(m_projectiles[i].getPlayerID(), playerID, m_projectiles[i].getStrength()*7.0f);
                                m_projectiles[i].die();
                                createExplosion(pos, m_projectiles[i].getStrength());
                        }

                        else {
                                glPushMatrix();
                                        glTranslatef(pos.x, pos.y, pos.z);
                                        m_objects[PLAY_OBJ_GRENADE]->draw();
                                glPopMatrix();
                        }
                }
        }
}

/********************************************************************
 * Player collission
 */
int Play::playerCollission(Vec3 pos, float size) {
        float dist;

        Vec2 pA(pos.x, pos.z);
        Vec2 pP;

        for (unsigned int i=0; i<SPLAYER_MAX_PLAYERS; i++) {
                if (g_players[i].state == PLAYER_STATE_OFFLINE)
                        continue;
                pP = Vec2(g_players[i].pos.x, g_players[i].pos.z);
                dist = (pA - pP).length();
                if (dist <= size)
                        return i;
        }

        return -1;
}


/********************************************************************
 * Set spawn player (FOR SERVER)
 */
void Play::setSpawnPlayer(int playerID) {


        g_players[playerID].state = PLAYER_STATE_INVISIBLE;
        g_players[playerID].spawnTime = g_time + 100.0f;

        if (gne->isRunning() && gne->isServer()) {
                gne->setPlayerState(playerID, g_players[playerID].state);
        }
}

/********************************************************************
 * Draw player
 */
void Play::drawPlayers() {
        // draw ALL players
        for (unsigned int i=0; i<SPLAYER_MAX_PLAYERS; i++) {
                if (g_players[i].state != PLAYER_STATE_OFFLINE)
                        drawPlayer(i);
        }
}

/********************************************************************
 * Draw player
 */
void Play::drawPlayer(int playerID) {
        SPlayer *p = &g_players[playerID];

        if (p->state == PLAYER_STATE_OFFLINE || p->state == PLAYER_STATE_INVISIBLE)
                return;

        if (!m_parent->camera.sphereInFrustum(p->pos, 0.25f))
                return;

        glPushMatrix();
        {
                glTranslatef(p->pos.x, p->pos.y, p->pos.z);

                // immortal bubble
                if (p->extras[PLAY_EXTRAS_IMMORTAL]) {
                        m_parent->renderer->setDepthFunc(LEQUAL);
                        m_parent->renderer->setMask(COLOR);
                        m_parent->renderer->setTextures(m_textures[PLAY_TEX_SPAWN_SPHERE]);
                        m_parent->renderer->setBlending(ONE, ONE);
                        m_parent->renderer->apply();

                        glPushMatrix();
                                glTranslatef(0.0f, 0.40f, 0.0f);
                                glRotatef(-g_time*0.15f, 0.25f, 0.85f, 0.45f);
                                m_objects[PLAY_OBJ_SPHERE]->draw();
                        glPopMatrix();
                }

                // spawn bubble (and rotate)
                if (p->state == PLAYER_STATE_SPAWNING) {

                        m_parent->renderer->setDepthFunc(LEQUAL);
                        m_parent->renderer->setMask(COLOR);
                        m_parent->renderer->setTextures(m_textures[PLAY_TEX_SPAWN_SPHERE]);
                        m_parent->renderer->setBlending(ONE, ONE);
                        m_parent->renderer->apply();

                        glPushMatrix();
                                glTranslatef(0.0f, 0.40f, 0.0f);
                                glRotatef(-g_time*0.15f, 0.25f, 0.85f, 0.45f);
                                m_objects[PLAY_OBJ_SPHERE]->draw();
                        glPopMatrix();

                        glRotatef(g_time*0.6f, 0.0f, 1.0f, 0.0f); //drawSpawn(playerID);
                }
                else {
                        glRotatef(p->angle, 0.0f, 1.0f, 0.0f);
                }


                if (p->extras[PLAY_EXTRAS_INVISIBLE] != 0) {
                        glColor4f(0.2f, 0.2f, 0.2f, 0.15f);
                        m_parent->renderer->setBlending(ONE_MINUS_SRC_ALPHA, ONE);
                }
                m_parent->renderer->setTextures(p->textureID);
                m_parent->renderer->apply();

                //if (p->extras[PLAY_EXTRAS_INVISIBLE] == 0) {
                        glScalef(-0.1f, 0.1f, -0.1f);
                        g_models[playerID].render();
                //}

                //glPushAttrib(GL_LIGHTING_BIT);
                //      glDisable(GL_LIGHTING);
                //      m_model.renderBones();
                //glPopAttrib();

        }
        glPopMatrix();

        glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
        if (p->extras[PLAY_EXTRAS_INVISIBLE] == 0) {
                drawShadow(p->pos, 0.35f);
        }
        m_parent->renderer->apply(); // for some reason needed for stencil test
}

/********************************************************************
 * Draw spawn
 */
void Play::drawSpawn(int playerID) {
        //SPlayer *p = &g_players[playerID];
        //static float time = -1.0f;

        //if (p->state == PLAYER_STATE_SPAWNING && time == -1.0f) {
        //      time = g_time + 1500.0f;
        //}

        //if (g_time < time) {
        //      glRotatef(g_time*0.6f, 0.0f, 1.0f, 0.0f);
        //}
        //else {
        //      p->state = PLAYER_STATE_USER;
        //      m_particleSystems[p->ownsParticleSystem].die();
        //      p->ownsParticleSystem = -1;
        //      time = -1.0f;
        //}
}

/********************************************************************
 * Start particle system
 */
int Play::startParticleSystem(Vec3 pos, int type) {
        for (unsigned int i=1; i<MAX_PARTICLESYSTEMS; i++) {
                if (!m_particleSystems[i].isAlive()) {
                        m_particleSystems[i].loadPreset(type);
                        m_particleSystems[i].move(pos);
                        m_particleSystems[i].move(pos);
                        m_particleSystems[i].start();
                        return i;
                }
        }

        return 1;
}

/********************************************************************
 * Set particle system position
 */
void Play::setParticleSystemPos(int id, Vec3 pos) {
        if (m_particleSystems[id].isAlive())
                m_particleSystems[id].move(pos);
}

/********************************************************************
 * Draw particle systems
 */
void Play::drawParticleSystems() {
        m_parent->renderer->setDepthFunc(LEQUAL);
        m_parent->renderer->setMask(COLOR);
        m_parent->renderer->setTextures(m_textures[PLAY_TEX_PARTICLE]);
        m_parent->renderer->setBlending(ONE, ONE);
        m_parent->renderer->apply();

        for (unsigned int i=0; i<MAX_PARTICLESYSTEMS; i++) {    // Dead systems handled by "drawAndUpdate"
                if (!m_parent->camera.sphereInFrustum(m_particleSystems[i].getPos(), 0.25f))
                        continue;

                m_particleSystems[i].drawAndUpdate(&m_parent->camera, g_frameTime*0.001f);
        }
}

/********************************************************************
 * Draw shadow
 */
void Play::drawShadow(Vec3 pos, float size) {

        m_parent->renderer->setMask(COLOR);
        m_parent->renderer->setTextures(m_textures[PLAY_TEX_SHADOW]);
        m_parent->renderer->setBlending(DST_COLOR, ZERO);
        m_parent->renderer->apply();

        glPushAttrib(GL_LIGHTING_BIT);
        {
                glDisable(GL_LIGHTING);

                glBegin(GL_QUADS);
                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0, 0);
                        glVertex3f(pos.x-size, 0.001f, pos.z-size);

                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0, 1);
                        glVertex3f(pos.x-size, 0.001f, pos.z+size);

                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 1, 1);
                        glVertex3f(pos.x+size, 0.001f, pos.z+size);

                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 1, 0);
                        glVertex3f(pos.x+size, 0.001f, pos.z-size);
                glEnd();

                //glEnable(GL_LIGHTING);        // can be removed.. I think

        }
        glPopAttrib();
}

/********************************************************************
 * Set player cam
 */
void Play::setPlayerCam(int playerID) {
        float pitch = 55.0f;
        float heading = 90.0f;
        Vec3 pos = g_players[playerID].pos+Vec3(-7.0f, 10.75f, 0.0f);


        if (g_players[playerID].extras[PLAY_EXTRAS_FLIPVIEW] > 0) {
                pitch = 125.0f;
                pos = g_players[playerID].pos+Vec3(7.0f, 10.75f, 0.0f);
        }

        if (g_players[playerID].extras[PLAY_EXTRAS_SHAKE] > 0) {
                pitch += cosf(g_time*0.01f)*2.2f;
                heading += sinf(g_time*0.01f)*2.5f;

        }

        m_parent->camera.setPitch(pitch);
        m_parent->camera.setHeading(heading);
        m_parent->camera.setPosition(pos);
}

/********************************************************************
 * Draw avatar
 */
void Play::drawAvatar(int model, bool clear) {
        static float x = 0.0f;
        float size = 25.0f;
        float y = 45.0f;

        if (clear)
                x = 55.0f;
        else
                x += 75.0f;


        m_parent->renderer->setMask(COLOR);
        m_parent->renderer->setTextures(m_textures[model]);
        m_parent->renderer->setBlending(ONE, ONE);
        m_parent->renderer->apply();

        //glPushAttrib(GL_LIGHTING_BIT);
        //{
        //      glDisable(GL_LIGHTING);

                glBegin(GL_QUADS);
                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0, 1);
                        glVertex2f(x-size, y-size);

                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0, 0);
                        glVertex2f(x-size, y+size);

                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 1, 0);
                        glVertex2f(x+size, y+size);

                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 1, 1);
                        glVertex2f(x+size, y-size);
                glEnd();

                //glEnable(GL_LIGHTING);        // can be removed.. I think

        //}
        //glPopAttrib();

}

void Play::drawLifebar() {
        float height = 10.0f;
        float mWidth = 150.0f;
        float width = g_players[g_myPlayerID].life * 1.5f;
        float x = g_width - 25.0f;
        float y = g_height - height - 15.0f;
        float border = 2.0f;
        bool glow = false;
        
        if (width < 0.0f)
                width = 0.0f;

        if (width > mWidth) {
                glow = true;
                width = mWidth;
        }

        m_parent->renderer->setMask(COLOR);
        m_parent->renderer->setTextures(m_textures[PLAY_TEX_LIFEBAR_BG]);
        m_parent->renderer->setBlending(ONE, ONE);
        m_parent->renderer->apply();

        glBegin(GL_QUADS);
                glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0, 1);
                glVertex2f(x-width+border, y-height+border);

                glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0, 0);
                glVertex2f(x-width+border, y+height-border);

                glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 1, 0);
                glVertex2f(x-border, y+height-border);

                glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 1, 1);
                glVertex2f(x-border, y-height+border);
        glEnd();


        m_parent->renderer->setMask(COLOR);
        m_parent->renderer->setTextures(m_textures[PLAY_TEX_LIFEBAR_FRAME]);
        m_parent->renderer->setBlending(DST_COLOR, ZERO);
        m_parent->renderer->apply();

        glBegin(GL_QUADS);
                glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0, 1);
                glVertex2f(x-mWidth, y-height);

                glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0, 0);
                glVertex2f(x-mWidth, y+height);

                glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 1, 0);
                glVertex2f(x, y+height);

                glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 1, 1);
                glVertex2f(x, y-height);
        glEnd();

        if (glow || g_players[g_myPlayerID].extras[PLAY_EXTRAS_IMMORTAL]) {
                float c = 0.7f + sinf(g_time*0.01f)*0.3f;
                glColor4f(c,c,c,c);
                m_parent->renderer->setMask(COLOR);
                m_parent->renderer->setTextures(m_textures[PLAY_TEX_LIFEBAR_GLOW]);
                m_parent->renderer->setBlending(ONE, ONE);
                m_parent->renderer->apply();

                glBegin(GL_QUADS);
                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0, 1);
                        glVertex2f(x-mWidth-border, y-height-border);

                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0, 0);
                        glVertex2f(x-mWidth-border, y+height+border);

                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 1, 0);
                        glVertex2f(x+border, y+height+border);

                        glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 1, 1);
                        glVertex2f(x+border, y-height-border);
                glEnd();
        }

        glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
}

/********************************************************************
 * Apply extras
 */
void Play::applyExtras(int playerID, int type, bool add) {
        //------------------------------------------------------------
        // Add extras
        //------------------------------------------------------------
        if (add) {
                switch (type) {
                        case PLAY_EXTRAS_LIFE:                                          // life
                                g_players[playerID].life = 150.0f;
                                break;

                        case PLAY_EXTRAS_AMMO:                                          // ammo
                                g_players[playerID].ammo += 25;
                                break;

                        case PLAY_EXTRAS_SLOW:                                          // slow down
                                g_players[playerID].extras[type] = 1;
                                g_players[playerID].timeExtras[type] = g_time + 15000.0f;
                                break;

                        case PLAY_EXTRAS_SHAKE:                                         // shake
                                g_players[playerID].extras[type] = 1;
                                g_players[playerID].timeExtras[type] = g_time + 12500.0f;
                                break;

                        case PLAY_EXTRAS_FLIPVIEW:                                      // flip view
                                g_players[playerID].extras[type] = 1;
                                g_players[playerID].timeExtras[type] = g_time + 12500.0f;
                                break;

                        case PLAY_EXTRAS_FAST:                                          // fast
                                g_players[playerID].extras[type] = 1;
                                g_players[playerID].timeExtras[type] = g_time + 15000.0f;
                                break;

                        case PLAY_EXTRAS_INVISIBLE:                                     // invisible
                                g_players[playerID].extras[type] = 1;
                                g_players[playerID].timeExtras[type] = g_time + 15000.0f;
                                break;

                        case PLAY_EXTRAS_IMMORTAL:                                      // immortal
                                g_players[playerID].extras[type] = 1;
                                g_players[playerID].timeExtras[type] = g_time + 15000.0f;
                                break;

                        default:                                                                        // not defined
                                break;
                }
        }
        //------------------------------------------------------------
        // Remove extras
        //------------------------------------------------------------
        else {
                switch (type) {
                        case PLAY_EXTRAS_LIFE:                                          // life
                                break;

                        case PLAY_EXTRAS_AMMO:                                          // ammo
                                break;

                        default:
                                g_players[playerID].extras[type] = 0;
                                g_players[playerID].timeExtras[type] = 0.0f;
                                break;
                }
        }
}

/********************************************************************
 * New extras
 */
void Play::newExtras(int type, float x, float z) {
        float maxTime = 0.0f;
        int avaiable = 0;

        for (unsigned int i=0; i<PLAY_EXTRAS_SIMULTANEOUS; i++) {
                if (m_extras[i].type == PLAY_EXTRAS_NONE) {
                        avaiable = i;
                        break;
                }
                
                if (m_extras[i].time > maxTime) {
                        maxTime = m_extras[i].time;
                        avaiable = i;
                }
        }


        m_extras[avaiable].type = type;
        m_extras[avaiable].time = g_time;
        m_extras[avaiable].pos = Vec3(x, 0.0f, z);
}

/********************************************************************
 * Deal extras (FOR SERVER only)
 */
void Play::dealExtras() {
        static float time = 0.0f;
        static float max = pow(PLAY_EXTRAS, 2);

        if (!gne->isServer())
                return;

        // deal one extras
        if (time <= g_time) {
                Vec3 pos = m_objLevel->getExtras();
                float r = ((float)rand() / (float)RAND_MAX)*(max);

                //int type = (int)sqrt(r);
                //if (type < 0) type = 0;
                //else if (type > PLAY_EXTRAS-1) type = PLAY_EXTRAS - 1;

                int type = (int)round(((float)rand() / (float)RAND_MAX)*(PLAY_EXTRAS-1));

                //LOG_MISC(("New extras dealed (%d, %f, %f)", type, pos.x, pos.z));

                gne->dealExtras(type, pos.x, pos.z, 1);

                time = g_time + 10000.0f;
        }
}

/********************************************************************
 * Draw extras
 */
void Play::drawExtras() {
        float size = 0.20f;

        for (unsigned int i=0; i<PLAY_EXTRAS_SIMULTANEOUS; i++) {
                if (m_extras[i].type == PLAY_EXTRAS_NONE)
                        continue;

                m_parent->renderer->setMask(COLOR);
                m_parent->renderer->setTextures(m_textures[PLAY_TEX_EXTRAS_OTHER]);
                m_parent->renderer->setBlending(ONE, ONE);
                m_parent->renderer->apply();

                glPushMatrix();
                {
                        glTranslatef(m_extras[i].pos.x, m_extras[i].pos.y, m_extras[i].pos.z);
                        glRotatef((m_extras[i].time + g_time)*0.1f, 0.0f, 1.0f, 0.0f);

                        glBegin(GL_QUADS);
                                glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0, 0);
                                glVertex3f(-size, size+0.0f, 0.0f);

                                glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 0, 1);
                                glVertex3f(-size, size+size*2.0f, 0.0f);

                                glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 1, 1);
                                glVertex3f(size, size+size*2.0f, 0.0f);

                                glMultiTexCoord2fARB(GL_TEXTURE0_ARB, 1, 0);
                                glVertex3f(size, size+0.0f, 0.0f);
                        glEnd();
                }
                glPopMatrix();
        }
}

/********************************************************************
 * Bot
 */
void Play::bot(int playerID) {
        static Vec3 goal[SPLAYER_MAX_PLAYERS];
        static float lastGrenade[SPLAYER_MAX_PLAYERS] = {0};
        static float lastProjectile[SPLAYER_MAX_PLAYERS] = {0};
        static int gunPos[SPLAYER_MAX_PLAYERS] = {0};

        SPlayer *player = &g_players[playerID];

        if (player->state != PLAYER_STATE_USER) {
                goal[playerID] = Vec3(0.0f, 0.0f, 0.0f);
                return;
        }

        if (goal[playerID].length() == 0.0f) {
                float dx = (1.0f*(float)rand() / (float)RAND_MAX - 0.5f);
                float dz = (1.0f*(float)rand() / (float)RAND_MAX - 0.5f);

                Vec3 wanted = player->pos - (player->pos - g_players[g_myPlayerID].pos).normalize()*0.5f + Vec3(dx, 0.0f, dz);

                if (!m_objLevel->collission(wanted, 0.30f)) {
                        goal[playerID] = wanted;
                }
                else {
                        int n = 0;
                        while (n++ < 10) {
                                dx = (2.0f*(float)rand() / (float)RAND_MAX - 1.0f);
                                dz = (2.0f*(float)rand() / (float)RAND_MAX - 1.0f);
                                Vec3 pos(wanted.x + dx, wanted.y, wanted.z + dz);
                                if (m_objLevel->collission(pos, 0.30f) || m_objLevel->isWater(pos)) {
                                }
                                else {
                                        goal[playerID] = pos;
                                        break;
                                }
                        }
                }
        }

        Vec3 dir = player->pos - goal[playerID];
        dir = dir.normalize()*g_frameTime*0.002f;

        player->pos -= dir;
        player->dir = dir;
        player->angle = atanf(dir.x/dir.z)*180.0f/PI + (dir.z >= 0.0f ? 0.0f : -180.0f);

        //----------- WEAPONS ------------------
        if ((player->pos - g_players[g_myPlayerID].pos).length() <= 4.00f) {

                float angle = -player->angle*PIdiv180;
                float cosA = cos(angle);
                float sinA = sin(angle);

                // throw grenade!
                if (g_time - lastGrenade[playerID] > 500.0f) {
                        Vec3 gunVec = Vec3(0.0f, 0.25f, 0.0f);
                        if (g_models[playerID].numGuns > 0) {
                                if (++gunPos[playerID] >= g_models[playerID].numGuns) gunPos[playerID] = 0;
                                
                                gunVec = g_models[playerID].guns[gunPos[playerID]];

                                Vec3 tmp = gunVec;
                                gunVec.x = tmp.x*cosA-tmp.z*sinA;
                                gunVec.z = tmp.x*sinA+tmp.z*cosA;
                        }

                        lastGrenade[playerID] = g_time + (1000.0f*(float)rand() / (float)RAND_MAX);;
                        throwGrenade(playerID, player->pos + gunVec, -player->dir*350.0f + Vec3(0.0f, 6.0f, 0.0f), 3.0f, 1.0f);
                }

                // fire projectile
                if (g_time - lastProjectile[playerID] > player->weapon.reload) {
                        Vec3 gunVec = Vec3(0.0f, 0.25f, 0.0f);
                        if (g_models[playerID].numGuns > 0) {
                                if (++gunPos[playerID] >= g_models[playerID].numGuns) gunPos[playerID] = 0;
                                
                                gunVec = g_models[playerID].guns[gunPos[playerID]];

                                Vec3 tmp = gunVec;
                                gunVec.x = tmp.x*cosA-tmp.z*sinA;
                                gunVec.z = tmp.x*sinA+tmp.z*cosA;
                        }

                        
                        lastProjectile[playerID] = g_time + (1000.0f*(float)rand() / (float)RAND_MAX);
                        fireProjectile(playerID, player->pos + gunVec, -player->dir*500.0f*player->weapon.speed, player->weapon.power);
                }
        }

        //--------------------------------------

        player->moving = true;

        if ((player->pos - goal[playerID]).length() <= 0.01f)
                goal[playerID] = Vec3(0.0f, 0.0f, 0.0f);

        //setPlayerCam(1);
}

---