Commit 0bf220c3 authored by Arnaud Billon's avatar Arnaud Billon
Browse files

added

parents
#Old Gamejams code
the code of the old gamejams
smallworld = planete
a dragon's freedom = le dragon qui bouffe des lotus
\ No newline at end of file
#include <SDL2/SDL.h>
#include <stdio.h>
int main(int argc, char** argv)
{
/* Initialisation simple */
if (SDL_Init(SDL_INIT_VIDEO) != 0 )
{
fprintf(stdout,"chec de l'initialisation de la SDL (%s)\n",SDL_GetError());
return -1;
}
{
/* Cration de la fentre */
SDL_Window* pWindow = NULL;
pWindow = SDL_CreateWindow("Ma premire application SDL2",SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
640,
480,
SDL_WINDOW_SHOWN);
if( pWindow )
{
SDL_Delay(3000); /* Attendre trois secondes, que l'utilisateur voie la fentre */
SDL_DestroyWindow(pWindow);
}
else
{
fprintf(stderr,"Erreur de cration de la fentre: %s\n",SDL_GetError());
}
}
SDL_Quit();
return 0;
}
#include "Asteroid.h"
Asteroid::Asteroid(float x, float y, float masse, float rayon, Vecteur v0, Vecteur a0, int vie, unsigned int indiceDrop) : Corps(x, y, masse, rayon, 1, v0, a0)
{
//JERRY ICI c pas idrop cest drop = valeur
m_drop = m_gains[indiceDrop];
if (indiceDrop==1) {
m_typeCorps = IM_ASTEROIDEGAIN1;
} else if (indiceDrop==2) {
m_typeCorps = IM_ASTEROIDEGAIN2;
} else if (indiceDrop==3) {
m_typeCorps = IM_ASTEROIDEGAIN3;
}
m_vie = vie;
m_indiceDrop = indiceDrop;
}
unsigned int Asteroid::getDrop(){
return m_drop;
}
unsigned int Asteroid::getIndiceDrop() {
return m_indiceDrop;
}
//Detecte la collision avec la planete
bool Asteroid::detecteCollisionPlanete(Planete planete) {
bool collide = false;
bool toucheTrou = false;
//bool pointTrouve = false;
int i = 0;
Vecteur pointPresPlanete = trouvePointProchePlanete(planete);
vector<Cercle> listeTrous = planete.getTrous();
int nbTrous = listeTrous.size();
// On check si on touche le plein de la planete
Vecteur ecart(m_x - planete.getX(), m_y - planete.getY());
if(ecart.norme() < m_rayon + planete.getRayon())
{
//collide = true;
while (!collide && i < nbTrous)
{
Vecteur ecart(m_x - listeTrous[i].getXCentre(), m_y - listeTrous[i].getYCentre());
//collide = false;
if(ecart.norme() < m_rayon + listeTrous[i].getRayon())
{
toucheTrou = true;
float tmp11;
float tmp12;
float tmp21;
float tmp22;
float *x1 = &tmp11;
float *y1 = &tmp12;
float *x2 = &tmp21;
float *y2 = &tmp22;
intersect(x1, y1, x2, y2, m_x, m_y, listeTrous[i].getXCentre(), listeTrous[i].getYCentre(), getRayon(), listeTrous[i].getRayon());
if(x1 != NULL)
{
Vecteur ecart1(*x1 - planete.getX(), *y1 - planete.getY());
Vecteur ecart2(*x2 - planete.getX(), *y2 - planete.getY());
collide = (( ecart1.norme() <= planete.getRayon() &&
!appartientCercles(*x1, *y1, listeTrous, i) ) ||
( ecart2.norme() <= planete.getRayon() &&
!appartientCercles(*x2, *y2, listeTrous, i) ));
}
}
i++;
}
collide = collide ||!toucheTrou;
}
else
{
collide = false;
}
return collide;
}
//On rcupre
void Asteroid::intersect(float *x1, float *y1, float *x2, float *y2, float xc1, float yc1, float xc2, float yc2, float b, float c)
{
float a;
float d;
float A;
float B;
float C;
float D;
if(yc2 != yc1)
{
a = (-pow(xc1, 2) - pow(yc1, 2) + pow(xc2, 2) + pow(yc2, 2) + pow(b, 2) - pow(c, 2))/(2.0 * (yc2 - yc1));
d = (xc2 - xc1)/(yc2 - yc1);
A = (pow(d, 2) + 1);
B = (-2 * xc1 + 2 * yc1 * d - 2 * a * d);
C = pow(xc1, 2) + pow(yc1, 2) - 2 * yc1 * a + pow(a, 2) - pow(b, 2);
D = pow(B, 2) - 4 * A * C;
*x1 = (-B + sqrt(D))/(2 * A);
*y1 = a - *x1 * d;
*x2 = (-B - sqrt(D))/(2 * A);
*y2 = a - *x2 * d;
}
else if (xc2 != xc1)
{
*x1 = (pow(c, 2) - pow(b, 2) - pow(xc2, 2) + pow(xc1, 2))/(2.0 * (xc1 - xc2));
*x2 = *x1;
A = 1;
B = - 2.0 * yc2;
C = pow(xc2, 2) + pow(*x1, 2) - 2.0 * xc2 * *x1 + pow(yc2, 2) - pow(c, 2);
D = pow(B, 2) - 4 * A * C;
*y1 = (-B + sqrt(D))/(2.0 * A);
*y2 = (-B - sqrt(D))/(2.0 * A);
}
else
{
*x1 = NULL;
*y1 = NULL;
*x2 = NULL;
*y2 = NULL;
}
}
// indique si un point appartient a un disque
bool Asteroid::appartientCercles(float x, float y, vector<Cercle> listeCercles, int except) {
bool res = false;
int nbCercles = listeCercles.size();
int i=0;
Vecteur point = Vecteur(x, y);
while (i<nbCercles && !res) {
if (i != except)
{
Vecteur centreCercle = Vecteur(listeCercles[i].getXCentre(), listeCercles[i].getYCentre());
float distance = (centreCercle-point).norme();
if (distance<listeCercles[i].getRayon()) {
res = true;
}
}
i++;
}
return res;
}
// Pour un asteroide, trouve le point a sa surface qui
// est le plus proche du centre de la planete
Vecteur Asteroid::trouvePointProchePlanete(Planete planete){
Vecteur vectDirecteur = calcDirection(planete.getX(), planete.getY())*-1.0;
Vecteur vectDUnitaire = vectDirecteur/vectDirecteur.norme();
Vecteur res = vectDUnitaire * m_rayon;
res += {m_x, m_y};
return res;
}
// Pour un asteroide trouve le point le plus loin du
// centre du trou
Vecteur Asteroid::trouvePointLoinTrou(Cercle trou) {
Vecteur vectDirecteur = calcDirection(trou.getXCentre(), trou.getYCentre())*-1;
Vecteur vectDUnitaire = vectDirecteur/vectDirecteur.norme();
Vecteur res = vectDUnitaire * m_rayon;
res += {m_x, m_y};
return res;
}
// gere la collision avec la planete => faire un trou
void Asteroid::collisionAvecPlanete(Planete *planete){
(*planete).ajouteTrous(m_x, m_y, m_rayon);
}
Cercle Asteroid::cercleGain() {
Cercle res = Cercle(m_x, m_y, 5.0, IMG_PREMIER_NOMBRE+m_indiceDrop);
return res;
}
#ifndef ASTEROID_H
#define ASTEROID_H
#define IMG_PREMIER_NOMBRE 9
#include <vector>
#include <math.h>
#include "Corps.h"
#include "cercle.h"
#include "Planete.h"
#include "Ressources.h"
#include "iostream"
class Asteroid : public Corps
{
public:
Asteroid(float x, float y, float masse, float rayon, Vecteur v0, Vecteur a0,int vie, unsigned int goldDrop);
//void collisionEntreAsteroides(Corps asteroide);
unsigned int getDrop();
unsigned int getIndiceDrop();
void collisionAvecPlanete(Planete* planete);
bool detecteCollisionPlanete(Planete planete);
void intersect(float *x1, float *y1, float *x2, float *y2, float xc1, float yc1, float xc2, float yc2, float R1, float R2);
bool appartientCercles(float x, float y, vector<Cercle> listeCercles, int except);
Vecteur trouvePointProchePlanete(Planete planete);
Vecteur trouvePointLoinTrou(Cercle trou);
Cercle cercleGain();
protected:
private:
int m_vie;
unsigned int m_drop;
unsigned int m_indiceDrop;
};
#endif // ASTEROID_H
#include "BouclierGeant.h"
BouclierGeant::BouclierGeant(int x, int y, int rayon, unsigned int image) : Constructions(x, y, rayon, image) {
m_type = "bouclier";
m_ressource = 20; //??
}
BouclierGeant::~BouclierGeant()
{
//dtor
}
#ifndef BOUCLIERGEANT_H
#define BOUCLIERGEANT_H
#include "Constructions.h"
class BouclierGeant : public Constructions
{
public:
BouclierGeant(int x, int y, int rayon, unsigned int image);
virtual ~BouclierGeant();
protected:
private:
};
#endif // BOUCLIERGEANT_H
#include "Constructions.h"
Constructions::Constructions() : m_x(0), m_y(0)
{
}
Constructions::Constructions(int x, int y, int rayon, unsigned int image) {
m_x = x;
m_y = y;
m_rayon = rayon;
m_image = image;
}
Constructions::~Constructions()
{
//dtor
}
int Constructions::getX() {
return m_x;
}
void Constructions::setX(int x) {
m_x = x;
}
int Constructions::getY() {
return m_y;
}
void Constructions::setY(int y) {
m_y = y;
}
std::string Constructions::getType() {
return m_type;
}
void Constructions::setType(std::string t) {
m_type = t;
}
unsigned int Constructions::getImage() {
return m_image;
}
void Constructions::setImage(int valeur) {
m_image = valeur;
}
unsigned int Constructions::getRessource() {
return m_ressource;
}
void Constructions::setRessource(unsigned int valeur) {
m_ressource = valeur;
}
int Constructions::getRayon() {
return m_rayon;
}
void Constructions::setRayon(int valeur) {
m_rayon = valeur;
}
#ifndef CONSTRUCTIONS_H
#define CONSTRUCTIONS_H
#include <string>
class Constructions {
public:
Constructions();
Constructions(int x, int y, int rayon, unsigned int image);
virtual ~Constructions();
unsigned int getRessource();
void setRessource(unsigned int valeur);
void setImage(int valeur);
unsigned int getImage();
std::string getType();
void setType(std::string t);
int getX();
int getY();
void setX(int x);
void setY(int y);
int getRayon();
void setRayon(int valeur);
protected:
int m_x;
int m_y;
int m_rayon;
std::string m_type;
unsigned int m_image;
unsigned int m_ressource;
};
#endif // CONSTRUCTIONS_H
#include "Corps.h"
using namespace std;
Corps::Corps(float x, float y, float masse, float rayon,unsigned int typeCorps, Vecteur v0, Vecteur a0)
{
//ca chie
m_x = x;
m_y = y;
m_masse = masse;
m_typeCorps = typeCorps;
//m_numSprite = indiceSprite;
m_rayon = rayon;
m_vitesse = v0;
m_acceleration = a0;
for(int i = 0; i<10;i++){
m_gains.push_back(i);
}
}
float Corps::getX() {
return m_x;
}
float Corps::getY(){
return m_y;
}
float Corps::getRayon() {
return m_rayon;
}
unsigned int Corps::getType()
{
return m_typeCorps;
}
bool Corps::detecteCollisionCorps(Corps autre)
{
// On check si on touche le plein de la planete
Vecteur ecart(m_x - autre.getX(), m_y - autre.getY());
return (ecart.norme() < m_rayon + autre.getRayon());
}
float Corps::calcDistance(float x, float y){
Vecteur ecart(m_x-x, m_y-y);
return ecart.norme();
}
// Calcule le vecteur directeur entre les 2 Corps
Vecteur Corps::calcDirection(float x, float y){
Vecteur ecart(m_x - x, m_y - y);
ecart = ecart/ecart.norme();
return ecart;
}
void Corps::gereDeplacement(vector<Corps> listeCorps, float dt){
calcAcceleration(listeCorps);
calcVitesse(dt);
calcPosition(dt);
}
// Applique le PFD pour calculer l'acceleration du Corps
void Corps::calcAcceleration(vector<Corps> listeCorps){
int nbCorps = listeCorps.size();
m_acceleration.m_x = 0;
m_acceleration.m_y = 0;
const float Cx = 0.5; // le coeff de resistance aerodynamique (0.5 pour une sphere)
const float ro = 1.0; // masse volumique de l'air
for (int i = 0; i < nbCorps; i++){
Corps actuel = listeCorps[i];
float distCour = calcDistance(actuel.getX(), actuel.getY());
if(distCour > listeCorps[i].getRayon()) // On vrifie qu'on est pas trop proche de l'objet
{
Vecteur vectDirecteur = calcDirection(actuel.getX(), actuel.getY());
//float S = 3.141592 * pow(getRayon(), 2);
//Vecteur frottement = -0.5*Cx*ro*S*m_vitesse.norme() * m_vitesse;
//Vecteur frottement = -2.0 * m_vitesse.norme() * m_vitesse;
m_acceleration.m_x -= DEFG * m_masse * actuel.m_masse / pow(distCour, 2) * vectDirecteur.m_x;
m_acceleration.m_y -= DEFG * m_masse * actuel.m_masse / pow(distCour, 2) * vectDirecteur.m_y;
m_vitesse = 0.9995 * m_vitesse;
}
}
}
// Calcule la vitesse du Corps en connaissant sa vitesse actuelle et son acceleration
// dt = intervalle entre 2 maj de la vitesse
void Corps::calcVitesse(float dt){
m_vitesse += m_acceleration * dt;
}
void Corps::calcPosition(float dt) {
m_x = m_x + m_vitesse.m_x * dt;
m_y = m_y + m_vitesse.m_y * dt;
}
void Corps::afficher()
{
}
#ifndef Corps_H
#define Corps_H
#include <vector>
#include <math.h>
#include <iostream>
#include "Vecteur.h"
//#include "Personnage.h"
#define DEFG 0.01
using namespace std;
class Corps{
// Attributs
protected:
float m_x;
float m_y;
float m_rayon;
float m_masse;
unsigned int m_typeCorps;
vector<int> m_gains;
Vecteur m_vitesse;
Vecteur m_acceleration;
public:
Corps(float x, float y, float masse, float rayon, unsigned int typeCorps, Vecteur v0, Vecteur a0);
float getX();
float getY();
float getRayon();
unsigned int getType();
bool detecteCollisionCorps(Corps autre);
float calcDistance(float x, float y);
Vecteur calcDirection(float x, float y);
void gereDeplacement(vector<Corps> listeCorps, float dt);