/*
 *   (C) COPYRIGHT Vincent S. Cojot and others 1996-1997
 *   All Rights Reserved
 *   Licensed Materials - Property of Vincent S. Cojot and others.
 *   Use, duplication or disclosure restricted by Vincent S. Cojot.
 */
#include <GL/gl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/time.h>
#include <math.h>

#ifdef USING_MESA  
#include <glaux.h>
#else
#include <aux.h>
#endif

#include "defines.h"
#include "collisions.h"


/***************************************************************/
/* Fonction principale de la gestion des collisions. C'est a elle */
/* que revient la tache de determiner si il y a collision et, dans */
/* ce cas, quelle fonction de gestion des collisions il faut appeller. */
/***************************************************************/
GLvoid VerifierCollision(GLvoid)
{
    /* Reduit la taille du monde connu a un carre de 40x40 pour faire des */
    /* hypotheses sur les collisions */
    ReduceWorldSize();

    /* Calcule la distance du mobile au centre du carre local. */
    RCdistance = hypot (RscenePosx, RscenePosz);

    if ( VerifyClose(13) ) {
        #ifdef DEBUG
        printf("Not close..........\n");
        #endif
        WasInside = 0;
    } else {

        /* Calcule la distance du mobile au centre du monde virtuel. */
        Cdistance = hypot (scenePosx, scenePosz);

        if ( Cdistance < 13 ) {
            #ifdef DEBUG
            printf("Cylindre...\n");
            #endif
            if (WasInside == 0)
                BangOnCylinder();
        } else {

            if ( !VerifyVeryClose(8) ) {

                if ( VerifyOutOfThisWorld() ) {

                    if ( VerifyEvenOrOdd() ) {
                        #ifdef DEBUG
                        printf("PRISME..\n");
                        #endif
                        if (WasInside == 0)
                            BangOnPrism();
                    } else {
                        #ifdef DEBUG
                        printf("CUBE..\n");
                        #endif
                        if (WasInside == 0)
                            BangOnCube();
                    }

                } else {
                    WasInside = 0;
                    #ifdef DEBUG
                    printf ("Out of this world.\n");
                    #endif
                }

            } else {
                WasInside = 0;
            }

        }

    }

#ifdef DEBUG
    printf("Xpos: %.2f ,", scenePosx);
    printf("Zpos: %.2f ,", scenePosz);
    printf("RXpos: %.2f ,", RscenePosx);
    printf("RZpos: %.2f\n", RscenePosz);
#endif
}

