blockofighter/src/fight.cpp

#include "main.h"

#include <math.h>

#include "legoblocks.h"
#include "camera.h"
#include "light.h"
#include "audio.h"
#include "object.h"
#include "appearance.h"
#include "sphere.h"
#include "vector.h"
#include "collision.h"
#include "utils.h"
#include "graphics.h"
#include "objectfactory.h"
#include "world.h"
#include "3dutils.h"
#include "legoman.h"
#include "particle.h"
#include "font.h"
#include "fight.h"
#include "menu.h"
#include "end.h"
#include "run.h"

#include "glapi.h"

Camera camera;
Light light1, light2, light3, light4;
World *arenaworld;

Sound *fightmusic;
Sound *hitsound1, *hitsound2, *hitsound3, *hitsound4;
Sound *softhitsound1, *softhitsound2;
Sound *jumpsound;
Sound *fallsound1, *fallsound2;
Sound *fightsound;
Sound *victorysound;

Legoman *man1, *man2;
int points1, points2;

#define ARENASIZE 10
#define ARENAHEIGHT 10

bool fightinitialized = false;

void initFight(void){
    if (!fightinitialized){
        initCollisions();
        addCollisionLink(COLLISIONGROUP_ARENA, COLLISIONGROUP_PARTICLE);
        //addCollisionLink(COLLISIONGROUP_PARTICLE, COLLISIONGROUP_PARTICLE);

        addCollisionLink(COLLISIONGROUP_MAN1, COLLISIONGROUP_ARENA);
        //addCollisionLink(COLLISIONGROUP_MAN1, COLLISIONGROUP_PARTICLE);
        addCollisionLink(COLLISIONGROUP_MAN1, COLLISIONGROUP_MAN1);
        addCollisionLink(COLLISIONGROUP_MAN1HAND, COLLISIONGROUP_ARENA);
        //addCollisionLink(COLLISIONGROUP_MAN1HAND, COLLISIONGROUP_PARTICLE);

        addCollisionLink(COLLISIONGROUP_MAN2, COLLISIONGROUP_ARENA);
        //addCollisionLink(COLLISIONGROUP_MAN2, COLLISIONGROUP_PARTICLE);
        addCollisionLink(COLLISIONGROUP_MAN2, COLLISIONGROUP_MAN2);
        addCollisionLink(COLLISIONGROUP_MAN2HAND, COLLISIONGROUP_ARENA);
        //addCollisionLink(COLLISIONGROUP_MAN2HAND, COLLISIONGROUP_PARTICLE);

        addCollisionLink(COLLISIONGROUP_MAN1, COLLISIONGROUP_MAN2);
        addCollisionLink(COLLISIONGROUP_MAN1, COLLISIONGROUP_MAN2HAND);
        addCollisionLink(COLLISIONGROUP_MAN1HAND, COLLISIONGROUP_MAN2);
        addCollisionLink(COLLISIONGROUP_MAN1HAND, COLLISIONGROUP_MAN2HAND);

        //Sound* backgroundsong = new Sound("mixdown.mp3");
        Sound* backgroundsong = new Sound(BGSONG, true);
        camera.setPosition(-5, 8, 18);

        arenaworld = new World();


        //arenalight.setEnabled(true);
        /*arenalight.setPosition(0, 10, 0);
        Object *lamp = new Object();
        lamp->appearance = new LampAppearance();
        lamp->setPosition(0, 10, 0);
        arenaworld->addChild(lamp);*/

    }

    light1.setColor(1, 1, 1);
    light1.setSpecular(1, 1, 1);
    light1.setPosition(-ARENASIZE+0.5, 5, -ARENASIZE+0.5);
    light1.setAttenuation(0.2, 0.0, 0.02);

    light2.setColor(1, 1, 1);
    light2.setSpecular(1, 1, 1);
    light2.setPosition(ARENASIZE-0.5, 5, -ARENASIZE+0.5);
    light2.setAttenuation(0.2, 0.0, 0.02);

    light3.setColor(1, 1, 1);
    light3.setSpecular(1, 1, 1);
    light3.setPosition(-ARENASIZE+0.5, 5, ARENASIZE-0.5);
    light3.setAttenuation(0.2, 0.0, 0.02);

    light4.setColor(1, 1, 1);
    light4.setSpecular(1, 1, 1);
    light4.setPosition(ARENASIZE-0.5, 5, ARENASIZE-0.5);
    light4.setAttenuation(0.2, 0.0, 0.02);


    if (!fightinitialized){
        Object *lamp;

        lamp = new Object();
        lamp->appearance = new LampAppearance();
        lamp->setPosition(-ARENASIZE+0.5, (ARENAHEIGHT+0.5)*BLOCKHEIGHT, -ARENASIZE+0.5);
        arenaworld->addChild(lamp);

        lamp = new Object();
        lamp->appearance = new LampAppearance();
        lamp->setPosition(ARENASIZE-0.5, (ARENAHEIGHT+0.5)*BLOCKHEIGHT, -ARENASIZE+0.5);
        arenaworld->addChild(lamp);

        lamp = new Object();
        lamp->appearance = new LampAppearance();
        lamp->setPosition(-ARENASIZE+0.5, (ARENAHEIGHT+0.5)*BLOCKHEIGHT, ARENASIZE-0.5);
        arenaworld->addChild(lamp);

        lamp = new Object();
        lamp->appearance = new LampAppearance();
        lamp->setPosition(ARENASIZE-0.5, (ARENAHEIGHT+0.5)*BLOCKHEIGHT, ARENASIZE-0.5);
        arenaworld->addChild(lamp);


        //Floor
        BasicBlock *floorblock;
        floorblock = new BasicBlock(ARENASIZE*2, 3, ARENASIZE*2);
        floorblock->setPosition(0, -BLOCKHEIGHT*3/2.0, 0);
        floorblock->setColor(0, 1, 0);
        floorblock->setCollisionGroup(COLLISIONGROUP_ARENA);
        arenaworld->addChild(floorblock);


        //Corners
        BasicBlock *arenacorner;

        arenacorner = new BasicBlock(1, ARENAHEIGHT, 1);
        arenacorner->setColor(1, 0, 0);
        //arenacorner->setCollisionGroup(COLLISIONGROUP_ARENA);
        arenacorner->setPosition(ARENASIZE-0.5, BLOCKHEIGHT*ARENAHEIGHT/2.0, ARENASIZE-0.5);
        arenaworld->addChild(arenacorner);

        arenacorner = new BasicBlock(1, ARENAHEIGHT, 1);
        arenacorner->setColor(1, 0, 0);
        //arenacorner->setCollisionGroup(COLLISIONGROUP_ARENA);
        arenacorner->setPosition(-ARENASIZE+0.5, BLOCKHEIGHT*ARENAHEIGHT/2.0, ARENASIZE-0.5);
        arenaworld->addChild(arenacorner);

        arenacorner = new BasicBlock(1, ARENAHEIGHT, 1);
        arenacorner->setColor(1, 0, 0);
        //arenacorner->setCollisionGroup(COLLISIONGROUP_ARENA);
        arenacorner->setPosition(ARENASIZE-0.5, BLOCKHEIGHT*ARENAHEIGHT/2.0, -ARENASIZE+0.5);
        arenaworld->addChild(arenacorner);

        arenacorner = new BasicBlock(1, ARENAHEIGHT, 1);
        arenacorner->setColor(1, 0, 0);
        //arenacorner->setCollisionGroup(COLLISIONGROUP_ARENA);
        arenacorner->setPosition(-ARENASIZE+0.5, BLOCKHEIGHT*ARENAHEIGHT/2.0, -ARENASIZE+0.5);
        arenaworld->addChild(arenacorner);


        //"Ropes"
        MeshObject *arenaline;
        Mesh *linegeometry;
        MultiAppearance *lineappearance;
        BasicBlockAppearance *line;
        int geometryheight = BLOCKHEIGHT*ARENAHEIGHT;

        linegeometry = createBox(-0.5, 0.5, -geometryheight/2, geometryheight/2-BLOCKHEIGHT, -ARENASIZE, ARENASIZE);
        arenaline = new MeshObject(linegeometry);
        lineappearance = new MultiAppearance();
        line = new BasicBlockAppearance(1, 1, ARENASIZE*2);
        vectorSet(line->displacement, 0, -BLOCKHEIGHT*2.5, 0);
        line->material.setColor(1, 0, 0, 1);
        lineappearance->addAppearance(line),
        line = new BasicBlockAppearance(1, 1, ARENASIZE*2);
        vectorSet(line->displacement, 0, BLOCKHEIGHT*0.5, 0);
        line->material.setColor(1, 0, 0, 1);
        lineappearance->addAppearance(line),
        line = new BasicBlockAppearance(1, 1, ARENASIZE*2);
        vectorSet(line->displacement, 0, BLOCKHEIGHT*3.5, 0);
        line->material.setColor(1, 0, 0, 1);
        lineappearance->addAppearance(line),
        arenaline->appearance = lineappearance;
        arenaline->setCollisionGroup(COLLISIONGROUP_ARENA);
        arenaline->setPosition(-ARENASIZE+0.5, geometryheight/2, 0);
        arenaworld->addChild(arenaline);

        linegeometry = createBox(-0.5, 0.5, -geometryheight/2, geometryheight/2-BLOCKHEIGHT, -ARENASIZE, ARENASIZE);
        arenaline = new MeshObject(linegeometry);
        lineappearance = new MultiAppearance();
        line = new BasicBlockAppearance(1, 1, ARENASIZE*2);
        vectorSet(line->displacement, 0, -BLOCKHEIGHT*2.5, 0);
        line->material.setColor(1, 0, 0, 1);
        lineappearance->addAppearance(line),
        line = new BasicBlockAppearance(1, 1, ARENASIZE*2);
        vectorSet(line->displacement, 0, BLOCKHEIGHT*0.5, 0);
        line->material.setColor(1, 0, 0, 1);
        lineappearance->addAppearance(line),
        line = new BasicBlockAppearance(1, 1, ARENASIZE*2);
        vectorSet(line->displacement, 0, BLOCKHEIGHT*3.5, 0);
        line->material.setColor(1, 0, 0, 1);
        lineappearance->addAppearance(line),
        arenaline->appearance = lineappearance;
        arenaline->setCollisionGroup(COLLISIONGROUP_ARENA);
        arenaline->setPosition(ARENASIZE-0.5, geometryheight/2, 0);
        arenaworld->addChild(arenaline);

        linegeometry = createBox(-ARENASIZE, ARENASIZE, -geometryheight/2, geometryheight/2-BLOCKHEIGHT, -0.5, 0.5);
        arenaline = new MeshObject(linegeometry);
        lineappearance = new MultiAppearance();
        line = new BasicBlockAppearance(ARENASIZE*2, 1, 1);
        vectorSet(line->displacement, 0, -BLOCKHEIGHT*2.5, 0);
        line->material.setColor(1, 0, 0, 1);
        lineappearance->addAppearance(line),
        line = new BasicBlockAppearance(ARENASIZE*2, 1, 1);
        vectorSet(line->displacement, 0, BLOCKHEIGHT*0.5, 0);
        line->material.setColor(1, 0, 0, 1);
        lineappearance->addAppearance(line),
        line = new BasicBlockAppearance(ARENASIZE*2, 1, 1);
        vectorSet(line->displacement, 0, BLOCKHEIGHT*3.5, 0);
        line->material.setColor(1, 0, 0, 1);
        lineappearance->addAppearance(line),
        arenaline->appearance = lineappearance;
        arenaline->setCollisionGroup(COLLISIONGROUP_ARENA);
        arenaline->setPosition(0, geometryheight/2, -ARENASIZE+0.5);
        arenaworld->addChild(arenaline);

        linegeometry = createBox(-ARENASIZE, ARENASIZE, -geometryheight/2, geometryheight/2-BLOCKHEIGHT, -0.5, 0.5);
        arenaline = new MeshObject(linegeometry);
        lineappearance = new MultiAppearance();
        line = new BasicBlockAppearance(ARENASIZE*2, 1, 1);
        vectorSet(line->displacement, 0, -BLOCKHEIGHT*2.5, 0);
        line->material.setColor(1, 0, 0, 1);
        lineappearance->addAppearance(line),
        line = new BasicBlockAppearance(ARENASIZE*2, 1, 1);
        vectorSet(line->displacement, 0, BLOCKHEIGHT*0.5, 0);
        line->material.setColor(1, 0, 0, 1);
        lineappearance->addAppearance(line),
        line = new BasicBlockAppearance(ARENASIZE*2, 1, 1);
        vectorSet(line->displacement, 0, BLOCKHEIGHT*3.5, 0);
        line->material.setColor(1, 0, 0, 1);
        lineappearance->addAppearance(line),
        arenaline->appearance = lineappearance;
        arenaline->setCollisionGroup(COLLISIONGROUP_ARENA);
        arenaline->setPosition(0, geometryheight/2, ARENASIZE-0.5);
        arenaworld->addChild(arenaline);

        float movement[3];

        man1 = new Legoman(PLAYER1);
        man1->insertToWorld(arenaworld);
        vectorSet(movement, -4, 0, 0);
        man1->move(movement);
        man1->lockPart(LEFTLEG | RIGHTLEG);

        man2 = new Legoman(PLAYER2);
        man2->insertToWorld(arenaworld);
        vectorSet(movement, 4, 0, 0);
        man2->move(movement);
        man2->lockPart(LEFTLEG | RIGHTLEG);

        man1->addOpponent(man2);
        man2->addOpponent(man1);


        initBloods(arenaworld);


        hitsound1 = new Sound(DATAPATH"hit1.wav");
        softhitsound1 = new Sound(DATAPATH"hitsoft1.wav");
        softhitsound2 = new Sound(DATAPATH"hitsoft2.wav");
        jumpsound = new Sound(DATAPATH"jump.wav");
        fallsound1 = new Sound(DATAPATH"fall1.wav");
        fallsound2 = new Sound(DATAPATH"fall2.wav");
        fightsound = new Sound(DATAPATH"fight.wav");
        victorysound = new Sound(DATAPATH"victory.wav");

        fightmusic = new Sound(DATAPATH"fight.mp3", true);
    }

    float cameraTarget[3] = {0, 6, 0};
    camera.setTarget(cameraTarget);
    arenaworld->prepare();

    points1 = 0;
    points2 = 0;

    winner = man1;
}

