2021-09-24 10:15:43 -04:00
# include "engine.h"
2023-11-20 14:28:54 -05:00
# include <algorithm>
# include <filesystem>
# include <fstream>
2023-10-02 15:55:45 -04:00
# include <iostream>
# include <chrono>
# include <thread>
# include <queue>
// Define a structure to represent notifications
struct Notification {
std : : string message ;
float displayStartTime = 0.0f ;
} ;
2023-11-13 16:02:13 -05:00
2023-10-02 15:55:45 -04:00
// Use a queue to manage notifications
//std::queue<Notification> notificationQueue;
// Use a vector to manage notifications
std : : vector < Notification > notifications ;
2023-11-13 16:02:13 -05:00
Engine : : Engine ( ) : m_remotePlayer ( & m_pinfo ) , m_pinfo ( ) { }
2021-09-24 10:15:43 -04:00
2023-09-15 11:24:43 -04:00
Engine : : ~ Engine ( ) {
2021-12-06 21:41:50 -05:00
m_world . CleanUpWorld ( m_renderCount , true ) ;
2021-12-07 18:59:50 -05:00
for ( int x = 0 ; x < WORLD_SIZE_X ; + + x )
2021-12-06 21:41:50 -05:00
for ( int y = 0 ; y < WORLD_SIZE_Y ; + + y )
if ( m_world . GetChunks ( ) . Get ( x , y ) )
m_world . GetChunks ( ) . Get ( x , y ) - > ~ Chunk ( ) ;
}
2021-09-24 10:15:43 -04:00
2023-10-23 16:57:19 -04:00
void Engine : : DrawSplachScreen ( )
{
glDisable ( GL_LIGHTING ) ;
glDisable ( GL_DEPTH_TEST ) ;
glDisable ( GL_STENCIL_TEST ) ;
// Définir la matrice de projection en mode orthographique
glMatrixMode ( GL_PROJECTION ) ;
glPushMatrix ( ) ;
glLoadIdentity ( ) ;
glOrtho ( - Width ( ) / 2 , Width ( ) / 2 , - Height ( ) / 2 , Height ( ) / 2 , - 1 , 1 ) ;
// Définir la matrice de modèle-vue
glMatrixMode ( GL_MODELVIEW ) ;
glPushMatrix ( ) ;
glLoadIdentity ( ) ;
// L'image sera centrée autour de l'origine (0, 0, 0)
int imageWidth = Width ( ) ; // Remplacez par la largeur de votre image
int imageHeight = Height ( ) ; // Remplacez par la hauteur de votre image
// Texture
SplachScreenTexture . Bind ( ) ;
// Dessiner un quadrilatère centré
glBegin ( GL_QUADS ) ;
glTexCoord2f ( 0 , 0 ) ;
glVertex2i ( - imageWidth / 2 , - imageHeight / 2 ) ;
glTexCoord2f ( 1 , 0 ) ;
glVertex2i ( imageWidth / 2 , - imageHeight / 2 ) ;
glTexCoord2f ( 1 , 1 ) ;
glVertex2i ( imageWidth / 2 , imageHeight / 2 ) ;
glTexCoord2f ( 0 , 1 ) ;
glVertex2i ( - imageWidth / 2 , imageHeight / 2 ) ;
glEnd ( ) ;
// Activer la transparence
glBlendFunc ( GL_SRC_ALPHA , GL_ONE_MINUS_SRC_ALPHA ) ;
glBlendEquation ( GL_FUNC_ADD ) ;
glEnable ( GL_BLEND ) ;
// Restaurer les matrices précédentes
glMatrixMode ( GL_PROJECTION ) ;
glPopMatrix ( ) ;
glMatrixMode ( GL_MODELVIEW ) ;
glPopMatrix ( ) ;
2023-10-29 15:39:29 -04:00
m_gamestate = GameState : : OPTIONS ;
2023-10-23 16:57:19 -04:00
}
2023-10-02 17:09:03 -04:00
void Engine : : DrawMenu ( )
{
static const int sTitle = 400 ;
static const int sButton = 225 ;
glDisable ( GL_LIGHTING ) ;
2023-10-30 15:36:43 -04:00
2023-10-16 17:36:04 -04:00
2023-10-02 17:09:03 -04:00
glDisable ( GL_DEPTH_TEST ) ;
2023-10-16 17:36:04 -04:00
glDisable ( GL_STENCIL_TEST ) ;
2023-10-02 17:09:03 -04:00
glMatrixMode ( GL_PROJECTION ) ;
glPushMatrix ( ) ;
glLoadIdentity ( ) ;
glOrtho ( 0 , Width ( ) , 0 , Height ( ) , - 1 , 1 ) ;
glMatrixMode ( GL_MODELVIEW ) ;
glPushMatrix ( ) ;
MenuBGTexture . Bind ( ) ;
glLoadIdentity ( ) ;
glBegin ( GL_QUADS ) ;
glTexCoord2f ( 0 , 0 ) ;
glVertex2i ( 0 , 0 ) ;
glTexCoord2f ( 1 , 0 ) ;
2023-10-30 15:52:15 -04:00
glVertex2i ( Width ( ) , 0 ) ; //
2023-10-02 17:09:03 -04:00
glTexCoord2f ( 1 , 1 ) ;
2023-10-30 15:52:15 -04:00
glVertex2i ( Width ( ) , Height ( ) ) ;
2023-10-02 17:09:03 -04:00
glTexCoord2f ( 0 , 1 ) ;
2023-10-30 15:52:15 -04:00
glVertex2i ( 0 , Height ( ) ) ;
2023-10-02 17:09:03 -04:00
glEnd ( ) ;
2023-10-16 17:36:04 -04:00
glBlendFunc ( GL_SRC_ALPHA , GL_ONE_MINUS_SRC_ALPHA ) ;
glBlendEquation ( GL_FUNC_ADD ) ;
glEnable ( GL_BLEND ) ;
2023-10-02 17:09:03 -04:00
if ( m_gamestate ! = GameState : : OPTIONS )
{
MenuTitleTexture . Bind ( ) ;
glTranslated ( 200 , 300 , 0 ) ;
glBegin ( GL_QUADS ) ;
glTexCoord2f ( 0 , 0 ) ;
glVertex2i ( 0 , 200 ) ;
glTexCoord2f ( 1 , 0 ) ;
glVertex2i ( sTitle , 200 ) ;
glTexCoord2f ( 1 , 1 ) ;
glVertex2i ( sTitle , 300 ) ;
glTexCoord2f ( 0 , 1 ) ;
glVertex2i ( 0 , 300 ) ;
glEnd ( ) ;
2023-10-30 15:52:15 -04:00
2023-10-02 17:09:03 -04:00
MenuStartTexture . Bind ( ) ;
glTranslated ( 80 , - 225 , 0 ) ;
glBegin ( GL_QUADS ) ;
glTexCoord2f ( 0 , 0 ) ;
glVertex2i ( 0 , 100 ) ;
glTexCoord2f ( 1 , 0 ) ;
2023-10-30 15:52:15 -04:00
glVertex2i ( sButton , 100 ) ;
2023-10-02 17:09:03 -04:00
glTexCoord2f ( 1 , 1 ) ;
glVertex2i ( sButton , 200 ) ;
glTexCoord2f ( 0 , 1 ) ;
glVertex2i ( 0 , 200 ) ;
glEnd ( ) ;
2023-10-30 15:52:15 -04:00
2023-10-02 17:09:03 -04:00
/*MenuResumeTexture.Bind();
glTranslated ( 0 , - 100 , 0 ) ;
glBegin ( GL_QUADS ) ;
glTexCoord2f ( 0 , 0 ) ;
glVertex2i ( 0 , 125 ) ;
2023-10-30 15:52:15 -04:00
//glTexCoord2f(1, 0);
2023-10-02 17:09:03 -04:00
glVertex2i ( sButton , 125 ) ;
glTexCoord2f ( 1 , 1 ) ;
glVertex2i ( sButton , 200 ) ;
glTexCoord2f ( 0 , 1 ) ;
glVertex2i ( 0 , 200 ) ;
glEnd ( ) ; */
/*MenuOptionsTexture.Bind();
glTranslated ( 0 , - 100 , 0 ) ;
glBegin ( GL_QUADS ) ;
glTexCoord2f ( 0 , 0 ) ;
glVertex2i ( 0 , 125 ) ;
glTexCoord2f ( 1 , 0 ) ;
glVertex2i ( sButton , 125 ) ;
glTexCoord2f ( 1 , 1 ) ;
glVertex2i ( sButton , 200 ) ;
glTexCoord2f ( 0 , 1 ) ;
glVertex2i ( 0 , 200 ) ;
glEnd ( ) ; */
MenuQuitTexture . Bind ( ) ;
glTranslated ( 0 , - 100 , 0 ) ;
glBegin ( GL_QUADS ) ;
glTexCoord2f ( 0 , 0 ) ;
glVertex2i ( 0 , 100 ) ;
glTexCoord2f ( 1 , 0 ) ;
glVertex2i ( sButton , 100 ) ;
glTexCoord2f ( 1 , 1 ) ;
glVertex2i ( sButton , 200 ) ;
glTexCoord2f ( 0 , 1 ) ;
glVertex2i ( 0 , 200 ) ;
glEnd ( ) ;
}
else
{
/*MenuOptionsTexture.Bind();
glTranslated ( 200 , 0 , 0 ) ;
glBegin ( GL_QUADS ) ;
glTexCoord2f ( 0 , 0 ) ;
glVertex2i ( 0 , 0 ) ;
glTexCoord2f ( 1 , 0 ) ;
glVertex2i ( sTitle , 0 ) ;
glTexCoord2f ( 1 , 1 ) ;
glVertex2i ( sTitle , 200 ) ;
glTexCoord2f ( 0 , 1 ) ;
glVertex2i ( 0 , 200 ) ;
glEnd ( ) ;
WireFrameTexture . Bind ( ) ;
glTranslated ( 0 , 300 , 0 ) ;
glBegin ( GL_QUADS ) ;
glTexCoord2f ( 0 , 0 ) ;
glVertex2i ( 0 , 125 ) ;
glTexCoord2f ( 1 , 0 ) ;
glVertex2i ( sButton , 125 ) ;
glTexCoord2f ( 1 , 1 ) ;
glVertex2i ( sButton , 200 ) ;
glTexCoord2f ( 0 , 1 ) ;
glVertex2i ( 0 , 200 ) ;
glEnd ( ) ;
OnOffBtnTexture . Bind ( ) ;
glTranslated ( 200 , 0 , 0 ) ;
glBegin ( GL_QUADS ) ;
glTexCoord2f ( 0 , 0 ) ;
glVertex2i ( 0 , 125 ) ;
glTexCoord2f ( 1 , 0 ) ;
glVertex2i ( sButton , 125 ) ;
glTexCoord2f ( 1 , 1 ) ;
glVertex2i ( sButton , 200 ) ;
glTexCoord2f ( 0 , 1 ) ;
glVertex2i ( 0 , 200 ) ;
glEnd ( ) ;
glTranslated ( - 400 , - 300 , 0 ) ;
MusicTexture . Bind ( ) ;
glTranslated ( 200 , 200 , 0 ) ;
glBegin ( GL_QUADS ) ;
glTexCoord2f ( 0 , 0 ) ;
glVertex2i ( 0 , 125 ) ;
glTexCoord2f ( 1 , 0 ) ;
glVertex2i ( sButton , 125 ) ;
glTexCoord2f ( 1 , 1 ) ;
glVertex2i ( sButton , 200 ) ;
glTexCoord2f ( 0 , 1 ) ;
glVertex2i ( 0 , 200 ) ;
glEnd ( ) ;
OnOffBtnTexture . Bind ( ) ;
glTranslated ( 200 , 0 , 0 ) ;
glBegin ( GL_QUADS ) ;
glTexCoord2f ( 0 , 0 ) ;
glVertex2i ( 0 , 125 ) ;
glTexCoord2f ( 1 , 0 ) ;
glVertex2i ( sButton , 125 ) ;
glTexCoord2f ( 1 , 1 ) ;
glVertex2i ( sButton , 200 ) ;
glTexCoord2f ( 0 , 1 ) ;
glVertex2i ( 0 , 200 ) ;
glEnd ( ) ;
BackBtnTexture . Bind ( ) ;
glTranslated ( - 375 , 175 , 0 ) ;
glBegin ( GL_QUADS ) ;
glTexCoord2f ( 0 , 0 ) ;
glVertex2i ( 0 , 140 ) ;
glTexCoord2f ( 1 , 0 ) ;
glVertex2i ( sButton , 140 ) ;
glTexCoord2f ( 1 , 1 ) ;
glVertex2i ( sButton , 200 ) ;
glTexCoord2f ( 0 , 1 ) ;
glVertex2i ( 0 , 200 ) ;
glEnd ( ) ; */
}
2023-10-16 17:36:04 -04:00
//glEnable(GL_LIGHTING);
2023-10-02 17:09:03 -04:00
glDisable ( GL_BLEND ) ;
glEnable ( GL_DEPTH_TEST ) ;
glMatrixMode ( GL_PROJECTION ) ;
glPopMatrix ( ) ;
glMatrixMode ( GL_MODELVIEW ) ;
glPopMatrix ( ) ;
ShowCursor ( ) ;
}
2023-10-23 17:51:29 -04:00
void Engine : : DrawPause ( )
{
static const int sTitle = 400 ;
static const int sButton = 225 ;
glDisable ( GL_LIGHTING ) ;
2023-10-23 16:57:19 -04:00
2023-10-23 17:51:29 -04:00
glDisable ( GL_DEPTH_TEST ) ;
glDisable ( GL_STENCIL_TEST ) ;
glMatrixMode ( GL_PROJECTION ) ;
glPushMatrix ( ) ;
glLoadIdentity ( ) ;
glOrtho ( 0 , Width ( ) , 0 , Height ( ) , - 1 , 1 ) ;
glMatrixMode ( GL_MODELVIEW ) ;
glPushMatrix ( ) ;
2023-10-30 15:49:17 -04:00
PauseBGTexture . Bind ( ) ;
2023-10-23 17:51:29 -04:00
glLoadIdentity ( ) ;
glBegin ( GL_QUADS ) ;
glTexCoord2f ( 0 , 0 ) ;
glVertex2i ( 0 , 0 ) ;
glTexCoord2f ( 1 , 0 ) ;
glVertex2i ( 800 , 0 ) ;
glTexCoord2f ( 1 , 1 ) ;
glVertex2i ( 800 , 600 ) ;
glTexCoord2f ( 0 , 1 ) ;
glVertex2i ( 0 , 600 ) ;
glEnd ( ) ;
2023-10-30 15:49:17 -04:00
glDisable ( GL_BLEND ) ;
glEnable ( GL_DEPTH_TEST ) ;
glMatrixMode ( GL_PROJECTION ) ;
glPopMatrix ( ) ;
glMatrixMode ( GL_MODELVIEW ) ;
glPopMatrix ( ) ;
ShowCursor ( ) ;
2023-10-23 17:51:29 -04:00
}
2021-11-30 19:55:11 -05:00
void Engine : : Init ( ) {
2023-10-23 16:57:19 -04:00
2021-10-11 11:37:58 -04:00
GLenum glewErr = glewInit ( ) ;
2021-10-12 15:58:54 -04:00
if ( glewErr ! = GLEW_OK ) {
2021-10-11 11:37:58 -04:00
std : : cerr < < " ERREUR GLEW : " < < glewGetErrorString ( glewErr ) < < std : : endl ;
abort ( ) ;
}
2023-10-18 09:33:56 -04:00
uint64_t seed = SEED ;
2023-09-30 14:46:54 -04:00
glDisable ( GL_FRAMEBUFFER_SRGB ) ;
2023-10-30 15:36:43 -04:00
glEnable ( GL_DEPTH_TEST ) ;
2023-09-30 14:46:54 -04:00
glEnable ( GL_STENCIL_TEST ) ;
glEnable ( GL_POINT_SMOOTH ) ;
glEnable ( GL_BLEND ) ;
2023-11-19 16:46:13 -05:00
//glEnable(GL_CULL_FACE);
2021-09-27 10:20:58 -04:00
glEnable ( GL_TEXTURE_2D ) ;
2023-09-15 11:24:43 -04:00
2021-09-27 10:20:58 -04:00
glMatrixMode ( GL_PROJECTION ) ;
glLoadIdentity ( ) ;
2021-10-06 21:32:12 -04:00
2023-09-15 11:24:43 -04:00
gluPerspective ( 45.0f , ( float ) Width ( ) / ( float ) Height ( ) , 0.1f , VIEW_DISTANCE ) ;
2023-09-15 20:28:20 -04:00
glShadeModel ( GL_SMOOTH ) ;
2021-11-30 19:55:11 -05:00
2023-09-30 14:46:54 -04:00
glHint ( GL_PERSPECTIVE_CORRECTION_HINT , GL_NICEST ) ;
glDisable ( GL_BLEND ) ;
glBlendFunc ( GL_SRC_ALPHA , GL_ONE_MINUS_SRC_ALPHA ) ;
glBlendEquation ( GL_FUNC_SUBTRACT ) ;
2023-10-30 15:36:43 -04:00
2023-11-06 16:43:52 -05:00
if ( m_istarted )
return ;
else m_istarted = true ;
2023-09-15 20:28:20 -04:00
//
2021-10-12 15:58:54 -04:00
// Objet de skybox avec sa propre texture et son propre shader!
2021-12-06 09:45:51 -05:00
m_skybox . Init ( 0.2f ) ;
2023-11-19 16:46:13 -05:00
//m_skybox2.Init(1.f);
2021-10-19 10:27:59 -04:00
// Objet de musique!
2023-09-27 11:24:41 -04:00
//m_audio.ToggleMusicState();
2021-11-15 20:58:13 -05:00
2021-12-07 18:59:50 -05:00
// Array pour les balles.
2023-10-16 12:02:37 -04:00
for ( int x = 0 ; x < MAX_BULLETS ; + + x ) {
2021-12-07 18:59:50 -05:00
m_bullets [ x ] = nullptr ;
2023-10-18 09:33:56 -04:00
m_whoosh [ x ] = nullptr ;
2023-10-16 12:02:37 -04:00
}
2021-12-07 18:59:50 -05:00
2023-10-30 15:36:43 -04:00
char * ch = new char [ 2 ] ;
2023-10-23 15:41:07 -04:00
2023-10-30 15:36:43 -04:00
std : : cout < < " Jouer en ligne? [o/N] " ;
std : : cin . getline ( ch , 2 ) ;
std : : cout < < std : : endl ;
2023-10-27 14:37:53 -04:00
2023-10-30 15:36:43 -04:00
if ( * ch = = ' o ' | | * ch = = ' O ' ) {
char * input = new char [ 32 ] ;
std : : string playname , srvname ;
2023-10-27 14:37:53 -04:00
2023-10-30 15:36:43 -04:00
while ( playname . size ( ) < 1 ) {
std : : cout < < " Veuillez entrer un nom de joueur: " ;
std : : cin . getline ( input , 32 ) ;
std : : cout < < std : : endl ;
playname = input ;
if ( playname . size ( ) < 1 | | playname . size ( ) > 32 )
std : : puts ( " Nom invalide. " ) ;
}
while ( srvname . size ( ) < 1 ) {
std : : cout < < " Veuillez entrer une adresse de serveur: " ;
std : : cin . getline ( input , 32 ) ;
std : : cout < < std : : endl ;
srvname = input ;
if ( srvname . size ( ) < 1 | | srvname . size ( ) > 32 )
std : : puts ( " Adresse serveur invalide. " ) ;
}
delete [ ] input ;
if ( ! m_conn . Init ( ) ) {
if ( ! m_conn . Connect ( srvname . c_str ( ) , playname ) ) {
// setup jeu en reseau.
std : : cout < < " ID recu du serveur: " < < std : : to_string ( m_conn . getId ( ) ) < < " ! " < < std : : endl ;
std : : cout < < " Seed recu du serveur: " < < std : : to_string ( m_conn . getSeed ( ) ) < < " ! " < < std : : endl ;
m_player = Player ( m_conn . getOrigin ( ) . position ) ;
for ( auto & [ key , player ] : m_conn . m_players )
m_players [ key ] = new RemotePlayer ( player ) ;
seed = m_conn . getSeed ( ) ;
m_networkgame = true ;
2023-09-25 08:23:52 -04:00
}
2023-10-30 15:36:43 -04:00
else std : : cout < < " Erreur de connexion. " < < std : : endl ;
2023-09-25 08:23:52 -04:00
}
2023-10-30 15:36:43 -04:00
else std : : cout < < " Erreur de creation de socket. " < < std : : endl ;
}
delete [ ] ch ;
2023-09-25 08:23:52 -04:00
m_world . SetSeed ( seed ) ;
2021-11-16 20:48:52 -05:00
// Init Chunks
2021-11-19 11:11:08 -05:00
m_world . GetChunks ( ) . Reset ( nullptr ) ;
2021-11-02 18:01:06 -04:00
2023-11-02 15:47:15 -04:00
m_startTime = std : : chrono : : high_resolution_clock : : now ( ) ;
2023-11-19 16:46:13 -05:00
m_remotePlayer . SetPosition ( Vector3f ( .5 , CHUNK_SIZE_Y + 10. , .5 ) ) ;
2021-10-31 00:31:08 -04:00
// Gestion de souris.
2021-09-27 10:20:58 -04:00
CenterMouse ( ) ;
HideCursor ( ) ;
2021-09-24 10:15:43 -04:00
}
2023-09-15 11:24:43 -04:00
void Engine : : DeInit ( ) { }
2021-09-24 10:15:43 -04:00
2021-09-27 11:30:18 -04:00
void Engine : : LoadResource ( ) {
2023-09-16 00:12:14 -04:00
LoadTexture ( m_skybox . GetTexture ( ) , TEXTURE_PATH " skybox.png " , true ) ;
2023-11-19 16:46:13 -05:00
//LoadTexture(m_skybox2.GetTexture(), TEXTURE_PATH "skybox.png", true);
2023-09-16 00:12:14 -04:00
LoadTexture ( m_textureCrosshair , TEXTURE_PATH " cross.bmp " , true ) ;
LoadTexture ( m_textureFont , TEXTURE_PATH " font.bmp " , true ) ;
LoadTexture ( m_textureGun , TEXTURE_PATH " gun01.png " , false ) ;
2023-10-15 23:36:26 -04:00
LoadTexture ( m_texturePovGun , TEXTURE_PATH " GUN.png " , false ) ;
2023-10-25 01:01:25 -04:00
LoadTexture ( m_textureSoloMultiMenu , TEXTURE_PATH " single_multi.png " , false ) ;
2023-10-29 15:39:29 -04:00
LoadTexture ( m_textureSoloText , TEXTURE_PATH " single_player.png " , false ) ;
LoadTexture ( m_textureMultiText , TEXTURE_PATH " multi_player.png " , false ) ;
LoadTexture ( m_textureSoloMultiMenu , TEXTURE_PATH " single_multi.png " , false ) ;
2023-10-25 01:01:25 -04:00
LoadTexture ( m_textureTitle , TEXTURE_PATH " title.png " , false ) ;
2023-09-16 00:12:14 -04:00
2023-10-30 15:52:15 -04:00
LoadTexture ( MenuTitleTexture , TEXTURE_PATH " BrouillonbackgroundMenu.png " ) ;
LoadTexture ( MenuBGTexture , TEXTURE_PATH " BrouillonbackgroundMenu.png " ) ;
2023-11-06 16:04:34 -05:00
LoadTexture ( PauseBGTexture , TEXTURE_PATH " BrouillonbackgroundMenu.png " ) ;
2023-10-23 16:57:19 -04:00
LoadTexture ( SplachScreenTexture , TEXTURE_PATH " sc2.png " ) ;
2023-10-02 17:09:03 -04:00
LoadTexture ( MenuQuitTexture , MENU_ITEM_PATH " BasicQuit.png " ) ;
LoadTexture ( MenuOptionsTexture , MENU_ITEM_PATH " test.png " ) ;
LoadTexture ( MenuStartTexture , MENU_ITEM_PATH " BasicPlay.png " ) ;
2023-11-06 16:04:34 -05:00
2021-10-31 00:31:08 -04:00
TextureAtlas : : TextureIndex texDirtIndex = m_textureAtlas . AddTexture ( TEXTURE_PATH " metal3.png " ) ;
2021-12-04 09:55:43 -05:00
TextureAtlas : : TextureIndex texIceIndex = m_textureAtlas . AddTexture ( TEXTURE_PATH " metal2.png " ) ;
2021-10-31 00:31:08 -04:00
TextureAtlas : : TextureIndex texGrassIndex = m_textureAtlas . AddTexture ( TEXTURE_PATH " grass.png " ) ;
2021-12-06 09:45:51 -05:00
TextureAtlas : : TextureIndex texMetalIndex = m_textureAtlas . AddTexture ( TEXTURE_PATH " dirt.png " ) ;
2023-11-20 15:40:43 -05:00
TextureAtlas : : TextureIndex texBoostHeal = m_textureAtlas . AddTexture ( BOOSTER_TEXTURE_PATH " BoosterVert.png " ) ;
2023-10-30 14:03:10 -04:00
TextureAtlas : : TextureIndex texBoostDmg = m_textureAtlas . AddTexture ( BOOSTER_TEXTURE_PATH " BoosterRouge.png " ) ;
TextureAtlas : : TextureIndex texBoostSpd = m_textureAtlas . AddTexture ( BOOSTER_TEXTURE_PATH " BoosterBleu.png " ) ;
TextureAtlas : : TextureIndex texBoostInv = m_textureAtlas . AddTexture ( BOOSTER_TEXTURE_PATH " BoosterJaune.png " ) ;
2021-10-26 17:28:37 -04:00
2023-11-20 14:28:54 -05:00
//AJOUTER LES TEXTURES DANS L'ORDRE DE L'ÉNUM
//JUMP
//TextureAtlas::TextureIndex JumpBack = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueBackJumpRight.png");
//TextureAtlas::TextureIndex JumpFront = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueFrontJumpRight.png");
//TextureAtlas::TextureIndex JumpQuarterBackLeft = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueLeftBackJumpLeft.png");
//TextureAtlas::TextureIndex JumpQuarterBackRight = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueRightBackJumpRight.png");
//TextureAtlas::TextureIndex JumpProfiltLeft = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueProfilJumpLeft.png");
//TextureAtlas::TextureIndex JumpProfiltRight = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueProfilJumpRight.png");
//TextureAtlas::TextureIndex JumpQuarterFrontLeft = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueLeftFrontJumpLeft.png");
//TextureAtlas::TextureIndex JumpQuarterFrontRight = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueRightFrontJumpRight.png");
//STILL
//TextureAtlas::TextureIndex StillBack = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueBackRight.png");
TextureAtlas : : TextureIndex StillFront = m_animeAtlas . AddTexture ( ANIME_PATH_STILL " BlueFrontRight.png " ) ;
//TextureAtlas::TextureIndex StillQuarterBackLeft = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueLeftBack.png");
//TextureAtlas::TextureIndex StillQuarterBackRight = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueRightBack.png");
//TextureAtlas::TextureIndex StillProfiltLeft = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueProfilLeft.png");
//TextureAtlas::TextureIndex StillProfiltRight = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueProfilRight.png");
//TextureAtlas::TextureIndex StillQuarterFrontLeft = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueLeft.png");
//TextureAtlas::TextureIndex StillQuarterFrontRight = m_animeAtlas.AddTexture(ANIME_PATH_JUMP "BlueRight.png");
//SHOOTINGSTILL
//SHOOTINGJUMP
if ( ! m_animeAtlas . Generate ( TEXTURE_SIZE , false ) ) {
std : : cout < < " Unable to generate texture atlas ... " < < std : : endl ;
abort ( ) ;
}
2021-12-06 10:58:40 -05:00
if ( ! m_textureAtlas . Generate ( TEXTURE_SIZE , false ) ) {
2021-10-26 17:28:37 -04:00
std : : cout < < " Unable to generate texture atlas ... " < < std : : endl ;
abort ( ) ;
}
2021-10-11 11:37:58 -04:00
2021-10-31 00:31:08 -04:00
float u , v , s ;
m_textureAtlas . TextureIndexToCoord ( texDirtIndex , u , v , s , s ) ;
m_blockinfo [ BTYPE_DIRT ] = new BlockInfo ( BTYPE_DIRT , " Dirt " , u , v , s , 1 ) ;
m_textureAtlas . TextureIndexToCoord ( texGrassIndex , u , v , s , s ) ;
m_blockinfo [ BTYPE_GRASS ] = new BlockInfo ( BTYPE_GRASS , " Grass " , u , v , s , 1 ) ;
m_textureAtlas . TextureIndexToCoord ( texMetalIndex , u , v , s , s ) ;
m_blockinfo [ BTYPE_METAL ] = new BlockInfo ( BTYPE_METAL , " Metal " , u , v , s , 1 ) ;
m_textureAtlas . TextureIndexToCoord ( texIceIndex , u , v , s , s ) ;
m_blockinfo [ BTYPE_ICE ] = new BlockInfo ( BTYPE_ICE , " Ice " , u , v , s , 1 ) ;
2023-10-30 14:32:20 -04:00
m_textureAtlas . TextureIndexToCoord ( texBoostHeal , u , v , s , s ) ;
m_boostinfo [ BTYPE_HEAL ] = new BoostInfo ( BTYPE_HEAL , " Heal " , u , v , s , 1 ) ;
m_textureAtlas . TextureIndexToCoord ( texBoostDmg , u , v , s , s ) ;
m_boostinfo [ BTYPE_DAMAGE ] = new BoostInfo ( BTYPE_DAMAGE , " Dmg " , u , v , s , 1 ) ;
m_textureAtlas . TextureIndexToCoord ( texBoostSpd , u , v , s , s ) ;
m_boostinfo [ BTYPE_SPEED ] = new BoostInfo ( BTYPE_SPEED , " Spd " , u , v , s , 1 ) ;
m_textureAtlas . TextureIndexToCoord ( texIceIndex , u , v , s , s ) ;
m_boostinfo [ BTYPE_INVINCIBLE ] = new BoostInfo ( BTYPE_INVINCIBLE , " Inv " , u , v , s , 1 ) ;
2021-10-31 00:31:08 -04:00
2023-11-20 14:28:54 -05:00
m_animeAtlas . TextureIndexToCoord ( 0 , u , v , s , s ) ;
2021-10-11 11:37:58 -04:00
std : : cout < < " Loading and compiling shaders ... " < < std : : endl ;
2021-10-12 15:58:54 -04:00
if ( ! m_shader01 . Load ( SHADER_PATH " shader01.vert " , SHADER_PATH " shader01.frag " , true ) ) {
2021-10-11 11:37:58 -04:00
std : : cout < < " Failed to load shader " < < std : : endl ;
exit ( 1 ) ;
}
2021-09-24 10:15:43 -04:00
2021-10-12 15:58:54 -04:00
if ( ! m_skybox . GetShader ( ) . Load ( SHADER_PATH " skybox.vert " , SHADER_PATH " skybox.frag " , true ) ) {
std : : cout < < " Failed to load shader " < < std : : endl ;
exit ( 1 ) ;
}
2021-09-24 10:15:43 -04:00
}
2021-11-15 20:58:13 -05:00
void Engine : : UnloadResource ( ) { }
2021-10-12 15:58:54 -04:00
2023-10-23 15:43:55 -04:00
void Engine : : InstantDamage ( )
{
2023-10-30 14:36:44 -04:00
m_player . InflictDamage ( 0.10f ) ;
2023-10-23 15:43:55 -04:00
m_damage = false ;
}
2023-10-02 15:55:45 -04:00
void Engine : : SystemNotification ( std : : string systemLog ) {
std : : string message = " " ;
message = systemLog ;
DisplayNotification ( message ) ;
}
void Engine : : KillNotification ( Player killer , Player killed ) {
std : : string message = " " ;
message = killed . GetUsername ( ) + " killed by -> " + killer . GetUsername ( ) ;
DisplayNotification ( message ) ;
}
void Engine : : DisplayNotification ( std : : string message ) {
if ( message . length ( ) > 45 ) {
message = message . substr ( 0 , 45 ) ;
}
// Create a new notification and add it to the queue
Notification newNotification ;
newNotification . message = message ;
newNotification . displayStartTime = m_time ;
2023-10-23 16:11:35 -04:00
2023-10-02 15:55:45 -04:00
notifications . push_back ( newNotification ) ;
}
// Add a method to process the notification queue
void Engine : : ProcessNotificationQueue ( ) {
2023-10-23 16:11:35 -04:00
//PrintText(fPosX, fUsernamePosY, ss.str(), 1.5f);
//float fPosX = (Width() / 100.0f) * scaleX;
//float fPosY = Height() - (Height() * 0.05) * scaleY;
2023-10-02 15:55:45 -04:00
m_textureFont . Bind ( ) ;
2023-10-31 11:11:14 -04:00
float xOffset = Width ( ) * 0.66f ;
float yOffset = Height ( ) * 0.83f ;
2023-10-15 23:36:26 -04:00
2023-10-02 15:55:45 -04:00
for ( auto it = notifications . begin ( ) ; it ! = notifications . end ( ) ; ) {
float timeSinceDisplay = m_time - it - > displayStartTime ;
2023-10-31 11:11:14 -04:00
float y = yOffset - ( 20.0f * ( it - notifications . begin ( ) ) ) ;
2023-10-15 23:36:26 -04:00
2023-10-02 15:55:45 -04:00
glDisable ( GL_STENCIL_TEST ) ;
glDisable ( GL_DEPTH_TEST ) ;
glBlendFunc ( GL_SRC_ALPHA , GL_ONE ) ;
glBlendEquation ( GL_FUNC_ADD ) ;
glMatrixMode ( GL_PROJECTION ) ;
glPushMatrix ( ) ;
glLoadIdentity ( ) ;
glOrtho ( 0 , Width ( ) , 0 , Height ( ) , - 1 , 1 ) ;
glMatrixMode ( GL_MODELVIEW ) ;
glPushMatrix ( ) ;
2023-10-15 23:36:26 -04:00
PrintText ( xOffset , y , it - > message ) ;
2023-10-02 15:55:45 -04:00
glBlendFunc ( GL_CONSTANT_COLOR , GL_ONE_MINUS_CONSTANT_COLOR ) ;
glBlendEquation ( GL_FUNC_SUBTRACT ) ;
glEnable ( GL_STENCIL_TEST ) ;
glEnable ( GL_DEPTH_TEST ) ;
glMatrixMode ( GL_PROJECTION ) ;
glPopMatrix ( ) ;
glMatrixMode ( GL_MODELVIEW ) ;
glPopMatrix ( ) ;
2023-10-15 23:36:26 -04:00
2023-10-02 15:55:45 -04:00
if ( timeSinceDisplay > = 4.0f ) {
2023-10-15 23:36:26 -04:00
it = notifications . erase ( it ) ;
2023-10-02 15:55:45 -04:00
}
else {
+ + it ;
}
}
}
2023-09-15 20:28:20 -04:00
void Engine : : DisplayCrosshair ( ) {
m_textureCrosshair . Bind ( ) ;
static const int crossSize = 32 ;
2023-09-15 11:24:43 -04:00
glLoadIdentity ( ) ;
2023-09-15 20:28:20 -04:00
glTranslated ( Width ( ) / 2 - crossSize / 2 , Height ( ) / 2 - crossSize / 2 , 0 ) ;
glBegin ( GL_QUADS ) ;
2023-10-23 16:11:35 -04:00
glTexCoord2f ( 0 , 0 ) ;
glVertex2i ( 0 , 0 ) ;
glTexCoord2f ( 1 , 0 ) ;
glVertex2i ( crossSize , 0 ) ;
glTexCoord2f ( 1 , 1 ) ;
glVertex2i ( crossSize , crossSize ) ;
glTexCoord2f ( 0 , 1 ) ;
glVertex2i ( 0 , crossSize ) ;
2023-09-15 20:28:20 -04:00
glEnd ( ) ;
}
2023-09-15 11:24:43 -04:00
2023-10-15 23:36:26 -04:00
void Engine : : DisplayPovGun ( ) {
// Setter le blend function, tout ce qui sera noir sera transparent
glDisable ( GL_STENCIL_TEST ) ;
glDisable ( GL_DEPTH_TEST ) ;
glBlendFunc ( GL_SRC_ALPHA , GL_ONE_MINUS_SRC_ALPHA ) ;
glBlendEquation ( GL_FUNC_ADD ) ;
glMatrixMode ( GL_PROJECTION ) ;
glPushMatrix ( ) ;
glLoadIdentity ( ) ;
glOrtho ( 0 , Width ( ) , 0 , Height ( ) , - 1 , 1 ) ;
glMatrixMode ( GL_MODELVIEW ) ;
glPushMatrix ( ) ;
2023-10-31 11:11:14 -04:00
float baseXOffsetPercentage = 0.4958 ;
float baseWidthPercentage = 0.4688 ;
float baseHeightPercentage = 0.5787 ;
float xTranslation = baseXOffsetPercentage * Width ( ) ;
float quadWidth = baseWidthPercentage * Width ( ) ;
float quadHeight = baseHeightPercentage * Height ( ) ;
2023-10-15 23:36:26 -04:00
m_texturePovGun . Bind ( ) ;
glLoadIdentity ( ) ;
glTranslated ( xTranslation , 0 , 0 ) ;
glBegin ( GL_QUADS ) ;
glTexCoord2f ( 0 , 0 ) ;
glVertex2i ( 0 , 0 ) ;
glTexCoord2f ( 1 , 0 ) ;
glVertex2i ( quadWidth , 0 ) ;
glTexCoord2f ( 1 , 1 ) ;
glVertex2i ( quadWidth , quadHeight ) ;
glTexCoord2f ( 0 , 1 ) ;
glVertex2i ( 0 , quadHeight ) ;
glEnd ( ) ;
// Reset du blend function
glBlendFunc ( GL_CONSTANT_COLOR , GL_ONE_MINUS_CONSTANT_COLOR ) ;
glBlendEquation ( GL_FUNC_SUBTRACT ) ;
glEnable ( GL_STENCIL_TEST ) ;
glEnable ( GL_DEPTH_TEST ) ;
glMatrixMode ( GL_PROJECTION ) ;
glPopMatrix ( ) ;
glMatrixMode ( GL_MODELVIEW ) ;
glPopMatrix ( ) ;
}
2023-09-16 00:12:14 -04:00
void Engine : : DisplayCurrentItem ( ) {
}
2023-10-16 17:36:04 -04:00
2023-09-23 17:15:35 -04:00
void Engine : : DisplayHud ( int timer ) {
2023-09-15 20:28:20 -04:00
glBindTexture ( GL_TEXTURE_2D , 0 ) ;
glLoadIdentity ( ) ;
2023-10-15 23:36:26 -04:00
glBlendFunc ( GL_SRC_ALPHA , GL_ONE_MINUS_SRC_ALPHA ) ;
2023-10-31 11:11:14 -04:00
float itemBackgroundWidthProportion = 0.25f ;
float itemBackgroundHeightProportion = 0.175f ;
float itemBackgroundWidth = Width ( ) * itemBackgroundWidthProportion ;
float itemBackgroundHeight = Height ( ) * itemBackgroundHeightProportion ;
float itemBackgroundXOffset = Width ( ) * 0.05f ;
float itemBackgroundYOffset = Height ( ) * 0.6f ;
float itemBackgroundXPos = itemBackgroundXOffset ;
float itemBackgroundYPos = Height ( ) - itemBackgroundHeight - itemBackgroundYOffset ;
2023-10-15 23:36:26 -04:00
2023-10-31 11:11:14 -04:00
// Selected item background
2023-10-15 23:36:26 -04:00
glColor4f ( 1.0f , 1.0f , 1.0f , 0.2f ) ;
glBegin ( GL_QUADS ) ;
2023-10-31 11:11:14 -04:00
glVertex2f ( itemBackgroundXPos , itemBackgroundYPos ) ;
glVertex2f ( itemBackgroundXPos + itemBackgroundWidth , itemBackgroundYPos ) ;
glVertex2f ( itemBackgroundXPos + itemBackgroundWidth , itemBackgroundYPos + itemBackgroundHeight ) ;
glVertex2f ( itemBackgroundXPos , itemBackgroundYPos + itemBackgroundHeight ) ;
2023-10-15 23:36:26 -04:00
glEnd ( ) ;
// HP Bar
2023-09-15 11:24:43 -04:00
float playerHp = m_player . GetHP ( ) ;
2023-09-16 00:12:14 -04:00
float facteurOmbrage = m_displayInfo ? 0.5f : 1.0f ;
2023-09-15 11:24:43 -04:00
2023-10-31 11:11:14 -04:00
float hpBarWidthProportion = 0.25f ;
float hpBarHeightProportion = 0.045f ;
float hpBarWidth = Width ( ) * hpBarWidthProportion ;
float hpBarHeight = Height ( ) * hpBarHeightProportion ;
float hpBarXOffset = Width ( ) * 0.05f ;
float hpBarYOffset = Height ( ) * 0.7f ;
float hpBarYPos = Height ( ) - hpBarHeight - hpBarYOffset ;
2023-10-15 23:36:26 -04:00
// HP Bar Background
2023-09-16 00:12:14 -04:00
glColor3f ( 1.0f * facteurOmbrage , 1.0f * facteurOmbrage , 1.0f * facteurOmbrage ) ;
2023-09-15 11:24:43 -04:00
glBegin ( GL_QUADS ) ;
2023-10-31 11:11:14 -04:00
glVertex2f ( itemBackgroundXPos , hpBarYPos - hpBarHeight ) ;
glVertex2f ( itemBackgroundXPos + itemBackgroundWidth , hpBarYPos - hpBarHeight ) ;
glVertex2f ( itemBackgroundXPos + itemBackgroundWidth , hpBarYPos ) ;
glVertex2f ( itemBackgroundXPos , hpBarYPos ) ;
2023-09-15 11:24:43 -04:00
glEnd ( ) ;
2023-10-18 09:33:56 -04:00
//TODO: Associer avec mechanique de vie du joueur
2023-09-16 00:12:14 -04:00
// Barre HP
glColor3f ( 0.0f * facteurOmbrage , 1.0f * facteurOmbrage , 0.0f * facteurOmbrage ) ;
2023-09-15 11:24:43 -04:00
glBegin ( GL_QUADS ) ;
2023-10-31 11:11:14 -04:00
glVertex2f ( itemBackgroundXPos , hpBarYPos - hpBarHeight ) ;
glVertex2f ( itemBackgroundXPos + itemBackgroundWidth * playerHp , hpBarYPos - hpBarHeight ) ;
glVertex2f ( itemBackgroundXPos + itemBackgroundWidth * playerHp , hpBarYPos ) ;
glVertex2f ( itemBackgroundXPos , hpBarYPos ) ;
2023-09-15 11:24:43 -04:00
glEnd ( ) ;
2023-09-16 00:12:14 -04:00
2023-10-15 23:36:26 -04:00
// Equip Bar
2023-09-15 11:24:43 -04:00
glEnable ( GL_BLEND ) ;
2023-09-16 00:12:14 -04:00
glBlendFunc ( GL_SRC_ALPHA , GL_ONE_MINUS_SRC_ALPHA ) ;
glColor3f ( 1.0f * facteurOmbrage , 1.0f * facteurOmbrage , 1.0f * facteurOmbrage ) ;
2023-10-31 11:11:14 -04:00
float equipWidthProportion = 0.8f ;
float equipHeightProportion = 0.7f ;
float equipWidth = itemBackgroundWidth * equipWidthProportion ;
float equipHeight = itemBackgroundHeight * equipHeightProportion ;
float equipXOffset = itemBackgroundXPos + ( itemBackgroundWidth - equipWidth ) * 0.1f ;
float equipYOffset = itemBackgroundYPos + ( itemBackgroundHeight - equipHeight ) * 0.75f ;
2023-09-16 00:12:14 -04:00
2023-10-31 11:11:14 -04:00
glTranslatef ( equipXOffset , equipYOffset , 0 ) ;
2023-09-16 00:12:14 -04:00
2023-10-15 23:36:26 -04:00
m_textureGun . Bind ( ) ;
2023-09-16 00:12:14 -04:00
glBegin ( GL_QUADS ) ;
2023-10-31 11:11:14 -04:00
glTexCoord2f ( 0 , 0 ) ; glVertex2f ( 0 , 0 ) ;
glTexCoord2f ( 1 , 0 ) ; glVertex2f ( equipWidth , 0 ) ;
glTexCoord2f ( 1 , 1 ) ; glVertex2f ( equipWidth , equipHeight ) ;
glTexCoord2f ( 0 , 1 ) ; glVertex2f ( 0 , equipHeight ) ;
2023-09-16 00:12:14 -04:00
glEnd ( ) ;
// Username
glEnable ( GL_BLEND ) ;
glBlendFunc ( GL_SRC_ALPHA , GL_ONE ) ;
2023-09-15 20:28:20 -04:00
glColor3f ( 1.0f , 1.0f , 1.0f ) ;
2023-10-15 23:36:26 -04:00
2023-09-16 00:12:14 -04:00
m_textureFont . Bind ( ) ;
std : : ostringstream ss ;
2023-10-31 11:11:14 -04:00
float fUsernamePosY = hpBarYPos - ( hpBarHeight * 2 ) ;
2023-10-25 01:01:25 -04:00
ss . str ( " " ) ;
2023-09-15 20:28:20 -04:00
ss < < m_player . GetUsername ( ) ;
2023-10-31 11:11:14 -04:00
PrintText ( itemBackgroundXPos , fUsernamePosY , ss . str ( ) , 1.5f ) ;
2023-09-23 17:15:35 -04:00
2023-10-25 01:01:25 -04:00
ss . str ( " " ) ;
2023-10-15 23:36:26 -04:00
ss < < m_player . GetHP ( ) * 100 < < " % " ;
2023-10-31 11:11:14 -04:00
PrintText ( itemBackgroundXPos * 5.25f , fUsernamePosY , ss . str ( ) , 1.5f ) ;
float countdownXOffset = Width ( ) * 0.2f ;
float countdownYOffset = Height ( ) * 0.1f ;
float countdownXPos = Width ( ) - countdownXOffset ;
float countdownYPos = Height ( ) - countdownYOffset ;
2023-09-23 17:15:35 -04:00
2023-10-15 23:36:26 -04:00
// Countdown
2023-09-23 17:15:35 -04:00
ss . str ( " " ) ;
ss < < " Time: " < < ( int ) ( timer / 60 ) < < " : " < < std : : setw ( 2 ) < < std : : setfill ( ' 0 ' ) < < timer % 60 ;
2023-10-31 11:11:14 -04:00
PrintText ( countdownXPos , countdownYPos , ss . str ( ) , 2.0f ) ;
2023-09-15 11:24:43 -04:00
}
2023-09-15 20:28:20 -04:00
void Engine : : DisplayInfo ( float elapsedTime , BlockType bloc ) {
2021-10-26 17:28:37 -04:00
m_textureFont . Bind ( ) ;
std : : ostringstream ss ;
2023-09-16 00:12:14 -04:00
2023-10-31 11:11:14 -04:00
float marginX = Width ( ) * 0.01 ;
float marginY = Height ( ) * 0.05 ;
float fPosX = marginX ;
float fPosY = Height ( ) - marginY ;
2023-09-16 00:12:14 -04:00
2023-10-15 23:36:26 -04:00
float charSize = 20 + ( 24 - 20 ) * ( Width ( ) - 1600 ) / ( 1920 - 1600 ) ;
2023-09-16 00:12:14 -04:00
2021-10-26 17:28:37 -04:00
ss < < " Fps : " < < GetFps ( elapsedTime ) ;
2023-10-15 23:36:26 -04:00
PrintText ( fPosX , fPosY , ss . str ( ) ) ;
2021-10-26 17:28:37 -04:00
ss . str ( " " ) ;
2023-10-15 23:36:26 -04:00
fPosY - = charSize ;
2021-11-26 11:59:02 -05:00
ss < < " Rendered Chunks : " < < m_renderCount ;
2023-10-15 23:36:26 -04:00
PrintText ( fPosX , fPosY , ss . str ( ) ) ;
2021-11-26 11:59:02 -05:00
ss . str ( " " ) ;
2023-10-15 23:36:26 -04:00
fPosY - = charSize ;
2021-12-15 21:00:06 -05:00
ss < < " To-Be-Deleted Chunks : " < < m_world . GettbDeleted ( ) ;
2023-10-15 23:36:26 -04:00
PrintText ( fPosX , fPosY , ss . str ( ) ) ;
2021-12-15 21:00:06 -05:00
ss . str ( " " ) ;
2023-10-15 23:36:26 -04:00
fPosY - = charSize ;
2023-10-31 11:11:14 -04:00
float fPosYJump = Height ( ) * 0.09 ;
2023-10-15 23:36:26 -04:00
fPosY = fPosYJump ;
fPosY - = charSize ;
2023-11-19 16:46:13 -05:00
ss < < " Velocity : " < < m_remotePlayer . GetVelocity ( ) ;
2023-10-15 23:36:26 -04:00
PrintText ( fPosX , fPosY , ss . str ( ) ) ;
2021-10-26 17:28:37 -04:00
ss . str ( " " ) ;
2023-10-15 23:36:26 -04:00
fPosY - = charSize ;
2023-11-19 16:46:13 -05:00
ss < < " Player Position : " < < m_player . GetPosition ( ) ;
2023-10-15 23:36:26 -04:00
PrintText ( fPosX , fPosY , ss . str ( ) ) ;
2021-10-26 17:28:37 -04:00
ss . str ( " " ) ;
2023-10-15 23:36:26 -04:00
fPosY - = charSize ;
2023-11-19 16:46:13 -05:00
ss < < " Remote Position : " < < m_remotePlayer . GetPosition ( ) ; //m_player.GetPosition();
2023-10-15 23:36:26 -04:00
PrintText ( fPosX , fPosY , ss . str ( ) ) ;
2021-12-07 18:59:50 -05:00
ss . str ( " " ) ;
2023-10-15 23:36:26 -04:00
fPosY - = charSize ;
2023-09-16 00:12:14 -04:00
2023-10-15 23:36:26 -04:00
ss < < " Block : " ;
2021-12-07 18:59:50 -05:00
if ( bloc = = BTYPE_LAST )
2023-10-15 23:36:26 -04:00
ss < < " Weapon " ;
else
ss < < ( int ) bloc ;
PrintText ( fPosX , fPosYJump , ss . str ( ) ) ;
2023-09-15 20:28:20 -04:00
}
2023-10-23 16:11:35 -04:00
void Engine : : DisplaySingleOrMultiplayerMenu ( ) {
2023-10-31 11:11:14 -04:00
GLint viewport [ 4 ] ;
glGetIntegerv ( GL_VIEWPORT , viewport ) ;
2023-10-25 01:01:25 -04:00
glEnable ( GL_BLEND ) ;
glBlendFunc ( GL_SRC_ALPHA , GL_ONE_MINUS_SRC_ALPHA ) ;
glBlendEquation ( GL_FUNC_ADD ) ;
2023-10-23 16:11:35 -04:00
glDisable ( GL_STENCIL_TEST ) ;
glDisable ( GL_DEPTH_TEST ) ;
glMatrixMode ( GL_PROJECTION ) ;
glPushMatrix ( ) ;
glLoadIdentity ( ) ;
glOrtho ( 0 , Width ( ) , 0 , Height ( ) , - 1 , 1 ) ;
glMatrixMode ( GL_MODELVIEW ) ;
glPushMatrix ( ) ;
2023-10-31 11:11:14 -04:00
// Background
2023-10-25 01:01:25 -04:00
m_textureSoloMultiMenu . Bind ( ) ;
2023-10-23 16:11:35 -04:00
glBegin ( GL_QUADS ) ;
2023-10-31 11:11:14 -04:00
glTexCoord2f ( 0.0f , 0.0f ) ; glVertex2f ( 0.0f , 0.0f ) ;
glTexCoord2f ( 1.0f , 0.0f ) ; glVertex2f ( Width ( ) , 0.0f ) ;
glTexCoord2f ( 1.0f , 1.0f ) ; glVertex2f ( Width ( ) , Height ( ) ) ;
glTexCoord2f ( 0.0f , 1.0f ) ; glVertex2f ( 0.0f , Height ( ) ) ;
2023-10-23 16:11:35 -04:00
glEnd ( ) ;
2023-10-29 15:39:29 -04:00
// Title
2023-10-31 11:11:14 -04:00
float titleWidthProportion = 0.4f ;
float titleHeightProportion = 0.4f ;
float titleWidth = titleWidthProportion * Width ( ) ;
float titleHeight = titleHeightProportion * Height ( ) ;
float offsetTitleXFactor = 0.05f ;
float offsetTitleYFactor = 0.05f ;
m_titleX = ( Width ( ) - titleWidth ) - ( offsetTitleXFactor * Width ( ) ) ;
m_titleY = ( Height ( ) - titleHeight ) - ( offsetTitleYFactor * Height ( ) ) ;
2023-10-23 16:11:35 -04:00
2023-10-25 01:01:25 -04:00
m_textureTitle . Bind ( ) ;
2023-10-31 11:11:14 -04:00
glColor4f ( 1.0f , 0.5f , 0.0f , 1.0f ) ;
2023-10-25 01:01:25 -04:00
glBegin ( GL_QUADS ) ;
2023-10-31 11:11:14 -04:00
glTexCoord2f ( 0.0f , 0.0f ) ; glVertex2f ( m_titleX , m_titleY ) ;
glTexCoord2f ( 1.0f , 0.0f ) ; glVertex2f ( m_titleX + titleWidth , m_titleY ) ;
glTexCoord2f ( 1.0f , 1.0f ) ; glVertex2f ( m_titleX + titleWidth , m_titleY + titleHeight ) ;
glTexCoord2f ( 0.0f , 1.0f ) ; glVertex2f ( m_titleX , m_titleY + titleHeight ) ;
2023-10-25 01:01:25 -04:00
glEnd ( ) ;
glBindTexture ( GL_TEXTURE_2D , 0 ) ;
2023-10-31 11:11:14 -04:00
// Single Player and Multiplayer button background quads
float buttonWidthProportion = 0.4f ;
float buttonHeightProportion = 0.075f ;
float buttonWidth = buttonWidthProportion * Width ( ) ;
float buttonHeight = buttonHeightProportion * Height ( ) ;
float offsetSingleButtonXFactor = 0.075f ;
float offsetSingleButtonYFactor = 0.05f ;
2023-10-25 01:01:25 -04:00
2023-10-31 11:11:14 -04:00
float buttonPosX = m_titleX ;
float buttonSinglePosY = m_titleY - buttonHeight - ( offsetSingleButtonYFactor * Height ( ) ) ;
float buttonMultiPosY = ( buttonSinglePosY * 0.75 ) ;
2023-10-25 01:01:25 -04:00
2023-10-31 11:11:14 -04:00
// Single Player background
2023-10-25 01:01:25 -04:00
glColor4f ( 1.0f , 1.0f , 1.0f , 0.5f ) ;
glBegin ( GL_QUADS ) ;
2023-10-31 11:11:14 -04:00
glTexCoord2f ( 0.0f , 0.0f ) ; glVertex2f ( buttonPosX , buttonSinglePosY ) ;
glTexCoord2f ( 1.0f , 0.0f ) ; glVertex2f ( buttonPosX + buttonWidth , buttonSinglePosY ) ;
glTexCoord2f ( 1.0f , 1.0f ) ; glVertex2f ( buttonPosX + buttonWidth , buttonSinglePosY + buttonHeight ) ;
glTexCoord2f ( 0.0f , 1.0f ) ; glVertex2f ( buttonPosX , buttonSinglePosY + buttonHeight ) ;
2023-10-25 01:01:25 -04:00
glEnd ( ) ;
2023-10-31 11:11:14 -04:00
// Single Player text
2023-10-29 15:39:29 -04:00
m_textureSoloText . Bind ( ) ;
2023-10-31 11:11:14 -04:00
glColor4f ( 0.75f , 0.05f , 0.0f , 1.0f ) ;
2023-10-29 15:39:29 -04:00
glBegin ( GL_QUADS ) ;
2023-10-31 11:11:14 -04:00
glTexCoord2f ( 0.0f , 0.0f ) ; glVertex2f ( buttonPosX , buttonSinglePosY ) ;
glTexCoord2f ( 1.0f , 0.0f ) ; glVertex2f ( buttonPosX + buttonWidth , buttonSinglePosY ) ;
glTexCoord2f ( 1.0f , 1.0f ) ; glVertex2f ( buttonPosX + buttonWidth , buttonSinglePosY + buttonHeight ) ;
glTexCoord2f ( 0.0f , 1.0f ) ; glVertex2f ( buttonPosX , buttonSinglePosY + buttonHeight ) ;
2023-10-25 01:01:25 -04:00
glEnd ( ) ;
2023-10-29 15:39:29 -04:00
glBindTexture ( GL_TEXTURE_2D , 0 ) ;
2023-10-31 11:11:14 -04:00
// Multi Player background
2023-10-29 15:39:29 -04:00
glColor4f ( 1.0f , 1.0f , 1.0f , 0.5f ) ;
2023-10-25 01:01:25 -04:00
glBegin ( GL_QUADS ) ;
2023-10-31 11:11:14 -04:00
glTexCoord2f ( 0.0f , 0.0f ) ; glVertex2f ( buttonPosX , buttonMultiPosY ) ;
glTexCoord2f ( 1.0f , 0.0f ) ; glVertex2f ( buttonPosX + buttonWidth , buttonMultiPosY ) ;
glTexCoord2f ( 1.0f , 1.0f ) ; glVertex2f ( buttonPosX + buttonWidth , buttonMultiPosY + buttonHeight ) ;
glTexCoord2f ( 0.0f , 1.0f ) ; glVertex2f ( buttonPosX , buttonMultiPosY + buttonHeight ) ;
2023-10-25 01:01:25 -04:00
glEnd ( ) ;
2023-10-31 11:11:14 -04:00
// Multi Player text
2023-10-29 15:39:29 -04:00
m_textureMultiText . Bind ( ) ;
2023-10-31 11:11:14 -04:00
glColor4f ( 0.75f , 0.05f , 0.0f , 1.0f ) ;
2023-10-25 01:01:25 -04:00
glBegin ( GL_QUADS ) ;
2023-10-31 11:11:14 -04:00
glTexCoord2f ( 0.0f , 0.0f ) ; glVertex2f ( buttonPosX , buttonMultiPosY ) ;
glTexCoord2f ( 1.0f , 0.0f ) ; glVertex2f ( buttonPosX + buttonWidth , buttonMultiPosY ) ;
glTexCoord2f ( 1.0f , 1.0f ) ; glVertex2f ( buttonPosX + buttonWidth , buttonMultiPosY + buttonHeight ) ;
glTexCoord2f ( 0.0f , 1.0f ) ; glVertex2f ( buttonPosX , buttonMultiPosY + buttonHeight ) ;
2023-10-25 01:01:25 -04:00
glEnd ( ) ;
2023-10-25 02:06:29 -04:00
glColor4f ( 1.0f , 1.0f , 1.0f , 1.0f ) ;
2023-10-23 16:11:35 -04:00
2023-10-31 11:11:14 -04:00
// Reset the state
glViewport ( viewport [ 0 ] , viewport [ 1 ] , viewport [ 2 ] , viewport [ 3 ] ) ;
2023-10-23 16:11:35 -04:00
glEnable ( GL_STENCIL_TEST ) ;
glEnable ( GL_DEPTH_TEST ) ;
2023-09-16 00:12:14 -04:00
2023-10-23 16:11:35 -04:00
glMatrixMode ( GL_PROJECTION ) ;
glPopMatrix ( ) ;
glMatrixMode ( GL_MODELVIEW ) ;
glPopMatrix ( ) ;
2023-10-29 15:39:29 -04:00
ShowCursor ( ) ;
2023-09-15 20:28:20 -04:00
}
void Engine : : DrawHud ( float elapsedTime , BlockType bloc ) {
2023-09-16 00:12:14 -04:00
// Setter le blend function, tout ce qui sera noir sera transparent
2023-09-15 20:28:20 -04:00
glDisable ( GL_STENCIL_TEST ) ;
2023-09-16 00:12:14 -04:00
glDisable ( GL_DEPTH_TEST ) ;
2023-09-15 20:28:20 -04:00
glBlendFunc ( GL_SRC_ALPHA , GL_ONE ) ;
glBlendEquation ( GL_FUNC_ADD ) ;
2023-10-16 17:36:04 -04:00
glEnable ( GL_BLEND ) ;
2023-09-16 00:12:14 -04:00
2023-09-15 20:28:20 -04:00
glMatrixMode ( GL_PROJECTION ) ;
glPushMatrix ( ) ;
2023-09-16 00:12:14 -04:00
2023-09-15 20:28:20 -04:00
glLoadIdentity ( ) ;
glOrtho ( 0 , Width ( ) , 0 , Height ( ) , - 1 , 1 ) ;
2023-09-16 00:12:14 -04:00
2023-09-15 20:28:20 -04:00
glMatrixMode ( GL_MODELVIEW ) ;
glPushMatrix ( ) ;
2023-09-23 17:15:35 -04:00
int timer = GetCountdown ( elapsedTime ) ;
2023-11-08 10:32:16 -05:00
for ( int i = 1 ; i < WORLD_SIZE_X ; i + + )
{
2023-11-15 08:27:51 -05:00
if ( timer < = COUNTDOWN - m_timerReductionChunk * i ) {
2023-11-08 10:32:16 -05:00
m_world . RemoveChunk ( m_nbReductionChunk * i ) ;
2023-11-15 08:27:51 -05:00
m_renderer . RemoveChunk ( m_nbReductionChunk * i ) ;
}
2023-11-08 10:32:16 -05:00
}
2023-10-02 15:55:45 -04:00
if ( m_keyK ) {
SystemNotification ( m_messageNotification ) ;
m_keyK = false ;
}
if ( m_keyL ) {
2023-10-23 16:11:35 -04:00
2023-10-02 15:55:45 -04:00
KillNotification ( m_player , m_player ) ;
m_keyL = false ;
}
2023-09-15 20:28:20 -04:00
if ( m_displayInfo ) {
DisplayInfo ( elapsedTime , bloc ) ;
}
2023-09-16 00:12:14 -04:00
if ( m_displayHud ) {
2023-09-23 17:15:35 -04:00
DisplayHud ( timer ) ;
2023-09-16 00:12:14 -04:00
}
2023-09-15 20:28:20 -04:00
if ( m_displayCrosshair ) {
DisplayCrosshair ( ) ;
}
2023-09-15 11:24:43 -04:00
2021-12-06 11:08:34 -05:00
glBlendFunc ( GL_CONSTANT_COLOR , GL_ONE_MINUS_CONSTANT_COLOR ) ;
glBlendEquation ( GL_FUNC_SUBTRACT ) ;
2023-09-16 00:12:14 -04:00
2021-12-06 11:08:34 -05:00
glEnable ( GL_STENCIL_TEST ) ;
2023-09-16 00:12:14 -04:00
glEnable ( GL_DEPTH_TEST ) ;
2021-10-26 17:28:37 -04:00
glMatrixMode ( GL_PROJECTION ) ;
glPopMatrix ( ) ;
2023-09-16 00:12:14 -04:00
2021-10-26 17:28:37 -04:00
glMatrixMode ( GL_MODELVIEW ) ;
glPopMatrix ( ) ;
}
2023-10-15 23:36:26 -04:00
void Engine : : PrintText ( float x , float y , const std : : string & t , float charSizeMultiplier ) {
2023-10-31 11:11:14 -04:00
float windowWidth = static_cast < float > ( Width ( ) ) ;
float windowHeight = static_cast < float > ( Height ( ) ) ;
2023-10-15 23:36:26 -04:00
2023-10-31 11:11:14 -04:00
float posX = x * windowWidth ;
float posY = y * windowHeight ;
2023-10-15 23:36:26 -04:00
2023-10-31 11:11:14 -04:00
float baseCharSize = 20 + ( 24 - 20 ) * ( windowWidth - 1600 ) / ( 1920 - 1600 ) ;
2023-10-15 23:36:26 -04:00
float charSize = baseCharSize * charSizeMultiplier ;
2021-10-26 17:28:37 -04:00
glLoadIdentity ( ) ;
glTranslated ( x , y , 0 ) ;
2023-09-16 00:12:14 -04:00
2021-10-26 17:28:37 -04:00
for ( unsigned int i = 0 ; i < t . length ( ) ; + + i ) {
float left = ( float ) ( ( t [ i ] - 32 ) % 16 ) / 16.f ;
float top = ( float ) ( ( t [ i ] - 32 ) / 16 ) / 16.f ;
2023-10-15 23:36:26 -04:00
top + = 0.5f ;
2023-09-16 00:12:14 -04:00
2021-10-26 17:28:37 -04:00
glBegin ( GL_QUADS ) ;
2023-10-15 23:36:26 -04:00
glTexCoord2f ( left , 1.f - top - .0625f ) ; glVertex2f ( 0 , 0 ) ;
2023-10-31 11:11:14 -04:00
glTexCoord2f ( left + .0625f , 1.f - top - .0625f ) ; glVertex2f ( charSize , 0 ) ;
glTexCoord2f ( left + .0625f , 1.f - top ) ; glVertex2f ( charSize , charSize ) ;
glTexCoord2f ( left , 1.f - top ) ; glVertex2f ( 0 , charSize ) ;
2021-10-26 17:28:37 -04:00
glEnd ( ) ;
2023-09-15 11:24:43 -04:00
2023-10-31 11:11:14 -04:00
glTranslated ( 0.5555f * charSize , 0 , 0 ) ;
2021-10-26 17:28:37 -04:00
}
}
int Engine : : GetFps ( float elapsedTime ) const { return 1 / elapsedTime ; }
2023-10-18 09:33:56 -04:00
2023-09-23 17:15:35 -04:00
int Engine : : GetCountdown ( float elapsedTime ) {
if ( m_resetcountdown )
{
2023-11-08 10:32:16 -05:00
m_nbReductionChunk = 4 ;
m_timerReductionChunk = 30 ;
2023-09-23 17:15:35 -04:00
m_countdown = m_time + COUNTDOWN ;
m_resetcountdown = false ;
}
2023-09-25 15:38:37 -04:00
if ( m_countdown < m_time )
Stop ( ) ;
2023-10-23 16:11:35 -04:00
if ( ! m_stopcountdown )
2023-09-23 17:15:35 -04:00
m_time + = elapsedTime ;
return m_countdown - ( int ) m_time ;
}
2021-10-26 17:28:37 -04:00
void Engine : : Render ( float elapsedTime ) {
2021-12-06 09:45:51 -05:00
glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT ) ;
2021-09-27 10:20:58 -04:00
2023-10-23 16:57:19 -04:00
m_time_SplashScreen + = elapsedTime ;
2023-10-29 15:39:29 -04:00
if ( m_time_SplashScreen < 2 ) {
2023-10-30 15:36:43 -04:00
DrawSplachScreen ( ) ;
2023-10-29 15:39:29 -04:00
}
2023-10-23 16:57:19 -04:00
else if ( m_gamestate = = GameState : : PLAY )
2023-10-02 17:09:03 -04:00
{
2023-10-16 17:36:04 -04:00
HideCursor ( ) ;
2023-10-16 16:35:26 -04:00
CenterMouse ( ) ; //D<> placement de centermouse dans l'action de jouer
2021-09-27 10:20:58 -04:00
2023-10-02 17:09:03 -04:00
//static float gameTime = elapsedTime;
2023-10-16 16:35:26 -04:00
static irrklang : : ISound * step ; // Pour les sons de pas.
2023-10-16 17:36:04 -04:00
static float pollTime = 0 ;
2023-10-02 17:09:03 -04:00
static float bulletTime = 0 ;
static BlockType bloc = 1 ;
2022-04-02 15:26:55 -04:00
2023-10-02 17:09:03 -04:00
if ( elapsedTime > 0.1f ) return ;
2021-11-19 13:25:52 -05:00
2023-10-02 17:09:03 -04:00
//gameTime += elapsedTime;
pollTime + = elapsedTime ;
2023-09-15 11:24:43 -04:00
2023-10-02 17:09:03 -04:00
Transformation all ;
Transformation skybox ;
2023-11-18 14:16:24 -05:00
Transformation remotePlayer ;
2023-10-16 17:36:04 -04:00
Vector3f vstep ;
2021-12-06 21:46:46 -05:00
2023-10-02 17:09:03 -04:00
// Transformations initiales
glMatrixMode ( GL_MODELVIEW ) ;
glLoadIdentity ( ) ;
2021-12-07 18:59:50 -05:00
2023-10-02 17:09:03 -04:00
if ( bulletTime > 0.f ) bulletTime - = elapsedTime ;
if ( bulletTime < 0.f ) bulletTime = 0.f ;
2022-04-02 15:26:55 -04:00
2023-10-16 17:36:04 -04:00
static bool leftright = false ;
if ( pollTime > = .005f ) {
Player : : Sound snd = m_player . ApplyPhysics ( m_player . GetInput ( m_keyW , m_keyS , m_keyA , m_keyD , m_keySpace , ( bloc = = BTYPE_LAST & & bulletTime < = 0.f & & m_mouseL ) , elapsedTime ) , & m_world , elapsedTime ) ;
switch ( snd ) {
case Player : : Sound : : STEP :
if ( leftright )
vstep = Vector3f ( m_player . GetPosition ( ) . x + m_player . GetDirection ( ) . z , m_player . GetPosition ( ) . y - 1.7f , m_player . GetPosition ( ) . z + m_player . GetDirection ( ) . x ) ;
else vstep = Vector3f ( m_player . GetPosition ( ) . x - m_player . GetDirection ( ) . z , m_player . GetPosition ( ) . y - 1.7f , m_player . GetPosition ( ) . z - m_player . GetDirection ( ) . x ) ;
2023-10-30 15:36:43 -04:00
m_audio . Create3DAudioObj ( step , AUDIO_PATH " step.wav " , vstep , m_player . GetVelocity ( ) , false , .8f ) ;
2023-10-16 17:36:04 -04:00
leftright = ! leftright ;
break ;
case Player : : Sound : : FALL :
2023-10-30 15:36:43 -04:00
m_audio . Create3DAudioObj ( step , AUDIO_PATH " hit.wav " , m_player . GetPosition ( ) , m_player . GetVelocity ( ) , false , 1.f ) ;
2023-10-16 17:36:04 -04:00
break ;
default : break ;
2021-12-07 18:59:50 -05:00
}
2023-10-18 09:33:56 -04:00
m_audio . Update3DAudio ( m_player . GetPOV ( ) , m_player . GetDirection ( ) , m_player . GetVelocity ( ) ) ; // Ajustement du positionnement 3D avec les coordonnees du joueur et
// son vecteur de velocite (pour l'effet Doppler)
2023-10-16 17:36:04 -04:00
pollTime = 0 ;
2023-10-02 17:09:03 -04:00
}
2021-11-19 13:25:52 -05:00
2023-10-02 17:09:03 -04:00
m_player . ApplyTransformation ( all ) ;
m_player . ApplyTransformation ( skybox , false ) ; // Version d'ApplyTransformation qui ne tient compte que de la rotation
// (donc l'objet ne bouge pas relativement au joueur, ce qui est pratique pour une skybox!).
2023-11-13 16:02:13 -05:00
2023-11-19 16:46:13 -05:00
m_player . ApplyTransformation ( remotePlayer , true , false ) ;
2023-10-02 17:09:03 -04:00
if ( m_mouseWU ) bloc + + ;
else if ( m_mouseWD ) bloc - - ;
if ( bloc = = BTYPE_LAST + 1 ) bloc = BTYPE_AIR + 1 ;
2023-10-16 16:35:26 -04:00
else if ( bloc = = BTYPE_AIR ) bloc = BTYPE_LAST ; // La selection de BTYPE_LAST <20> quipe l'arme.
2023-10-02 17:09:03 -04:00
m_mouseWU = m_mouseWD = false ;
2023-10-16 17:36:04 -04:00
if ( m_mouseL ) {
if ( bloc ! = BTYPE_LAST )
m_world . ChangeBlockAtCursor ( bloc , m_player . GetPosition ( ) , m_player . GetDirection ( ) , m_block ) ;
else if ( bulletTime < = 0.f ) {
for ( int x = 0 ; x < MAX_BULLETS ; + + x ) // Ajouter une balle dans l'array (aussi connu sous le nom de "faire pow pow").
if ( ! m_bullets [ x ] ) {
m_bullets [ x ] = new Bullet ( m_player . GetPOV ( ) + m_player . GetDirection ( ) , m_player . GetDirection ( ) ) ;
break ;
}
2023-10-27 13:27:00 -04:00
else if ( x = = MAX_BULLETS - 1 ) { // S'il y a pas d'espace dans l'array, prendre la place de la première balle de l'array.
2023-10-16 17:36:04 -04:00
m_bullets [ 0 ] - > ~ Bullet ( ) ;
m_bullets [ 0 ] = new Bullet ( m_player . GetPOV ( ) + m_player . GetDirection ( ) , m_player . GetDirection ( ) ) ;
}
2023-10-27 13:27:00 -04:00
bulletTime = BULLET_TIME ;
m_audio . Create3DAudioObj ( m_powpow , AUDIO_PATH " pow.wav " , m_player . GetPOV ( ) , m_player . GetDirection ( ) * 10 , false , .5f ) ;
if ( m_flash ) { // Coupe le rendering et affiche un frame blanc, pour simuler un flash.
glClearColor ( .8f , .8f , .8f , 1.f ) ;
glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT ) ;
glClearColor ( 0.f , 0.f , 0.f , 1.f ) ;
return ;
}
2023-10-30 15:36:43 -04:00
}
2021-12-07 18:59:50 -05:00
}
2023-10-30 15:36:43 -04:00
else if ( m_mouseR )
m_world . ChangeBlockAtCursor ( BTYPE_AIR , m_player . GetPosition ( ) , m_player . GetDirection ( ) , m_block ) ;
for ( int x = 0 ; x < MAX_BULLETS ; + + x ) { // Array de bullets en jeu.
if ( m_bullets [ x ] ) {
for ( int b = 0 ; b < BULLET_UPDATES_PER_FRAME ; + + b ) {
2023-11-01 08:59:09 -04:00
if ( m_bullets [ x ] - > Update ( & m_world , elapsedTime , BULLET_UPDATES_PER_FRAME , m_players ) ) {
2023-10-30 15:36:43 -04:00
m_bullets [ x ] - > ~ Bullet ( ) ;
if ( m_whoosh [ x ] )
m_whoosh [ x ] - > drop ( ) ;
m_bullets [ x ] = nullptr ;
m_whoosh [ x ] = nullptr ;
break ;
}
else if ( ! m_whoosh [ x ] ) {
m_whoosh [ x ] = m_audio . Create3DAudioObj ( m_whoosh [ x ] , AUDIO_PATH " noise.wav " , m_bullets [ x ] - > getPos ( ) , m_bullets [ x ] - > getVel ( ) , true , ( m_bullets [ x ] - > getPos ( ) - m_player . GetPosition ( ) ) . Length ( ) ) ;
}
else {
Vector3f pos = m_bullets [ x ] - > getPos ( ) , vel = m_bullets [ x ] - > getVel ( ) ;
m_audio . Render3DAudioObj ( m_whoosh [ x ] , pos , vel , 5 - ( m_bullets [ x ] - > getPos ( ) - m_player . GetPosition ( ) ) . Length ( ) ) ;
}
2023-10-27 12:23:45 -04:00
}
2023-10-27 13:27:00 -04:00
}
2023-10-16 12:02:37 -04:00
}
2021-12-07 18:59:50 -05:00
2023-11-19 16:46:13 -05:00
m_remotePlayer . ApplyPhysics ( Vector3f ( 0 , 0 , 0 ) , & m_world , elapsedTime ) ;
2023-11-18 14:16:24 -05:00
//m_remotePlayer.ApplyTransformation(remotePlayer, false);
2023-10-16 17:36:04 -04:00
m_world . Update ( m_bullets , m_player . GetPosition ( ) , m_blockinfo ) ;
2023-10-27 14:08:06 -04:00
m_renderer . UpdateMesh ( & m_world , m_player . GetPosition ( ) , m_blockinfo ) ;
2023-11-19 16:46:13 -05:00
m_remotePlayer . Render ( m_textureAtlas , m_shader01 , all , elapsedTime ) ;
2023-11-20 15:40:43 -05:00
m_booster . RenderBillboard ( { 120 , 20 , 120 } , m_textureAtlas , texBoostHeal , m_shader01 , all ) ;
2021-11-26 11:59:02 -05:00
2023-11-19 16:46:13 -05:00
if ( m_isSkybox ) m_renderer . RenderWorld ( & m_world , m_renderCount , m_player . GetPosition ( ) , m_player . GetDirection ( ) , all , m_shader01 , m_textureAtlas ) ;
2023-10-02 17:09:03 -04:00
2023-11-19 16:46:13 -05:00
//glClear(GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
//m_remotePlayer.Render(m_textureAtlas, m_shader01, all, elapsedTime);
2021-11-26 11:59:02 -05:00
2023-10-02 17:09:03 -04:00
2023-11-20 15:20:20 -05:00
if ( m_isSkybox ) m_skybox . Render ( skybox ) ;
2023-10-16 17:36:04 -04:00
2023-11-18 14:16:24 -05:00
2023-11-20 15:20:20 -05:00
DrawHud ( elapsedTime , bloc ) ;
DisplayPovGun ( ) ;
2023-10-27 14:53:45 -04:00
ProcessNotificationQueue ( ) ;
2023-10-30 14:36:44 -04:00
if ( m_damage )
{
InstantDamage ( ) ;
}
2023-10-16 17:36:04 -04:00
static bool fell = false ;
if ( m_player . GetPosition ( ) . y < 1.7f & & ! fell ) {
2023-10-30 15:36:43 -04:00
m_audio . Create3DAudioObj ( m_scream , AUDIO_PATH " scream.wav " , m_player . GetPOV ( ) , m_player . GetVelocity ( ) , false , 1.f ) ;
2023-10-16 17:36:04 -04:00
fell = true ;
}
else if ( m_player . GetPosition ( ) . y < - 20.f ) {
m_player = Player ( Vector3f ( .5f , CHUNK_SIZE_Y + 1.8f , .5f ) ) ; // Respawn si le bonho- joueur tombe en bas du monde.
fell = false ;
}
2023-09-15 11:24:43 -04:00
2023-11-07 07:56:59 -05:00
if ( m_networkgame ) { // Pour se gerer le paquet.
2023-11-02 15:47:15 -04:00
using namespace std : : chrono ;
using namespace netprot ;
2023-11-07 07:56:59 -05:00
Timestamp tstamp = duration_cast < milliseconds > ( high_resolution_clock : : now ( ) - m_startTime ) . count ( ) ;
2023-11-02 15:47:15 -04:00
Input input ;
2023-11-07 07:56:59 -05:00
Sync sync ;
uint64_t id = m_conn . getId ( ) ;
2023-11-06 17:59:57 -05:00
static std : : vector < char * > lsPck ;
2023-10-23 16:44:34 -04:00
2023-11-07 07:56:59 -05:00
if ( false ) { // TODO: Faire un checkup pour chaque ~1000ms.
sync . sid = id ;
sync . timestamp = tstamp ;
sync . position = m_player . GetPosition ( ) ;
sync . hp = m_player . GetHP ( ) ;
// TODO: Garrocher ca quelque-part.
}
2023-10-23 16:44:34 -04:00
2023-11-07 07:56:59 -05:00
input . sid = id ;
2023-10-23 16:44:34 -04:00
input . direction = m_player . GetDirection ( ) ;
2023-11-07 07:56:59 -05:00
input . timestamp = tstamp ;
2023-10-23 16:44:34 -04:00
input . keys . forward = m_keyW ;
input . keys . backward = m_keyS ;
input . keys . left = m_keyA ;
input . keys . right = m_keyD ;
input . keys . jump = m_keySpace ;
input . keys . block = m_mouseR ;
input . keys . shoot = m_mouseL ;
2023-11-06 17:59:57 -05:00
sendPackTo < Input > ( m_conn . m_sock_udp , & input , & m_bufout , & m_conn . m_srvsockaddr ) ;
lsPck = recvPacks ( m_conn . m_sock_udp , & m_buf ) ;
2023-11-07 07:46:11 -05:00
char * prevptr = nullptr ;
for ( auto & pck : lsPck ) { // We could make a few threads out of this.
Sync sync ;
Output out ;
if ( ! prevptr )
prevptr = m_buf . ptr ;
uint32_t bsize = m_buf . len - ( pck - prevptr ) ;
prevptr = pck ;
switch ( getType ( pck , 1 ) ) {
using enum PACKET_TYPE ;
2023-11-06 17:59:57 -05:00
case SYNC :
2023-11-07 07:46:11 -05:00
if ( Deserialize ( & sync , pck , & bsize ) ) {
if ( sync . sid ! = m_conn . getId ( ) )
break ;
2023-11-07 07:56:59 -05:00
// TODO: Vérifier si les positions concordent au sync local.
2023-11-07 07:46:11 -05:00
}
2023-11-06 17:59:57 -05:00
break ;
case OUTPUT :
2023-11-07 07:46:11 -05:00
if ( Deserialize ( & out , pck , & bsize ) ) {
RemotePlayer * r = ( RemotePlayer * ) m_players [ out . id ] ;
r - > Feed ( out ) ;
}
2023-11-06 17:59:57 -05:00
break ;
default :
break ;
}
}
lsPck . clear ( ) ;
2023-10-23 16:44:34 -04:00
}
2021-12-07 18:59:50 -05:00
}
2023-10-16 17:36:04 -04:00
else if ( m_gamestate = = GameState : : MAIN_MENU | | m_gamestate = = GameState : : OPTIONS )
{
2023-10-29 15:39:29 -04:00
if ( ! m_soloMultiChoiceMade ) {
DisplaySingleOrMultiplayerMenu ( ) ;
}
else {
DrawMenu ( ) ;
}
2021-12-07 18:59:50 -05:00
}
2023-10-23 17:51:29 -04:00
else if ( m_gamestate = = GameState : : PAUSE )
{
2023-10-30 15:49:17 -04:00
DrawPause ( ) ;
2021-12-07 18:59:50 -05:00
}
2023-10-16 17:36:04 -04:00
else if ( m_gamestate = = GameState : : QUIT )
Stop ( ) ;
2021-09-24 10:15:43 -04:00
}
2021-12-02 18:12:35 -05:00
void Engine : : KeyPressEvent ( unsigned char key ) {
2021-10-11 11:37:58 -04:00
switch ( key ) {
2023-09-15 11:24:43 -04:00
case 0 : // A - Gauche
2021-09-27 10:20:58 -04:00
if ( ! m_keyA ) {
m_keyA = true ;
}
break ;
2023-09-15 11:24:43 -04:00
case 3 : // D - Droite
if ( ! m_keyD ) {
m_keyD = true ;
}
break ;
case 18 : // S - Reculer
2021-09-27 10:20:58 -04:00
if ( ! m_keyS ) {
m_keyS = true ;
}
break ;
2023-09-15 11:24:43 -04:00
case 22 : // W - Avancer
if ( ! m_keyW ) {
m_keyW = true ;
2021-09-27 10:20:58 -04:00
}
break ;
2023-09-15 11:24:43 -04:00
case 36 : // ESC - Quitter
2023-10-30 15:49:17 -04:00
if ( m_gamestate = = GameState : : PLAY )
{
m_gamestate = GameState : : PAUSE ;
}
else if ( m_gamestate = = GameState : : PAUSE )
{
m_gamestate = GameState : : PLAY ;
}
2023-10-16 17:36:04 -04:00
//Stop();
2021-10-04 12:29:10 -04:00
break ;
2023-09-15 11:24:43 -04:00
case 57 : // Space - Sauter
2021-10-01 10:52:33 -04:00
if ( ! m_keySpace ) {
m_keySpace = true ;
}
break ;
2023-10-16 16:35:26 -04:00
case 94 : // F10 - Plein <20> cran
2023-09-16 21:38:58 -04:00
IsFullscreen ( ) ? SetFullscreen ( false ) : SetFullscreen ( true ) ;
//SetFullscreen(!IsFullscreen());
2023-09-15 11:24:43 -04:00
break ;
2023-09-15 20:28:20 -04:00
case 2 : // C - Ignorer
break ;
2021-12-07 18:59:50 -05:00
case 5 : // F - Ignorer
2023-09-15 11:24:43 -04:00
break ;
2023-10-02 15:55:45 -04:00
case 10 : // K - Debugging DisplayNotification()
m_keyK = true ;
2023-10-18 09:33:56 -04:00
m_messageNotification = " notifications systeme peuvent etre affichees " ;
2023-10-02 15:55:45 -04:00
break ;
case 11 : // L - Debugging DisplayNotification()
m_keyL = true ;
break ;
2023-09-23 17:15:35 -04:00
case 6 : // G - Ignorer
break ;
2021-10-19 10:27:59 -04:00
case 12 : // M - Ignorer
2023-09-15 11:24:43 -04:00
break ;
case 7 : // H - Ignorer
break ;
case 8 : // I - Ignorer
break ;
2023-10-23 15:43:55 -04:00
case 9 : // J - InstantDamage
m_damage = true ;
2023-10-16 12:02:37 -04:00
case 15 : // P - Ignorer
break ;
2021-11-26 11:59:02 -05:00
case 17 : // R - Ignorer
2021-09-27 10:20:58 -04:00
break ;
2023-09-23 17:15:35 -04:00
case 19 : // T - Ignorer
2023-10-23 16:11:35 -04:00
break ;
2023-09-15 11:24:43 -04:00
case 24 : // Y - Ignorer
break ;
case 255 : // Fn - Ignorer
break ;
2021-09-27 10:20:58 -04:00
default :
std : : cout < < " Unhandled key: " < < ( int ) key < < std : : endl ;
}
2021-09-24 10:15:43 -04:00
}
2021-12-02 18:12:35 -05:00
void Engine : : KeyReleaseEvent ( unsigned char key ) {
2021-10-11 11:37:58 -04:00
switch ( key ) {
2023-09-15 11:24:43 -04:00
case 0 : // A - Stop gauche
m_keyA = false ;
break ;
2023-09-15 20:28:20 -04:00
case 2 : // C - Toggle crosshair
m_displayCrosshair = ! m_displayCrosshair ;
std : : cout < < " DISPLAY CROSSHAIR " < < ( m_displayCrosshair ? " enabled " : " disabled " ) < < std : : endl ;
break ;
2023-09-15 11:24:43 -04:00
case 3 : // D - Stop droite
m_keyD = false ;
break ;
case 5 : // F - Toggle flash
2021-12-07 18:59:50 -05:00
m_flash = ! m_flash ;
break ;
2023-09-23 17:15:35 -04:00
case 6 : // G - Toggle Stop Countdown
m_stopcountdown = ! m_stopcountdown ;
std : : cout < < " STOP COUNTDOWN " < < ( m_stopcountdown ? " enabled " : " disabled " ) < < std : : endl ;
break ;
2023-09-15 11:24:43 -04:00
case 7 : // H - Toggle HUD
m_displayHud = ! m_displayHud ;
std : : cout < < " DISPLAY HUD " < < ( m_displayHud ? " enabled " : " disabled " ) < < std : : endl ;
break ;
case 8 : // I - Toggle render data
2023-09-15 20:28:20 -04:00
m_displayInfo = ! m_displayInfo ;
std : : cout < < " DISPLAY INFO " < < ( m_displayInfo ? " enabled " : " disabled " ) < < std : : endl ;
2023-09-15 11:24:43 -04:00
break ;
2023-10-02 15:55:45 -04:00
case 10 : // K
m_keyK = false ;
break ;
case 11 : // L - Debugging DisplayNotification()
m_keyL = false ;
break ;
2023-09-15 11:24:43 -04:00
case 12 : // M - Toggle music
2021-10-25 10:50:08 -04:00
m_audio . ToggleMusicState ( ) ;
2021-10-19 10:27:59 -04:00
break ;
2023-10-16 12:02:37 -04:00
case 15 :
for ( int x = 0 ; x < MAX_BULLETS ; + + x ) // Ajouter une balle dans l'array (aussi connu sous le nom de "faire pow pow").
if ( ! m_bullets [ x ] ) {
2023-10-30 15:36:43 -04:00
m_bullets [ x ] = new Bullet ( m_player . GetPOV ( ) - Vector3f ( 1.f , 0.f , 1.f ) , Vector3f ( 1.f , 0.f , 1.f ) ) ;
2023-10-16 12:02:37 -04:00
break ;
}
2023-10-16 17:43:32 -04:00
else if ( x = = MAX_BULLETS - 1 ) { // S'il y a pas d'espace dans l'array, prendre la place de la premi<6D> re balle de l'array.
2023-10-16 12:02:37 -04:00
m_bullets [ 0 ] - > ~ Bullet ( ) ;
m_bullets [ 0 ] = new Bullet ( m_player . GetPOV ( ) - Vector3f ( 1.f , 0.f , 1.f ) , Vector3f ( 1.f , 0.f , 1.f ) ) ;
}
break ;
2023-09-15 11:24:43 -04:00
case 17 : // R - Toggle skybox
2021-12-01 21:21:45 -05:00
m_isSkybox = ! m_isSkybox ;
2021-11-26 11:59:02 -05:00
break ;
2023-09-15 11:24:43 -04:00
case 18 : // S - Stop reculer
m_keyS = false ;
break ;
2023-09-23 17:15:35 -04:00
case 19 : // T -Reset countdown
m_resetcountdown = true ;
std : : cout < < " RESET COUNTDOWN " < < std : : endl ;
break ;
2023-09-15 11:24:43 -04:00
case 22 : // W - Stop avancer
m_keyW = false ;
break ;
case 24 : // Y - Wireframe
2021-09-27 10:20:58 -04:00
m_wireframe = ! m_wireframe ;
if ( m_wireframe )
glPolygonMode ( GL_FRONT_AND_BACK , GL_LINE ) ;
else
glPolygonMode ( GL_FRONT_AND_BACK , GL_FILL ) ;
break ;
2023-09-15 11:24:43 -04:00
case 57 : // Espace - Stop sauter
2021-10-01 10:52:33 -04:00
m_keySpace = false ;
break ;
2021-09-27 10:20:58 -04:00
}
2021-09-24 10:15:43 -04:00
}
2021-12-02 18:12:35 -05:00
void Engine : : MouseMoveEvent ( int x , int y ) {
2021-10-04 12:29:10 -04:00
m_player . TurnLeftRight ( x - ( Width ( ) / 2 ) ) ;
m_player . TurnTopBottom ( y - ( Height ( ) / 2 ) ) ;
2021-09-27 13:15:57 -04:00
2023-10-16 16:35:26 -04:00
// Centrer la souris seulement si elle n'est pas d<> j<EFBFBD> centr<74> e
// Il est n<> cessaire de faire la v<> rification pour <20> viter de tomber
// dans une boucle infinie o<> l'appel <20> CenterMouse g<> n<EFBFBD> re un
2021-09-27 10:20:58 -04:00
// MouseMoveEvent, qui rapelle CenterMouse qui rapelle un autre
// MouseMoveEvent, etc
if ( x = = ( Width ( ) / 2 ) & & y = = ( Height ( ) / 2 ) )
return ;
2021-09-24 10:15:43 -04:00
}
2021-11-26 11:59:02 -05:00
void Engine : : MousePressEvent ( const MOUSE_BUTTON & button , int x , int y ) {
2023-10-02 17:09:03 -04:00
m_mousemx = x ;
m_mousemy = y ;
if ( m_gamestate = = GameState : : PLAY )
{
switch ( button ) {
case MOUSE_BUTTON_LEFT :
m_mouseL = true ;
break ;
case MOUSE_BUTTON_RIGHT :
m_mouseR = true ;
break ;
case MOUSE_BUTTON_MIDDLE :
m_mouseC = true ;
break ;
case MOUSE_BUTTON_WHEEL_UP :
m_mouseWU = true ;
break ;
case MOUSE_BUTTON_WHEEL_DOWN :
m_mouseWD = true ;
break ;
case MOUSE_BUTTON_NONE : break ;
}
}
else if ( m_gamestate = = GameState : : MAIN_MENU )
{
if ( ( m_mousemx > = 285 & & m_mousemx < = 490 ) & & ( m_mousemy > = 150 & & m_mousemy < = 250 ) )
m_gamestate = GameState : : PLAY ;
if ( ( m_mousemx > = 305 & & m_mousemx < = 450 ) & & ( m_mousemy > = 300 & & m_mousemy < = 400 ) )
m_gamestate = GameState : : QUIT ;
2021-11-26 11:59:02 -05:00
}
2023-10-29 15:39:29 -04:00
else if ( m_gamestate = = GameState : : OPTIONS )
{
2023-10-31 11:11:14 -04:00
float buttonWidthProportion = 0.4f ;
float buttonHeightProportion = 0.075f ;
float buttonWidth = buttonWidthProportion * Width ( ) ;
float buttonHeight = buttonHeightProportion * Height ( ) ;
float offsetSingleButtonXFactor = 0.075f ;
float offsetSingleButtonYFactor = 0.05f ;
float buttonPosX = m_titleX ;
float buttonSinglePosY = m_titleY - buttonHeight - ( offsetSingleButtonYFactor * Height ( ) ) ;
float buttonMultiPosY = buttonSinglePosY * 0.75 ;
float adjustedMouseY = Height ( ) - m_mousemy ;
// Single Player
if ( m_mousemx > = buttonPosX & & m_mousemx < = ( buttonPosX + buttonWidth ) & &
adjustedMouseY > = buttonSinglePosY & & adjustedMouseY < = ( buttonSinglePosY + buttonHeight ) )
{
std : : cout < < " Single Player button clicked " < < std : : endl ;
2023-10-29 15:39:29 -04:00
m_soloMultiChoiceMade = true ;
m_gamestate = GameState : : PLAY ;
}
2023-10-31 11:11:14 -04:00
// Multiplayer
else if ( m_mousemx > = buttonPosX & & m_mousemx < = ( buttonPosX + buttonWidth ) & &
adjustedMouseY > = buttonMultiPosY & & adjustedMouseY < = ( buttonMultiPosY + buttonHeight ) )
{
std : : cout < < " Multiplayer button clicked " < < std : : endl ;
2023-10-29 15:39:29 -04:00
m_soloMultiChoiceMade = true ;
m_gamestate = GameState : : PLAY ;
}
}
2021-09-24 10:15:43 -04:00
}
2021-11-26 11:59:02 -05:00
void Engine : : MouseReleaseEvent ( const MOUSE_BUTTON & button , int x , int y ) {
switch ( button ) {
case MOUSE_BUTTON_LEFT :
m_mouseL = false ;
2021-11-27 13:35:39 -05:00
m_block = false ;
2021-11-26 11:59:02 -05:00
break ;
case MOUSE_BUTTON_RIGHT :
m_mouseR = false ;
2021-11-27 13:35:39 -05:00
m_block = false ;
2021-11-26 11:59:02 -05:00
break ;
case MOUSE_BUTTON_MIDDLE :
m_mouseC = false ;
break ;
case MOUSE_BUTTON_WHEEL_UP :
m_mouseWU = false ;
break ;
case MOUSE_BUTTON_WHEEL_DOWN :
m_mouseWD = false ;
break ;
case MOUSE_BUTTON_NONE : break ;
}
2021-09-24 10:15:43 -04:00
}
2023-09-16 00:12:14 -04:00
bool Engine : : LoadTexture ( Texture & texture , const std : : string & filename , bool useMipmaps , bool stopOnError ) {
texture . Load ( filename , useMipmaps ) ;
2023-09-15 11:24:43 -04:00
if ( ! texture . IsValid ( ) ) {
2021-09-27 10:20:58 -04:00
std : : cerr < < " Unable to load texture ( " < < filename < < " ) " < < std : : endl ;
if ( stopOnError )
Stop ( ) ;
2021-09-24 10:15:43 -04:00
2021-09-27 10:20:58 -04:00
return false ;
}
2021-09-24 10:15:43 -04:00
2021-09-27 10:20:58 -04:00
return true ;
2021-09-24 10:15:43 -04:00
}