/***************************************************************/
/* Fonction de determination de la position de depart. */
/* C'est une troisieme version de l'algorithme de collision qui */
/* renvoie la valeur VRAI si on est dans un object, FALSE autrement. */
/***************************************************************/
GLint  FindStartupPosition(GLvoid)
{
    /* utilise le nombre de micro-secondes de l'heure actuelle pour */
    /* servir de nombre aleatoire. */
    gettimeofday( &temps2, NULL);
    
    /* Utilise le nombre aleatoire obtenu pour generer une source de */
    /* nombres pseudo-aleatoires. */
    srand(temps2.tv_usec);

    /* Utilise un premier nombre aleatoire. */
    RandomscenePosx  = fmod(cos(rand())*rand()/150, 150);

    /* Utilise un deuxieme nombre aleatoire. */
    RandomscenePosz  = fmod(sin(rand())*rand()/150, 150);

    /* Utilise un troisieme nombre aleatoire. */
    RandomsceneAngle = fmod(tan(rand())*rand()/180, 180) + 180.0;

    #ifdef DEBUG
    printf("Angle: %.2f\n", RandomsceneAngle);
    #endif

    /* Reduit la taille du monde connu a un carre de 40x40 pour faire des */
    /* hypotheses sur les collisions. Cf ReduceWorldSize(); */
    RscenePosx = RandomscenePosx
               - ceil( (RandomscenePosx - 20.0) /40.0 )*40.0 ;
    RscenePosz = RandomscenePosz
               - ceil( (RandomscenePosz - 20.0) /40.0 )*40.0 ;

    /* Calcule la distance du mobile au centre du carre local. */
    RCdistance = hypot (RscenePosx, RscenePosz);

    if ( VerifyClose(13) ) {
                /* Position non dans un objet. */
    } else {

        /* Calcule la distance du mobile au centre du monde virtuel. */
        Cdistance = hypot (RandomscenePosx, RandomscenePosz);

        if ( Cdistance < 13 ) {
            return 1;
        } else {

            if ( !VerifyVeryClose(8) ) {

                if ( VerifyOutOfThisWorldGeneric() ) {

                    if ( VerifyEvenOrOdd() ) {
                        return 1;
                    } else {
                        return 1;
                    }

                } else {
                    /* Position non dans un objet. */
                }

            } else {
                /* Position non dans un objet. */
            }

        }

    }

    /* Il faut maintenant verifier les collisions avec les autres Tanks */
    /* et les epaves de nos victimes.. */

    /* Pour tous les tanks possibles..*/
    for (j=0; j<MAX_TANKS; j++)
    {
        /* Si le tank est valide...*/                    
        if ( Tanks[j].Valid ) {

            if ( hypot (RandomscenePosx - Tanks[j].Posx
                      , RandomscenePosz - Tanks[j].Posz) < 6.0 ) {
                return 1;
            }
        }
    }

    /* Pour toutes les epaves de tanks possibles..*/
    for (j=0; j<MAX_TANKS; j++)
    {
        /* Si le tank est valide...*/                    
        if ( DestroyedTanks[j].Valid ) {

            if ( hypot (RandomscenePosx - DestroyedTanks[j].Posx
                      , RandomscenePosz - DestroyedTanks[j].Posz) < 6.0 ) {
                return 1;
            }
        }
    }

    /* Verifie les collisions avec notre propre tank.. */
    if ( hypot (RandomscenePosx - scenePosx
              , RandomscenePosz - scenePosz) < 6.0 ) {
        return 1;
    }

    /* On n'est pas sorti, donc il n'y a pas eu de collisions avec */
    /* qui que ce soit.. on peut donc dire que la situation est bonne */
    /* et sortir avec un code d'erreur de 0. */

    return 0;

}


/***************************************************************/
/* Fonction servant au deplacement du missile et verifiant ses 
collisions. */
/* Cette fonction sert aussi a gerer les explosions eventuelles des obus */
/* de notre propre Tank. */
/***************************************************************/
GLvoid MoveMyMissile(GLvoid)
{
    #ifdef DEBUG
    printf("Missile!!!!\n");
    #endif

    Missiles[0].Incx = TimeTravel
                  * sin ( Missiles[0].Angle * PI / 180)
                  * MISSILE_SPEED / MISSILE_SLICE_INTERVALS ;
    Missiles[0].Incz = TimeTravel
                  * cos ( Missiles[0].Angle * PI / 180)
                  * MISSILE_SPEED / MISSILE_SLICE_INTERVALS ;

    /* Si le missile est en vol depuis plus de MAX_MISSILE_AGE secondes */
    /* alors il faut le detruire..*/
    if ( Missiles[0].Age <= MAX_MISSILE_AGE ) {
        Missiles[0].Age += TimeTravel;
    } else {
        if ( Missiles[0].Valid ) {
            Missiles[0].Valid = 0;
            MyFlyingMissile = 0;
            FlyingMissile--;
        }
    }


    for (i=1; i <= MISSILE_SLICE_INTERVALS; i++)
    {

        /* Si notre missile est encore en Vol. */
        if ( Missiles[0].Valid ) {

            /* Incrementation de la position partielle du Missile */
            Missiles[0].Posx += Missiles[0].Incx;
            Missiles[0].Posz += Missiles[0].Incz;

            /* Reduit la taille du monde connu a un carre de 40x40 pour faire*/
            /* des hypotheses sur les collisions */
            ReduceMissileWorldSize(0);

            /* Calcule la distance du mobile au centre du carre local. */
            RCdistance = hypot (RscenePosx, RscenePosz);

            if ( VerifyClose(11) ) {
                /* Pas de collision pour le Missile */;
            } else {

                /* Calcule la distance du mobile au centre du monde virtuel. */
                Cdistance = hypot (Missiles[0].Posx,
                                   Missiles[0].Posz);

                if ( Cdistance < 11 ) {
                    Missiles[0].Posx -= EXPLOSION_BACKWARD_FACTOR
                                         *Missiles[0].Incx;
                    Missiles[0].Posz -= EXPLOSION_BACKWARD_FACTOR
                                         *Missiles[0].Incz;
                    ExplodeMissile(0,0);
                } else {

                    if ( !VerifyVeryClose(6) ) {

                        if ( VerifyOutOfThisWorldMissile(0) ) {
                            Missiles[0].Posx -= EXPLOSION_BACKWARD_FACTOR
                                                 *Missiles[0].Incx;
                            Missiles[0].Posz -= EXPLOSION_BACKWARD_FACTOR
                                                 *Missiles[0].Incz;
                            ExplodeMissile(0,0);
                        } else {
                            /* Pas de collision pour le Missile */;
                        }

                    } else {
                        /* Pas de collision pour le Missile */;
                    }

                }

            }

            /* Notre missile n'a rien touche mais on doit verifier */
            /* maintenant si il n'est pas en train de detruire un Tank. */

            /* Pour tous les tanks possibles..*/
            for (j=0; j<MAX_TANKS; j++)
            {

                /* Si le tank est valide...*/                    
                if ( Tanks[j].Valid ) {

                    /* Verifie les collisions avec notre tank car on ne doit */
                    /* pas pouvoir rentrer dans les debris des autres tanks.. */
                    if ( hypot (Missiles[0].Posx - Tanks[j].Posx
                              , Missiles[0].Posz - Tanks[j].Posz) < 3.0 ) {

                    ExplodeMissile(0,j+1);
                    ExplodeTank(j);
                    }

                }

            } /* for j */

        }

    } /* for i */

}