#define MAXSCORE 3

int trophycounter = -1;

void resetFight(void){
    float movement[3];
    man1->heal();
    man2->heal();

    vectorSet(movement, -4, 0, 0);
    man1->move(movement);
    vectorSet(movement, 4, 0, 0);
    man2->move(movement);

    man1->lockPart(LEFTLEG | RIGHTLEG);
    man2->lockPart(LEFTLEG | RIGHTLEG);
}

int startcounter, endcounter;

float fightfade;

bool dead;

Legoman *winner;

void gameOver(Legoman *loser){
    endcounter = 0;
    dead = true;
    winner = loser->getOpponent();
}

void startFight(void){
    resetFight();
    fightmusic->setVolume(0);
    fightmusic->play();
    fightmusic->fadeIn(300);
    startcounter = 0;
    trophycounter = -1;
    fightfade = 1;
    dead = false;
    points1 = 0;
    points2 = 0;
}

SDLKey player1left = SDLK_LEFT;
SDLKey player1right = SDLK_RIGHT;
SDLKey player1forward = SDLK_UP;
SDLKey player1backward = SDLK_DOWN;
SDLKey player1jump = SDLK_RSHIFT;
SDLKey player1hit = SDLK_RCTRL;

SDLKey player2left = SDLK_a;
SDLKey player2right = SDLK_d;
SDLKey player2forward = SDLK_w;
SDLKey player2backward = SDLK_s;
SDLKey player2jump = SDLK_LSHIFT;
SDLKey player2hit = SDLK_LCTRL;


