Browse Source

First commit

master
Fife 3 years ago
parent
commit
d081178bd2
9 changed files with 1326 additions and 0 deletions
  1. 154
    0
      BoatControl.cpp
  2. 74
    0
      BoatControl.hpp
  3. 184
    0
      BoatControlPerso.cpp
  4. 19
    0
      BoatControlPerso.hpp
  5. 165
    0
      BoatControlPirate.cpp
  6. 19
    0
      BoatControlPirate.hpp
  7. 115
    0
      EngineGUI.cpp
  8. 20
    0
      EngineGUI.hpp
  9. 576
    0
      Marine.cpp

+ 154
- 0
BoatControl.cpp View File

@@ -0,0 +1,154 @@
#include "..\C-Engine\CHeader.hpp"

#include"BoatControl.hpp"

extern "C"
{
#include <math.h>
}


void BoatControl::StartBoat()
{
direction = 180; // Direction des bateaux au départ
}

void BoatControl::UpdateBoat()
{
if(BateauActuelle->VoilesLateralle.Pourcentage < 0)BateauActuelle->VoilesLateralle.Pourcentage = 0; // Pourcentage des voiles
if(BateauActuelle->VoilesLateralle.Pourcentage > 100)BateauActuelle->VoilesLateralle.Pourcentage = 100;

if(BateauActuelle->VoilesLongitudinal.Pourcentage < 0)BateauActuelle->VoilesLongitudinal.Pourcentage = 0;
if(BateauActuelle->VoilesLongitudinal.Pourcentage > 100)BateauActuelle->VoilesLongitudinal.Pourcentage = 100;

if(BateauActuelle->CanonDroit.couldown > 0)BateauActuelle->CanonDroit.couldown = BateauActuelle->CanonDroit.couldown - 4; // Diminution du couldown pour les canons.
if(BateauActuelle->CanonGauche.couldown > 0)BateauActuelle->CanonGauche.couldown = BateauActuelle->CanonGauche.couldown - 4;

float anglelong , anglelat;
float priseventlong;
float priseventlat;
float forceventapplique , forceapplique;
float forceappliquex , forceappliquey;

GetObject()->ORender->SetDirection(direction - 90); //Set de la direction pour l'affichage

anglelong = direction + 135; if(anglelong < 0)anglelong += 360; if(anglelong > 360) anglelong -= 360; // Calcul de l'angle des voiles.
anglelat = direction + 90; if(anglelat < 0)anglelat += 360; if(anglelat > 360) anglelat -= 360;

priseventlat = sin( degretorad( anglelat - VentActuelle->direction ) ) * BateauActuelle->VoilesLateralle.Pourcentage / 100;// Entre 0 et 1 // Pourcentage de la prise au vent des voiles.
priseventlong = sin( degretorad( anglelong - VentActuelle->direction ) * BateauActuelle->VoilesLongitudinal.Pourcentage / 100);// Entre -1 et 1

if(priseventlat < 0)priseventlat = 0;

forceventapplique = (( ABS(priseventlat) * VentActuelle->force ) + (ABS(priseventlong * VentActuelle->force)) ); // Force que le vent applique sur le bateau.
forceapplique = cos(degretorad(direction - VentActuelle->direction)) * forceventapplique * 10;

if(forceapplique < 0)forceapplique = 0;

forceappliquex = cos(degretorad(direction)) * forceapplique; // Passage de forme polaire à carthésienne.
forceappliquey = sin(degretorad(direction)) * forceapplique;

if(forceappliquex > -10 && forceappliquex < 0)forceappliquex = -10; // On cap les forces
if(forceappliquey > -10 && forceappliquey < 0)forceappliquey = -10;

if(forceappliquex > 20)forceappliquex = 20;
if(forceappliquey > 20)forceappliquey = 20;

GetObject()->ORigibody->R_body.velocity.x = forceappliquex; // On applique les forces.
GetObject()->ORigibody->R_body.velocity.y = forceappliquey;

}


void BoatControl::Initialisation( Vent * v , Boat * b , Animation * r)
{
this->VentActuelle = v; // On initialise les différens pointeurs.
this->BateauActuelle = b;
this->RenderBoulet = r;
}


void BoatControl::Turn(float v)
{
direction += v; // On fait tourner le bateau.

if(direction < 0)direction += 360;
if(direction > 360) direction -= 360;
}