/***************************************************************/
/* Fonction servant a l'affichage de tous les missiles en vol. */
/***************************************************************/
GLvoid MoveMissiles(GLvoid)
{
    #ifdef DEBUG
    printf("Missile!!!!\n");
    #endif

    for (j=0; j<MAX_MISSILES; j++)
    {

        if ( Missiles[j].Valid ) {

            if ( mode ) {
                glPushMatrix();
                    glTranslated( -Missiles[j].Posx, -1.0, -Missiles[j].Posz );

                    ThetaSecond = OrienteMissile( Missiles[j].Posx - scenePosx,
                                              Missiles[j].Posz - scenePosz,
                                              Missiles[j].Incx,
                                              Missiles[j].Incz ) - 180;

                    glRotated(ThetaSecond+Missiles[j].Angle, 0.0, 1.0, 0.0);

                    glBegin(GL_LINE_STRIP);
                        glVertex3f ( -1.0 , 0.0, 0.0);
                        glVertex3f ( -1.0 , 2.0, 0.0);
                        glVertex3f (  1.0 , 2.0, 0.0);
                        glVertex3f (  1.0 , 0.0, 0.0);
                        glVertex3f ( -1.0 , 0.0, 0.0);
                    glEnd();

                    #ifdef DEBUG
                    glCallList(ALL_MY_RED_WIRE_TANK); */
                    #endif

                glPopMatrix();
            } else {
                glPushMatrix();
                    glTranslated( -Missiles[j].Posx, -1.0, -Missiles[j].Posz );
                    glRotated(Missiles[j].Angle, 0.0, 1.0, 0.0);

                    ThetaSecond = OrienteMissile( Missiles[j].Posx - scenePosx,
                                              Missiles[j].Posz - scenePosz,
                                              Missiles[j].Incx,
                                              Missiles[j].Incz ) -180;

                    /* Selection de l'image a afficher. */
                    a = (GLint) (fabs (-0.5 + 14.0 * ThetaSecond / 360.0) );

                    glRotated(ThetaSecond, 0.0, 1.0, 0.0);   
                    glEnable(GL_ALPHA_TEST);
                    glAlphaFunc(GL_GREATER,0.0);
                    glEnable(GL_TEXTURE_2D);
                    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,
                              GL_MODULATE);
                    glTexImage2D(GL_TEXTURE_2D, 0, 4, MissImageWidth,
                        MissImageHeight, 0, GL_RGBA, GL_FLOAT,
                        &MissileImages[a][0][0][0]);
                    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
                                    GL_CLAMP);
                    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
                                    GL_CLAMP);
                    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
                                    GL_NEAREST);
                    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
                                    GL_NEAREST);

                    glColor4f(1, 1, 1, 1);
                    glBegin(GL_QUADS);
                        glTexCoord2f(0.0, -1.5); glVertex3f ( -1.0 , 0.0, 0.0);
                        glTexCoord2f(0.0, 2.5) ; glVertex3f ( -1.0 , 2.0, 0.0);
                        glTexCoord2f(1.0, 2.5) ; glVertex3f (  1.0 , 2.0, 0.0);
                        glTexCoord2f(1.0, -1.5); glVertex3f (  1.0 , 0.0, 0.0);
                    glEnd();

                    glDisable(GL_TEXTURE_2D);
                    glDisable(GL_ALPHA_TEST);

                    #ifdef DEBUG
                    glCallList(ALL_MY_RED_SOLID_TANK);
                    #endif

                glPopMatrix();
            }

        }

    } /* for j */

}


