Browse Source

First commit

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

154
BoatControl.cpp

@ -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
BoatControl.hpp

@ -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
BoatControlPerso.cpp
File diff suppressed because it is too large
View File

19
BoatControlPerso.hpp

@ -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
BoatControlPirate.cpp

@ -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
BoatControlPirate.hpp

@ -0,0 +1,19 @@
#ifndef COMMANDEBATEAUPIRATE
#define COMMANDEBATEAUPIRATE
class BoatControlPirate: public BoatControl
{
public:
void Start();
void Update();
void Fire( float angle);
};
#endif // COMMANDEBATEAUPIRATE

115
EngineGUI.cpp

@ -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
EngineGUI.hpp

@ -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
Marine.cpp
File diff suppressed because it is too large
View File

Loading…
Cancel
Save