void BoatControl::Fire( float angle)
{
if(angle == 90) // Tire du canon droit
{
if(BateauActuelle->CanonDroit.couldown <= 0)
{
float angletire;

angletire = direction - angle; // Angle de tire

Object * Buffer = new Object; // Création du boulet

Buffer->OTransforms->SetXY( GetX() + 8 , GetY() + 8); //On place le boulet sur la map
Buffer->ORender->SetRender(RenderBoulet , 1); //On set le rendu du boulet
Buffer->ORigibody = new Rigibody(Buffer); // On donne un Rigibody
Buffer->ORigibody->SetMass(5); //On dit qu'il pèse 5 kilo

Buffer->AffectTag("Boulet");

SBoulet * Script_Boulet = new SBoulet; // On créait le script du boulet
Buffer->AffectScript(Script_Boulet);

Script_Boulet->time = 20;

Buffer->ORigibody->R_body.velocity.x = cos(degretorad(angletire)) * 40; //On calcul la trajectoire du boule puis on set sa vitesse.
Buffer->ORigibody->R_body.velocity.y = sin(degretorad(angletire)) * 40;

GetEngine()->AddObject(Buffer); // On ajoute le boulet au jeu

BateauActuelle->CanonDroit.couldown = 100; // On place le compteur à 100.
}
}

if(angle == -90) // Tire du canon gauche
{
if(BateauActuelle->CanonGauche.couldown <= 0)
{
float angletire;

angletire = direction - angle;

Object * Buffer = new Object;

Buffer->OTransforms->SetXY( GetX() + 8 , GetY() + 8);
Buffer->ORender->SetRender(RenderBoulet , 1);
Buffer->ORigibody = new Rigibody(Buffer);
Buffer->ORigibody->SetMass(5);

Buffer->AffectTag("Boulet");

SBoulet * Script_Boulet = new SBoulet;
Buffer->AffectScript(Script_Boulet);

Script_Boulet->time = 20;

Buffer->ORigibody->R_body.velocity.x = cos(degretorad(angletire)) * 40;
Buffer->ORigibody->R_body.velocity.y = sin(degretorad(angletire)) * 40;

GetEngine()->AddObject(Buffer);

BateauActuelle->CanonGauche.couldown = 100;
}
}

}


void SBoulet::Update()
{
time--; //On diminue sa durée de vie
if(time < 0) //Si la durée de vie est écoulé alors on le détruit.
{
GetEngine()->DelObject(GetObject());
}
}

+ 74
- 0
BoatControl.hpp View File

@@ -0,0 +1,74 @@
#ifndef COMMANDEBATEAU
#define COMMANDEBATEAU

double degretorad(float v);

struct Vent;
struct Boat;

//**************Les Scripts***************//

class BoatControl: public Script
{
public:

void StartBoat(); //Fonctions des scripts de base
void UpdateBoat();

void Initialisation( Vent * v , Boat * b , Animation * r);//Pour initialiser les pointeursS

void Turn( float v); //Pour tourner
void Fire( float angle); //Pour tirer.

float direction; // Direction du bateau

Animation * RenderBoulet;

Boat * BateauActuelle;
Vent * VentActuelle;
};

class SBoulet: public Script
{
public:

void Update();

int time;//Durée de vie du boulet
};


//*************Les Structures*************//

struct Voile
{
int Pourcentage;
int taille;
};

struct Canon
{
int couldown;
};

struct Boat
{
int Grade;
int masse;
int vie;
int viemax;
Voile VoilesLateralle;
Voile VoilesLongitudinal;
Canon CanonDroit;
Canon CanonGauche;
};

struct Vent
{
float direction;
float force; // en m.s
};


#endif // COMMANDEBATEAU


+ 184
- 0
BoatControlPerso.cpp
File diff suppressed because it is too large
View File


+ 19
- 0
BoatControlPerso.hpp View File

@@ -0,0 +1,19 @@

#ifndef COMMANDEBATEAUPERSO
#define COMMANDEBATEAUPERSO

class BoatControlPerso: public BoatControl
{
public:

void Start();
void Update();

int CheckBoat();

void AfficherMap();

int objectifmax;
};

#endif // COMMANDEBATEAUPERSO

+ 165
- 0
BoatControlPirate.cpp View File

@@ -0,0 +1,165 @@
#include "..\C-Engine\CHeader.hpp"
#include"BoatControl.hpp"
#include "BoatControlPirate.hpp"

extern "C"
{
#include <math.h>
}