/*************************************************/
/* Fonction de gestion de tous les autres Tanks .*/
/*************************************************/
GLvoid  MoveTanks(GLvoid)
{
    /* Pour tous les tanks possibles..*/
    for (j=0; j<MAX_TANKS; j++)
    {

        /* Si le tank est valide...*/                    
        if ( Tanks[j].Valid ) {

            /* suivant le mode d'affichage, dessine le tank adapte. */
            glPushMatrix();
                glTranslated( -Tanks[j].Posx, -2.0, -Tanks[j].Posz );
                glRotated(Tanks[j].Angle, 0.0, 1.0, 0.0);
                if ( mode ) {
                    glCallList(ALL_MY_RED_WIRE_TANK);
                } else {
                    glCallList(ALL_MY_RED_SOLID_TANK);
                }

            glPopMatrix();

            glPushMatrix();
            glPushAttrib(GL_COLOR_BUFFER_BIT);
                /* affiche des informations sur les tanks enemis.*/
                if (ShowNames) {
                    if ( hypot(scenePosx - Tanks[j].Posx,
                               scenePosz - Tanks[j].Posz )
                         <= RADAR_IDENTIFICATION_DISTANCE ) {

                        glDisable(GL_FOG);

                        /* Meme couleur que les messages d'information. */
                        glColor3f(0.15, 0.90, 0.70);
                        glRasterPos3f(-Tanks[j].Posx, 2.0, -Tanks[j].Posz);
                        auxDrawStr(Tanks[j].Name);

                        if (Fog) {
                            glEnable(GL_FOG);
                        }
                    }
                }
            glPopAttrib();
            glPopMatrix();

            /* Verifie les collisions avec notre tank car on ne doit */
            /* pas pouvoir rentrer dans les autres tanks.. */
            if ( hypot (scenePosx - Tanks[j].Posx
                      , scenePosz - Tanks[j].Posz) < 6.0 ) {
                if (!WasInside)
                    LongSpeed = -LongSpeed;
                    WasInside = 1;
            }

        }

    } /* for j */

}