void stopGame(void){
    light1.setEnabled(false);
    light2.setEnabled(false);
    light3.setEnabled(false);
    light4.setEnabled(false);
    changeGameMode(MENUMODE);
    fightmusic->fadeOut(300);
    menuRestart();
}

void endGame(void){
    trophycounter = 0;
}

void endGame2(void){
    light1.setEnabled(false);
    light2.setEnabled(false);
    light3.setEnabled(false);
    light4.setEnabled(false);
    changeGameMode(ENDMODE);
    winner->heal();
    endRestart();
}

#define READY 250
#define FIGHT 500
#define VICTORY 300
#define VICTORYEND 700
#define ENDFADE 780
#define STARTOVER 800

#define TROPHYFADE 400

void calculateFight(int framecount){
    fightfade = -1;
    if (startcounter < 200){
        fightfade = (200-startcounter)/200.0;
    }
    if (startcounter == FIGHT - 30){
        fightsound->play();
    }
    startcounter++;

    if (endcounter == VICTORY){
        victorysound->play();
        if (winner == man1) points1++;
        if (winner == man2) points2++;
    }
    if (endcounter >= ENDFADE && endcounter <= STARTOVER){
        fightfade = (endcounter - ENDFADE)/(STARTOVER-ENDFADE);
    }
    if (endcounter == STARTOVER){
        if (points1 == MAXSCORE || points2 == MAXSCORE){
            endGame();
        } else{
            startcounter = 0;
            resetFight();
            dead = false;
            endcounter = 0;
        }
    }
    if (dead)	endcounter++;
    if (trophycounter != -1){
        fightfade = (float)trophycounter/TROPHYFADE;
        trophycounter++;
        if (trophycounter == TROPHYFADE) endGame2();
    }

    /*if (framecount % 10 == 0){
        float pos[3] = {0, 5, 0};
        float vel[3] = {randomf(2)-1, randomf(2)-1, randomf(2)-1};
        createBlood(pos, vel);
    }*/
    //arenalight.setPosition(sin(framecount*0.01)*6, 3, cos(framecount*0.01)*4);
    //light2.setPosition(sin(framecount*0.017)*6, 2, cos(framecount*0.027)*5);
    //light3.setPosition(sin(framecount*0.023)*3, 4, cos(framecount*0.013)*3);

    camera.setPosition(sin(framecount*0.0005)*20, sin(framecount*0.0013)*5+15, cos(framecount*0.0005)*20);

    //camera.setPosition(8, 5, 5);

    float upmovement[3] = {0, 0.001, 0};
    man1->move(upmovement);
    man2->move(upmovement);
    man1->update();
    man2->update();

    if (startcounter >= FIGHT){

        if (man1->isAlive()){
            if (keys[player1left]) man1->turn(5);
            if (keys[player1right]) man1->turn(-5);
            if (keys[player1forward]) man1->walk(0.03);
            if (keys[player1backward]) man1->walk(-0.03);
            if (keys[player1jump]) man1->jump();
            if (keys[player1hit]) man1->hit();
        }

        if (man2->isAlive()){
            if (keys[player2left]) man2->turn(5);
            if (keys[player2right]) man2->turn(-5);
            if (keys[player2forward]) man2->walk(0.03);
            if (keys[player2backward]) man2->walk(-0.03);
            if (keys[player2jump]) man2->jump();
            if (keys[player2hit]) man2->hit();
        }
    }


    if (keys[SDLK_ESCAPE]){
        stopGame();
    }


    arenaworld->move();
}