void BoatControlPirate::Start()
{
StartBoat();

GetObject()->ORigibody = new Rigibody(GetObject());

GetObject()->AffectTag("Pirate"); //On écrit que c'est un pirate
GetObject()->ORigibody->SetMass(500);

BateauActuelle->VoilesLongitudinal.Pourcentage = 0;//On met ces voiles à 0
BateauActuelle->VoilesLateralle.Pourcentage = 0;

BateauActuelle->viemax = 3;//Les pirates ont 3 de vies.
BateauActuelle->vie = BateauActuelle->viemax ;

BateauActuelle->CanonDroit.couldown = 0;
BateauActuelle->CanonGauche.couldown = 0;
}


void BoatControlPirate::Update()
{
UpdateBoat();

int difx , dify ;
int distance;
float angle , difangle;

difx = GetX() - GetEngine()->ListeObject[0]->OTransforms->GetX();
dify = GetY() - GetEngine()->ListeObject[0]->OTransforms->GetY();

distance = sqrt( difx * difx + dify * dify); //On calcul la distance entre le joueur et le bateau pirate.

angle = 360 - 90 - radtodegre(atan2( difx , dify));

if(angle > 360) angle -= 360;
if(angle < 0) angle += 360;

difangle = angle - direction;

if(distance < 50 || distance > 350)
{
difangle = angle - direction + 90;

BateauActuelle->VoilesLateralle.Pourcentage = BateauActuelle->VoilesLateralle.Pourcentage - 3;
BateauActuelle->VoilesLongitudinal.Pourcentage = BateauActuelle->VoilesLongitudinal.Pourcentage - 3;
}
else
{
if(BateauActuelle->VoilesLateralle.Pourcentage < 70)BateauActuelle->VoilesLateralle.Pourcentage = BateauActuelle->VoilesLateralle.Pourcentage + 2;
if(BateauActuelle->VoilesLateralle.Pourcentage < 70)BateauActuelle->VoilesLongitudinal.Pourcentage = BateauActuelle->VoilesLongitudinal.Pourcentage + 2;
}

if(difangle > 360) difangle -= 360;
if(difangle < 0) difangle += 360;

if(difangle < 180 && difangle > 2)Turn(2);//On aligne le bateau dans la bonne direction
if(difangle > 180 && difangle < 358) Turn(-2);

if(distance < 50)
{
Fire(90);
Fire(-90);

}

int affichage = BateauActuelle->vie * 15 / BateauActuelle->viemax;//On affiche la vie du pirate à sa gauche.
PrintMini( GetObject()->OTransforms->GetRelativeX() + 18 , 63 - GetObject()->OTransforms->GetRelativeY() - 10 , "P" , 0);
ML_line( GetObject()->OTransforms->GetRelativeX() - 2 , 62 - GetObject()->OTransforms->GetRelativeY() , GetObject()->OTransforms->GetRelativeX() - 2 , 62 - GetObject()->OTransforms->GetRelativeY() - affichage, ML_BLACK);


Object * Buffer = NULL;

Buffer = GetObject()->CollisionTagO("Boulet");

if(Buffer != NULL)//Si il est touché par un boulet de canon il perd une vie.
{
GetEngine()->DelObject(Buffer);

BateauActuelle->vie --;
}

if( BateauActuelle->vie <= 0)//Si il n'a plus de vie il meurt.
{
GetEngine()->DelObject(GetObject());
}


}


void BoatControlPirate::Fire( float angle)//Pareil que pour le BoatControl , seul le tag change.
{
if(angle == 90)
{
if(BateauActuelle->CanonDroit.couldown <= 0)
{
float angletire;

angletire = direction - angle;

Object * Buffer = new Object;

Buffer->OTransforms->SetXY( GetX() + 8 , GetY() + 8);
Buffer->ORender->SetRender(RenderBoulet , 1);
Buffer->ORigibody = new Rigibody(Buffer);
Buffer->ORigibody->SetMass(5);

Buffer->AffectTag("BouletP");

SBoulet * Script_Boulet = new SBoulet;
Buffer->AffectScript(Script_Boulet);

Script_Boulet->time = 20;

Buffer->ORigibody->R_body.velocity.x = cos(degretorad(angletire)) * 40;
Buffer->ORigibody->R_body.velocity.y = sin(degretorad(angletire)) * 40;

GetEngine()->AddObject(Buffer);

BateauActuelle->CanonDroit.couldown = 100;
}
}

if(angle == -90)
{
if(BateauActuelle->CanonGauche.couldown <= 0)
{
float angletire;

angletire = direction - angle;

Object * Buffer = new Object;

Buffer->OTransforms->SetXY( GetX() + 8 , GetY() + 8);
Buffer->ORender->SetRender(RenderBoulet , 1);
Buffer->ORigibody = new Rigibody(Buffer);
Buffer->ORigibody->SetMass(5);

Buffer->AffectTag("BouletP");

SBoulet * Script_Boulet = new SBoulet;
Buffer->AffectScript(Script_Boulet);

Script_Boulet->time = 20;

Buffer->ORigibody->R_body.velocity.x = cos(degretorad(angletire)) * 40;
Buffer->ORigibody->R_body.velocity.y = sin(degretorad(angletire)) * 40;

GetEngine()->AddObject(Buffer);

BateauActuelle->CanonGauche.couldown = 100;
}
}
}