/*************************************************/
/* Fonction de gestion des debris de tous les autres Tanks .*/
/*************************************************/
GLvoid  MoveDestroyedTanks(GLvoid)
{
    /* Pour tous les tanks possibles..*/
    for (j=0; j<MAX_DESTROYED_TANKS; j++)
    {

        /* Si le tank est valide...*/                    
        if ( DestroyedTanks[j].Valid ) {

            /* suivant le mode d'affichage, dessine les debris adaptes. */
            glPushMatrix();
                glTranslated( -DestroyedTanks[j].Posx,
                              -2.0,
                              -DestroyedTanks[j].Posz );
                glRotated(DestroyedTanks[j].Angle, 0.0, 1.0, 0.0);
                /* selon le mode d'affichage.. */
                if ( mode ) { 
                    /* Si le tank vient d'etre detruit.. */
                    /* affiche le tank enemi non encore detruit. */
                    if (DestroyedTanks[j].Destroyed) {
                        glCallList(ALL_MY_RED_WIRE_TANK);
                        if (DestroyedTanks[j].Destroyed >= DESTRUCTION_DELAY) {
                            DestroyedTanks[j].Destroyed = 0;
                        } else {
                            DestroyedTanks[j].Destroyed++;
                        }
                    } else {
                        glTranslated( 0.0, -0.3, 0.0);
                        /* Le tank est detruit donc il est un peu remue.. :) */
                        glRotated(-3, 0.0, 0.0, 1.0);
                        glRotated(-5, 1.0, 0.0, 0.0);
                        glCallList(WIRE_DESTROYED_TANK);
                    }
                } else {
                    /* Si le tank vient d'etre detruit.. */
                    /* affiche le tank enemi non encore detruit. */
                    if (DestroyedTanks[j].Destroyed) {
                        glCallList(ALL_MY_RED_SOLID_TANK);
                        if (DestroyedTanks[j].Destroyed >= DESTRUCTION_DELAY) {
                            DestroyedTanks[j].Destroyed = 0;
                        } else {
                            DestroyedTanks[j].Destroyed++;
                        }
                    } else {
                        glTranslated( 0.0, -0.3, 0.0);
                        /* Le tank est detruit donc il est un peu remue.. :) */
                        glRotated(-3, 0.0, 0.0, 1.0);
                        glRotated(-5, 1.0, 0.0, 0.0);   
                        glCallList(SOLID_DESTROYED_TANK);
                    }
                }
            glPopMatrix();
 
            /* Verifie les collisions avec notre tank car on ne doit */
            /* pas pouvoir rentrer dans les autres tanks.. */
            if ( hypot (scenePosx - DestroyedTanks[j].Posx
                      , scenePosz - DestroyedTanks[j].Posz) < 6.0 ) {
                if (!WasInside)
                    LongSpeed = -LongSpeed;
                    WasInside = 1;
            }

        }

    } /* for j */

}



/***************************************************************/
/* La fonction CallAnExplosion( Explosx, Explosy, Explosz) fait */
/* apparaitre une explosion au point ( Explosx, Explosy, Explosz). */
/***************************************************************/
GLvoid CallAllExplosions()
{

    for (j=0; j<MAX_EXPLOSIONS; j++)
    {

        if ( Explosions[j].Valid ) {

            glPushMatrix();
                glTranslated( Explosions[j].x,
                              Explosions[j].y,
                              Explosions[j].z );
                if ( Explosions[j].Age < NB_OF_EXPL_TEXTURES) {
                    if ( mode ) {
                        if ( Explosions[j].Age < 10) {
                            glCallList(EXPLOSION_BASE+Explosions[j].Age*10);
                        }
                    } else {
                        ThetaSecond = OrienteMissile(
                                      Explosions[j].x + scenePosx,
                                      Explosions[j].z + scenePosz,
                                      0 ,
                                      1);

                        glRotated(ThetaSecond, 0.0, 1.0, 0.0);

                        glScalef (Explosions[j].Age/1.5,
                                  Explosions[j].Age/1.5,
                                  Explosions[j].Age/1.5);


                        glEnable(GL_ALPHA_TEST);
                        glEnable(GL_BLEND);
                        glBlendFunc(GL_ONE,GL_ONE_MINUS_SRC_ALPHA);
                        glAlphaFunc(GL_GREATER,0.0);
                        glEnable(GL_TEXTURE_2D);
                        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,
                                  GL_MODULATE);

                        glTexImage2D(GL_TEXTURE_2D, 0, 4, ExplImageWidth,
                            ExplImageHeight, 0, GL_RGBA, GL_FLOAT,
                            &ExplosionImages[(int)Explosions[j].Age][0][0][0]);

                        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
                                        GL_CLAMP);
                        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
                                        GL_CLAMP);
                        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
                                        GL_NEAREST);
                        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
                                        GL_NEAREST);

                        glColor4f(1, 1, 1, 1);
                        glBegin(GL_QUADS);
                            glTexCoord2f( 0.0, 0.0);
                            glVertex3f ( -1.0 , -1.0, 0.0);
                            glTexCoord2f( 0.0, 1.0);
                            glVertex3f ( -1.0 , 1.0, 0.0);
                            glTexCoord2f( 1.0, 1.0);
                            glVertex3f (  1.0 , 1.0, 0.0);
                            glTexCoord2f( 1.0, 0.0);
                            glVertex3f (  1.0 , -1.0, 0.0);
                        glEnd();

                        glDisable(GL_TEXTURE_2D);
                        glDisable(GL_ALPHA_TEST);
                        glDisable(GL_BLEND);

                    }
  
                    Explosions[j].Age++;
                } else {
                    Explosions[j].Age = 0;
                    Explosions[j].Valid = 0;
                    explosion-- ;
                }
            glPopMatrix();

        }

    } /* for j */

}


