public virtual void move(direction dir) // Move est directement overrideable pour permettre plus de flexibilité (appeller plusieurs fois moveObject à la suite par exemple)
{
Vect2D directionVector;
switch (dir)
{
case direction.up:
directionVector = new Vect2D(0, 1);
break;
case direction.down:
directionVector = new Vect2D(0, -1);
break;
case direction.left:
directionVector = new Vect2D(-1, 0);
break;
case direction.right:
directionVector = new Vect2D(1, 0);
break;
default:
directionVector = new Vect2D(0, 0);
break;
}
this.moveObject(directionVector);
}
//S'occupe de bouger l'objet
protected void mv(Vect2D movement)
{
this.pos.pos += movement; //On déplace tout
this.physics.pos.pos += movement;
this.displayer.pos.pos += movement;
this.gameplay.pos.pos += movement;
}
/// <summary>
/// Cette fonction s'occupe juste de voir si à une position, pour un objet, il y a une potentielle collision (un objet ou les limites du terrain)
/// si c'est un objet, il retourne sa composante physique (et si y'a pas de composante physique il retourne null ( un objet sans compôsante physique est comme un fantome))
/// si c'est une limite du terrain, il crée un objet temporaire qui se comporte comme un mur
/// </summary>
/// <param name="p">L'objet qui veut vérifier si y'a pas de collision</param>
/// <param name="destination">L'endroit ou il veut aller</param>
/// <returns></returns>
public virtual BasePhysics collisionCheck(BasePhysics p, Vect2D destination)
{
//On regarde si on est bien dans les boundaries du niveau
if (destination.x < 0)
{
return(new BasePhysics(-1, destination.y, p.pos.layer));
}
else if (destination.x > this.worldLength)
{
return(new BasePhysics(this.worldLength, destination.y, p.pos.layer));
}
if (destination.y < 0)
{
return(new BasePhysics(destination.x, -1, p.pos.layer));
}
else if (destination.y > this.worldHeight)
{
return(new BasePhysics(destination.x, this.worldHeight, p.pos.layer));
}
WorldObject collided = getCollidedObject(p, destination);
if (collided != null)
{
return(collided.physics);
}
return(null); // pas de collision !
}
public bool checkCollision(Vect2D p)
{
if (p.x >= p1.x && p.x <= p2.x && p.y >= p1.y && p.y <= p2.y)
{
return(true);
}
return(false);
}
/// <summary>
/// Quand il y a une collision, gere la communication entre les deux objets physics
/// </summary>
/// <param name="collided"></param>
/// <param name="movement"></param>
/// <returns></returns>
public Vect2D resolveCollision(BasePhysics collided, Vect2D movement)
{
//verifie si il peut bouger
Vect2D opposedMovement = collided.onCollide(this, movement);
Vect2D newMovement = movement - opposedMovement;
return(newMovement);
}
public virtual Vect2D onCollide(BasePhysics obj, Vect2D hisTrajectory) //Représente la réaction de l'objet quand il subit une collision
{
Vect2D renvoi = (obj.pos.pos - this.pos.pos).normalize(); //Ici, repousse simplement l'objet à la case d'avant (comportement basique d'un mur)
return(renvoi);
//Il serait possible d'être plus fancy, en déplacant les deux objets impliqués par exemple (action, réaction)
//On peut aussi appliquer une réaction inverse
}
//private itemAction iAction;
bool use(GamePosition itemPos, GamePosition strikePos)
{
if (Vect2D.getDistance(itemPos.pos, strikePos.pos) < range)
{
action(itemPos, strikePos);
return(true);
}
return(false);
}
public Vect2D checkTeleportation(Vect2D movement)
{
//Verifie si il peut se tp là. Si il y a quelque chose, la teleportation ne se fait pas
Vect2D newMovement;
newMovement = movement;
BasePhysics collided = this.checkForCollision(this, movement);
if (!collided.onTpCollide(this, movement)) //Est ce que je peux me téléporter dessus?
{
newMovement = new Vect2D(0, 0);
}
return(newMovement);
}
/// <summary>
/// Teleport est un déplacement instantanné, il ne fait pas attention aux objets sur la route. Si il y a un objet à la position ou la téléportation est voulue,
/// la collision est gérée par les objets physics
/// </summary>
/// <param name="movement"></param>
public void teleport(Vect2D movement)
{
if (this.physics != null)
{
movement = physics.checkTeleportation(movement);
}
this.mv(movement);
if (this.physics != null)
{
WorldObject collided = world.getObjectAt(this.physics.pos.pos.x, this.physics.pos.pos.y); //On regarde si on s'est tp sur quelque chose
if (collided != null)
{
this.onCollide(collided); //Je fais mon action vers l'objet heurté
collided.onCollide(this); //L'objet heurté fait son action (les collision vont dans les deux sens, principe d'action réaction)
}
}
}
public BasePhysics physics; //(facultatif)La physique (le comportement physique de l'objet en relation avec les autres objets)
//quand implémenté, l'objet physique va vérifier que chaque déplacement effectué par l'objet est possible selon ses regles
/// <summary>
/// Move est un déplacement en ligne droite :
/// Si un objet est sur le chemin, il est heurté (onCollide) et bloque le déplacement (enfin ca dépend du comportement de sa composante physique)
/// </summary>
/// <param name="movement"></param>
public void move(Vect2D movement) //Cette fonction fait trop de trucs : faudrait rapatrier tout ce qui touche aux rebonds dans le physics, le laisser vivre sa vie, et gérer la dimension "gameplay" des collisions uniquement à chaque updates
{
//On regarde si on va collider avec quelque chose
if (this.physics != null) //Si y'a une composante physique on peut checker les collisions
{
WorldObject collided = world.getCollidedObject(this.physics, movement);
while (collided != null) //On utilise une boucle au cas ou il y aurait des rebonds menant à d'autres collisions
{
this.onCollide(collided); //Je fais mon action vers l'objet heurté
collided.onCollide(this); //L'objet heurté fait son action (les collision vont dans les deux sens, principe d'action réaction)
movement += physics.resolveCollision(collided.physics, movement); //On laisse l'objet physics gérer l'influence de la collision sur les déplacements
collided = world.getCollidedObject(this.physics, movement);
}
}
this.mv(movement);
}
public WorldObject getCollidedObject(BasePhysics p, Vect2D destination)
{
Vect2D normalizedDirection = destination.normalize();
Vect2D currentPosCursor = p.pos.pos.Copy();
for (int i = 0; i < Vect2D.getDistance(destination, new Vect2D(0, 0)); i++)
{
currentPosCursor += normalizedDirection;
//Si oui on regarde si là ou on veut aller, il y a déjà un objet (détection de collision très basique)
WorldObject collidedObject = getObjectAt(currentPosCursor.x, currentPosCursor.y);
if (collidedObject != null && collidedObject.pos.layer == p.pos.layer)
{
return(collidedObject);
}
}
return(null);
}
public GamePosition(Vect2D pos, int layer, direction or)
{
this.pos = pos;
this.layer = layer;
this.orientation = or;
}
public virtual bool onTpCollide(BasePhysics obj, Vect2D hisTrajectory) // Si un objet veut se téléporter à la position de celui ci
{
return(false);
}
public virtual Vect2D myTeleport(Vect2D position) //Fonction overrideable pour modifier le déroulement d'une téléportation
{
return(position);
}
public GamePosition(int x, int y, int layer, direction or)
{
this.pos = new Vect2D(x, y);
this.layer = layer;
this.orientation = or;
}
public static double getDistance(Vect2D p1, Vect2D p2)
{
return(Math.Sqrt(Math.Pow(p2.x - p1.x, 2) + Math.Pow(p2.y - p1.y, 2)));
}
public Vect2D normalize()
{
int size = (int)Vect2D.getDistance(this, new Vect2D(0, 0));
return(new Vect2D(this.x / size, this.y / size));
}
public displayData(char[,,,] img, Vect2D position, int orientation)
{
this.position = position;
this.orientation = orientation;
this.img = img;
}
public void teleport(Vect2D position)
{
this.teleportObject(myTeleport(position));
}