+ 19
- 0
BoatControlPirate.hpp View File

@@ -0,0 +1,19 @@
#ifndef COMMANDEBATEAUPIRATE
#define COMMANDEBATEAUPIRATE

class BoatControlPirate: public BoatControl
{
public:

void Start();
void Update();
void Fire( float angle);

};


#endif // COMMANDEBATEAUPIRATE





+ 115
- 0
EngineGUI.cpp View File

@@ -0,0 +1,115 @@
#include "..\C-Engine\CHeader.hpp"

#include"BoatControl.hpp"
#include"EngineGUI.hpp"

extern "C"
{
#include <math.h>
}



void EngineGUI::UpdateEverySecond()
{
VentActuelle->direction = VentActuelle->direction + cos(rand()) * 30;
VentActuelle->force = VentActuelle->force + cos(rand());

if(VentActuelle->direction < 0)VentActuelle->direction += 360;
if(VentActuelle->direction > 360) VentActuelle->direction -= 360;

if(VentActuelle->force > 5) VentActuelle->force = 5;
if(VentActuelle->force < 1) VentActuelle->force = 1;
}

void EngineGUI::Update()
{
float buffer;

const unsigned char Bordure[]={0x40,0x0,0x10,0x80,0x0,0x8,0x80,0x0,0x8,0x80,0x0,0x8,0x80,0x0,0x8,0x80,0x0,0x8,0x80,0x0,0x8,0x80,0x0,0x8,0x80,0x0,0x8,0x80,0x0,0x8,0x80,0x0,0x8,0x80,0x0,0x8,0x80,0x0,0x8,0x80,0x0,0x8,0x80,0x0,0x8,0x80,0x0,0x18,0x7f,0xff,0xe8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x8,0x0,0x0,0x10};

ML_bmp_or(Bordure , 84 , 0, 21 , 64);
ML_rectangle(105 , 0 , 127 , 63 , 1 , ML_WHITE , ML_WHITE);

//************Vent****************//

PrintMini(108 , 1 , "Vent" , 0);

PrintV( 120 , 7 ,VentActuelle->force);

buffer = VentActuelle->direction;

const unsigned char FlecheE[]={0x20,0x10,0xf8,0x10,0x20};
const unsigned char FlecheN[]={0x20,0x70,0xa8,0x20,0x20};
const unsigned char FlecheNE[]={0x78,0x18,0x28,0x48,0x80};
const unsigned char FlecheNO[]={0xf0,0xc0,0xa0,0x90,0x8};
const unsigned char FlecheO[]={0x20,0x40,0xf8,0x40,0x20};
const unsigned char FlecheS[]={0x20,0x20,0xa8,0x70,0x20};
const unsigned char FlecheSE[]={0x80,0x48,0x28,0x18,0x78};
const unsigned char FlecheSO[]={0x8,0x90,0xa0,0xc0,0xf0};

if((buffer >= 0 && buffer < 22)|| (buffer >= 337 && buffer < 360))ML_bmp_or(FlecheE ,109 , 7, 5 , 5);
else if(buffer >= 22 && buffer < 67)ML_bmp_or(FlecheNE ,109 , 7, 5 , 5);
else if(buffer >= 67 && buffer < 112)ML_bmp_or(FlecheN ,109 , 7, 5 , 5);
else if(buffer >= 112 && buffer < 157)ML_bmp_or(FlecheNO ,109 , 7, 5 , 5);
else if(buffer >= 157 && buffer < 202)ML_bmp_or(FlecheO ,109 , 7, 5 , 5);
else if(buffer >= 202 && buffer < 247)ML_bmp_or(FlecheSO ,109 , 7, 5 , 5);
else if(buffer >= 247 && buffer < 292)ML_bmp_or(FlecheS ,109 , 7, 5 , 5);
else if(buffer >= 292 && buffer < 337)ML_bmp_or(FlecheSE ,109 , 7, 5 , 5);

//**********************Voile*************//

const unsigned char Voile0[]={0x18,0xff,0x18,0x18,0x18,0x18,0x18,0x18};
const unsigned char Voile25[]={0x18,0xff,0x81,0xff,0x18,0x18,0x18,0x18};
const unsigned char Voile50[]={0x18,0xff,0x81,0x81,0xff,0x18,0x18,0x18};
const unsigned char Voile75[]={0x18,0xff,0x81,0x81,0x81,0xff,0x18,0x18};
const unsigned char Voile100[]={0x18,0xff,0x81,0x81,0x81,0x81,0xff,0x18};

const unsigned char* SpriteVoile[] = {Voile0,Voile25,Voile50,Voile75,Voile100};
PrintMini(108 , 15 , "Voiles" , 0);

int buffer2 = BateauActuelle->VoilesLateralle.Pourcentage;
int buffer2b = BateauActuelle->VoilesLongitudinal.Pourcentage;

if( buffer2 < 12 )ML_bmp_8_or(SpriteVoile[0] ,108 , 21);
else if(buffer2 >= 12 && buffer2 < 37 )ML_bmp_8_or(SpriteVoile[1] ,108 , 21);
else if(buffer2 >= 37 && buffer2 < 62 )ML_bmp_8_or(SpriteVoile[2] ,108 , 21);
else if(buffer2 >= 62 && buffer2 < 87 )ML_bmp_8_or(SpriteVoile[3] ,108 , 21);
else if(buffer2 >= 87)ML_bmp_8_or(SpriteVoile[4] ,108 , 21);

if( buffer2b < 12 )ML_bmp_8_or(SpriteVoile[0] ,118 , 21);
else if(buffer2b >= 12 && buffer2b < 37 )ML_bmp_8_or(SpriteVoile[1] ,118 , 21);
else if(buffer2b >= 37 && buffer2b < 62 )ML_bmp_8_or(SpriteVoile[2] ,118 , 21);
else if(buffer2b >= 62 && buffer2b < 87 )ML_bmp_8_or(SpriteVoile[3] ,118 , 21);
else if(buffer2b >= 87)ML_bmp_8_or(SpriteVoile[4] ,118 , 21);

//*****************Canons************//

int buffer3, buffer4;

PrintMini(106 , 31 , "Canon" , 0);

buffer3 = 17 - BateauActuelle->CanonDroit.couldown * 17 / 100;
buffer4 = 17 - BateauActuelle->CanonGauche.couldown * 17 / 100;

int affichage = BateauActuelle->vie * 17 / BateauActuelle->viemax;

ML_rectangle(108 , 38 , 125 , 40 , 1 , ML_BLACK , ML_WHITE);
ML_line( 108 , 39 , 108 + buffer3 , 39 , ML_BLACK);

ML_rectangle(108 , 43 , 125 , 45 , 1 , ML_BLACK , ML_WHITE);
ML_line( 108 , 44 , 108 + buffer4 , 44 , ML_BLACK);

//*******************Vie******************//

PrintMini(108 , 50 , "Vie" , 0);

ML_rectangle(108 , 57 , 125 , 59 , 1 , ML_BLACK , ML_WHITE);
ML_line( 108 , 58 , 108 + affichage , 58 , ML_BLACK);
}

void EngineGUI::Initialisation( Vent * v , Boat * b )
{
this->VentActuelle = v;
this->BateauActuelle = b;
}

+ 20
- 0
EngineGUI.hpp View File

@@ -0,0 +1,20 @@

#ifndef GUI
#define GUI

#include"BoatControl.hpp"

class EngineGUI: public Script
{
public:

void Update();//On affiche les différentes données du jeu
void UpdateEverySecond();//On actuallise la météo.

void Initialisation( Vent * v , Boat * b);

Boat * BateauActuelle;
Vent * VentActuelle;
};

#endif //GUI

+ 576
- 0
Marine.cpp
File diff suppressed because it is too large
View File


Loading…
Cancel
Save