/***************************************************************/
/* Fonction destinee a se ramener a un espace 40X40. (tank).*/
/***************************************************************/
GLvoid	ReduceWorldSize(GLvoid)
{

    RscenePosz = scenePosz - ceil( (scenePosz - 20.0) /40.0 )*40.0 ;
    RscenePosx = scenePosx - ceil( (scenePosx - 20.0) /40.0 )*40.0 ;

}

/***************************************************************/
/* Fonction destinee a se ramener a un espace 40X40. (Missile).*/
/***************************************************************/
GLvoid	ReduceMissileWorldSize(GLint Which)
{

    RscenePosx = Missiles[Which].Posx 
                 - ceil( (Missiles[Which].Posx - 20.0) /40.0 )*40.0 ;
    RscenePosz = Missiles[Which].Posz
                 - ceil( (Missiles[Which].Posz - 20.0) /40.0 )*40.0 ;

}


/***************************************************************/
/* Fonction pour verifier si on a des chances de rentrer dans un prisme */
/* ou dans un cube. Retourne Vrai si trop loin, faux si trop pres.*/
/***************************************************************/
GLint	VerifyVeryClose(GLint distance)
{
    if ( RCdistance > distance ) {
        return 1;
    } else {
        return 0;
    }
}


/***************************************************************/
/* Fonction pour verifier si on des chances de rentrer dans le cylindre */
/* central de la scene. Retourne Vrai si trop loin, faux si trop pres.*/
/***************************************************************/
GLint	VerifyClose(GLint distance)
{
    if ( RCdistance > distance ) {
        return 1;
    } else {
        return 0;
    }
}


/***************************************************************/
/* Fonction pour verifier si on est dans une zone paire ou impaire. */
/* Fonction pour verifier si on a affaire a un cube ou a un prisme. */
/***************************************************************/
GLint	VerifyEvenOrOdd(GLvoid)
{
    res_temp =   floor( (scenePosz - 20.0) /40.0 )
               + floor( (scenePosx - 20.0) /40.0 );

    if ( (2*floor(res_temp/2)) < res_temp ) {
        return 1;
    } else {
        return 0;
    }
}

/***************************************************************/
/* Fonction pour verifier si on est en dehors des obstacles. (tank). */
/***************************************************************/
GLint	VerifyOutOfThisWorld(GLvoid)
{
    if ( ( fabs(scenePosx) > 140) || ( fabs(scenePosz) > 140 ) ) {
        return 0;
    } else {
        return 1;
    }
}

/***************************************************************/
/* Fonction pour verifier si on est en dehors des obstacles. (tank). */
/***************************************************************/
GLint	VerifyOutOfThisWorldGeneric(GLvoid)
{
    if ( ( fabs(RandomscenePosx) > 140) || ( fabs(RandomscenePosz) > 140 ) ) {
        return 0;
    } else {
        return 1;
    }
}


/***************************************************************/
/* Fonction pour verifier si on est en dehors des obstacles. (Missile). */
/***************************************************************/
GLint	VerifyOutOfThisWorldMissile(GLint Which)
{
    if ( ( fabs(Missiles[Which].Posx) > 140) 
         || ( fabs(Missiles[Which].Posz) > 140 ) ) {
        return 0;
    } else {
        return 1;
    }
}

/***************************************************************/
/* Fonction determinant la facon dont on rebondit sur le cylindre */
/***************************************************************/
GLvoid	BangOnCylinder(GLvoid)
{
    LongSpeed = -(LongSpeed/2+sgn(LongSpeed));
    WasInside = 1;
}

/***************************************************************/
/* Fonction determinant la facon dont on rebondit sur un cube */
/***************************************************************/
GLvoid	BangOnCube(GLvoid)
{
    LongSpeed = -(LongSpeed/2+sgn(LongSpeed));
    WasInside = 1;
}