void drawDamageMeters(void){
    enable2D();

    glEnable(GL_BLEND);

    glPushMatrix();
    glTranslatef(0.925, 0.22-0.025, 0);
    glScalef(0.08*3/4, 0.08, 0.1);
    man1->drawVisuals();
    glPopMatrix();

    glPushMatrix();
    glTranslatef(0.075, 0.22-0.025, 0);
    glScalef(0.08*3/4, 0.08, 0.1);
    man2->drawVisuals();
    glPopMatrix();

    glDisable(GL_TEXTURE_2D);


    glColor3f(1, 1, 0);

    char pointstring[5];
    sprintf(pointstring, "%i", points1);
    print(0.75, 0.05, pointstring, 0.15);

    sprintf(pointstring, "%i", points2);
    print(0.15, 0.05, pointstring, 0.15);

    disable2D();
}

void drawFight(int framecount){
    glLoadIdentity();
    camera.glUpdate();
    //float position[3];
    //camera.getPosition((float*)position);
    //createSkyBox(position[0], position[1], position[2], 50, 20, 50);

    createSkyBox(0, 10, 0, 50, 20, 50);


    light1.setEnabled(true);
    light2.setEnabled(true);
    light3.setEnabled(true);
    light4.setEnabled(true);

    updateLights();

    arenaworld->draw();

    drawDamageMeters();


    flaretexture->enable();
    light1.createFlare();
    light2.createFlare();
    light3.createFlare();
    light4.createFlare();
    flaretexture->disable();


    enable2D();

    if (fightfade != -1){
        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glColor4f(0, 0, 0, fightfade);
        glBegin(GL_QUADS);
            glVertex2f(0, 0);
            glVertex2f(1, 0);
            glVertex2f(1, 1);
            glVertex2f(0, 1);
        glEnd();
    }

    if (startcounter >= READY && startcounter < FIGHT){
        float size = 0.2 - (startcounter - READY)*0.0001;
        float alpha = 1 - (float)(startcounter - READY)/(FIGHT - READY);
        float x = 0.5 - size*1.5;
        float y = 0.5 - size*0.5;

        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glColor4f(alpha, 0, 0, alpha);
        print(x, y, "Ready", size);
    }
    if (startcounter >= FIGHT && startcounter < FIGHT+200){
        float size = 0.2 + (startcounter - FIGHT)*0.0005;
        float alpha = 1 - (float)(startcounter - FIGHT)/200;
        float x = 0.5 - size*1.4;
        float y = 0.5 - size*0.5;

        glEnable(GL_BLEND);
        glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        glColor4f(0, alpha, 0, alpha);
        print(x, y, "Fight!", size);
    }

    if (dead){
        if (endcounter >= VICTORY && endcounter < VICTORYEND){
            float size = 0.18 + (endcounter - VICTORY)*0.0001;
            float alpha = (float)(endcounter - VICTORY)/(VICTORYEND-VICTORY);
            alpha = 1-4*(alpha-0.5)*(alpha-0.5);
            alpha = pow(alpha, 0.5);
            float x = 0.5 - size*1.9;
            float y = 0.3 - size*0.5;

            glEnable(GL_BLEND);
            glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
            glColor4f(0, 0, alpha, alpha);
            print(x, y, "Victory!", size);
        }
    }

    disable2D();


    glDisable(GL_BLEND);
    glEnable(GL_DEPTH_TEST);
}