First commit

master
Fife 7 years ago
parent ddf08aae21
commit d081178bd2

@ -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());
}
}

@ -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

File diff suppressed because one or more lines are too long

@ -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

@ -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;
}
}
}

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

@ -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;
}

@ -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

File diff suppressed because one or more lines are too long
Loading…
Cancel
Save