/***************************************************************/
/* Fonction determinant la facon dont on rebondit sur un prisme */
/***************************************************************/
GLvoid	BangOnPrism(GLvoid)
{
    LongSpeed = -(LongSpeed/2+sgn(LongSpeed));
    WasInside = 1;
}


/***************************************************************/
/* Fonction de destruction d'un missile dont on a determine */
/* la collision avec un obstacle. */
/***************************************************************/
GLvoid  ExplodeMissile(GLint Which, GLint Who)
{
    /* Enleve le flag VRAI du missile qui a explose. */
    Missiles[Which].Valid = 0;

    /* Decremente le nombre de missiles en vol.*/
    FlyingMissile--;

    /* Decremente le nombre de nos missiles en vol si c'etait le notre.*/
    if (Which == 0) {
        MyFlyingMissile = 0;
    }

    OneExplosion.x = -Missiles[Which].Posx;
    OneExplosion.y = 0.0;
    OneExplosion.z = -Missiles[Which].Posz;
    OneExplosion.Angle = Missiles[Which].Angle;
    sprintf( OneExplosion.Name, OurName);

    if (Who) {
        sprintf( OneExplosion.Destroyed, Tanks[Who-1].Name);
    } else {
        sprintf( OneExplosion.Destroyed, " ");
    }

    InsertExplosion(OneExplosion);

    SendMyExplosionPacket();

}

/***************************************************************/
/* Fonction de destruction d'un tank dont on a determine */
/* la collision avec notre missile. Il faut aussi appeler ExplodeMissile*/
/* conjointement avec cette fonction pour faire exploser le missile. */
/***************************************************************/
GLvoid  ExplodeTank(GLint Which)
{
    /* Enleve le flag VRAI du tank qui a explose. */
    Tanks[Which].Valid = 0;

    /* Decremente le nombre de tanks dans le jeu.*/
    tanks--;

    /* Si on n'est pas en mode Network, insere une epave de tanks */
    /* apres l'explosion de celui que nous avons touche..*/
    if (!Network) {

        OneDestroyedTank.Posx = Tanks[Which].Posx;
        OneDestroyedTank.Posz = Tanks[Which].Posz;
        OneDestroyedTank.Angle = Tanks[Which].Angle;

        /* Insere une epave de tank...*/
        InsertDestroyedTank(OneDestroyedTank);

    }

    /* Affiche un message de victoire... */
    ResetInfoMessage();
    sprintf(InfoMessage.texta, "    You really nailed that tank!!!");
    sprintf(InfoMessage.textc, "    May %s rest in peace..",Tanks[Which].Name);
    InfoMessage.Valid = 1;
    InfoMessage.Age = -1.0;

}


/***************************************************************/
/* Fonction d'orientation du missile par rapport au tank grace a l'angle */
/* entre deux vecteurs. */
/***************************************************************/
GLfloat OrienteMissile(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
{

    if ( ( x1 != 0 ) || ( y1 != 0 ) ) {

        /* Normalise le vecteur */
        Vlength = hypot(x1,y1) ;

        x1 = x1 / Vlength ;
        y1 = y1 / Vlength ;
    }


    if ( ( x2 != 0 ) || ( y2 != 0 ) ) {

        /* Normalise le vecteur */
        Vlength = hypot(x2,y2) ;

        x2 = x2 / Vlength ;
        y2 = y2 / Vlength ;

    }

    /* Calcul de l'angle */

    Theta =          acos ( (x1*x2 + y1*y2) / 1.001 ) 
            * ( sgn( asin ( x1*y2 - x2*y1) ) );

    #ifdef DEBUG
    printf(" Angle: %f \n", Theta*180/PI) ;
    #endif

    return Theta*180/PI;

}

/**************************************************************************/
/* Fonction chargee d'inserer un tank dans la matrice des tanks a la */
/* premiere place disponible. */
/**************************************************************************/
GLvoid  InsertTank(TANK OneTank)
{
    GLint i = 0;

    /* Recherche de la prochaine case libre. */
    while ( Tanks[i].Valid ) {
      i++;
    }
    
    if (i >= MAX_TANKS) {
        ResetInfoMessage();
        sprintf(InfoMessage.textb, "    Too Many Tanks, can't insert!!!");
        InfoMessage.Valid = 1;
        InfoMessage.Age = 1.0;
    } else {

        Tanks[i].Posx = OneTank.Posx;    
        Tanks[i].Posz = OneTank.Posz;    
        Tanks[i].Angle = OneTank.Angle;    
        Tanks[i].Valid = 1;    
        Tanks[i].Destroyed = 0;
        if (Network) {
            sprintf(Tanks[i].Name, OneTank.Name);
        } else {
            sprintf(Tanks[i].Name, "Evil Guy %i", (int)(i+1));
        }

        /* Augmente d'un le nombre de tanks. */
        tanks++;
    }

}

/**************************************************************************/
/* Fonction chargee d'inserer un missile dans la matrice des missiles a la */
/* premiere place disponible. */
/**************************************************************************/
GLvoid  InsertMissile(MISSILE OneMissile)
{
    /* On commence a la deuxieme case car la premiere est reservee au */
    /* missile de notre propre tank si ce dernier en lance un. */
    GLint i = 1;

    /* Recherche de la prochaine case libre. */
    while ( Missiles[i].Valid ) {
      i++;
    }
    
    if (i >= MAX_MISSILES) {
        ResetInfoMessage();
        sprintf(InfoMessage.textb, "    Too Many Missiles, can't insert!!!"); 
        InfoMessage.Valid = 1;
        InfoMessage.Age = 1.0;
     } else {

        Missiles[i].Posx = OneMissile.Posx;    
        Missiles[i].Posz = OneMissile.Posz;    
        Missiles[i].Incx = OneMissile.Incx;    
        Missiles[i].Incz = OneMissile.Incz;    
        Missiles[i].Angle = OneMissile.Angle;    
        Missiles[i].Age = 0;
        Missiles[i].Valid = 1;    

        /* Augmente d'un le nombre de missiles. */
        FlyingMissile++;
    }

}

/**************************************************************************/
/* Fonction chargee d'inserer une explosion dans la matrice des explosions */
/* a la premiere place disponible. */
/**************************************************************************/
GLvoid  InsertExplosion(EXPLOSION OneExplosion)
{
    GLint i = 0;

    /* Recherche de la prochaine case libre. */
    while ( Explosions[i].Valid ) {
      i++;
    }
    
    if (i >= MAX_EXPLOSIONS) {
        ResetInfoMessage();
        sprintf(InfoMessage.textb, "    Too Many Explosions, can't insert!!!");
        InfoMessage.Valid = 1;
        InfoMessage.Age = 1.0;
    } else {

        Explosions[i].x = OneExplosion.x;
        Explosions[i].y = OneExplosion.y;
        Explosions[i].z = OneExplosion.z;
        Explosions[i].Angle = OneExplosion.Angle;
        Explosions[i].Age = 0;    
        Explosions[i].Valid = 1;    
        sprintf(Explosions[i].Name, OneExplosion.Name);
        sprintf(Explosions[i].Destroyed, OneExplosion.Destroyed);

        /* Augmente d'une le nombre d'explosions. */
        explosion++;
    }

}

/**************************************************************************/
/* Fonction chargee d'inserer un tank dans la matrice des tanks a la */
/* premiere place disponible. */
/**************************************************************************/
GLvoid  InsertDestroyedTank(TANK OneDestroyedTank)
{
    GLint i = 0;

    /* Recherche de la prochaine case libre. */
    while ( DestroyedTanks[i].Valid ) {
      i++;
    }
    
    if (i >= MAX_DESTROYED_TANKS) {
        ResetInfoMessage();
        sprintf(InfoMessage.textb, "    Too Many Tank Wrecks, can't insert!!!");
        InfoMessage.Valid = 1;
        InfoMessage.Age = 1.0;
    } else {

        DestroyedTanks[i].Posx = OneDestroyedTank.Posx;    
        DestroyedTanks[i].Posz = OneDestroyedTank.Posz;    
        DestroyedTanks[i].Angle = OneDestroyedTank.Angle;    
        DestroyedTanks[i].Valid = 1;    
        DestroyedTanks[i].Destroyed = 1;

        /* Augmente d'un le nombre de tanks. */
        destroyed++;
    }
}