Plateforme de création de jeux vidéo (Le site est en cours de création / réorganisation)

public class ControlCollision extends Controler {   
    public ControlCollision (Model model) {
        super (model);
    }
    //Détecte les collisions personnages, segment lors du test de collision au sol.
    /**@params
    * posisitionsPerso, la position du joueur sur la map.
    * pointA : le somme de la pente.
    * PointB : le point
    */
    public static float calculerPointCollisionAvecTriangle  (Vec3t positionsPerso, Vec3t pointA, Vec3t pointB, Vec3t pointC) {
        //Je vais prendre comme repère le point A.       
        float angle;
        float valeur;
        //Détermination du vecteur pour la dénivellation par rapport à la hauteur. (vertical.)
        Vec3t denivellationC = new Vec3t (pointC.getVec3t()[2], pointA.getVec3t()[1], pointC.getVec3t()[2]);
        //Position du sommet par rapport à A pour le produit scalaire.
        Vec3t pointCA = denivellationC.additionner (pointA);       
        //Calcul de l'angle d'inclinaison de la pente du pointA par rapport au sommet.
        angle = (float) Math.acos(pointA.produitScalaire(pointCA));
        //On vérifie si la pente est inclinée vers le bas ou vers le haut.
        if (pointC.getVec3t()[1] > pointA.getVec3t()[1])
            angle = - angle;
        //Calcul pour savoir de combien le vecteur doit monter par rapport au sommet.
        valeur = (float) (positionsPerso.longueur() * Math.cos(angle));   
        if (pointC.getVec3t()[1] > pointA.getVec3t()[1]) {           
            //Trasnslation vers le haut.                   
            positionsPerso.translation(valeur, false, true, false);    
        } else {
            angle = -angle;
            //Transaltion vers le bas.                   
            positionsPerso.translation(-valeur, false, true, false);
        }       
        //Vecteur pour le calcul de la dénivellation de la base. (horizontal.)
        Vec3t denivellationB  = new Vec3t (pointB.getVec3t()[0], pointA.getVec3t()[1], pointB.getVec3t()[0]);
        //Position de B par rapport à A pour le produit scalaire.       
        Vec3t pointBA = pointA.additionner(pointB);
        Vec3t denivellationA = pointA.additionner(denivellationB);
        //On fait pareil que si dessus mais avec la base.
        angle = (float) Math.acos(denivellationA.produitScalaire(pointBA));       
        if (pointB.getVec3t()[1] < pointA.getVec3t()[1])
            angle = -angle;
       
        valeur = (float) (positionsPerso.longueur() * Math.cos(angle));
        if (pointB.getVec3t()[1] < pointA.getVec3t()[1])
            positionsPerso.translation(valeur, false, true, false);    
        else
            positionsPerso.translation(-valeur, false, true, false);
        return valeur;       
    }   
   
    //Détecte les collisions entre deux cylindre.
    public static boolean collideWithCylindre (Vec3t posp1, Vec3t posp2, int diamètre) {
        float distance = posp1.calculerDistance(posp2);
        return (distance <= diamètre) ? true : false;
    }
    //Détecte les collisions avec les mur.
    public static boolean collisionWithBox (Vec3t posBox, Vec3t posPerso, Vec3t[] points) {
       
        float distance = posPerso.calculerDistance(posBox);
        Vec3t pointCollision = null, avant;
        //Position du personnage par rapport au polygone.
        Vec3t posPersoBox = posPerso.additionner(posBox);       
        //On recherche le point le plus près du personnage.
        float distMin = points[0].calculerDistance(posPerso);
        int indexMin = 0;
        for (int i = 1; i < points.length; i++) {           
            float dist = points[i].calculerDistance(posPerso);
            if (dist < distMin) {
                indexMin = i;
            }           
        }       
        avant = points[indexMin];       
        //On place l'avant par rapport à la position de la boite.
        Vec3t avantPosBox = avant.additionner(posBox);           
        //On calcule l'angle entre le point de la face et le personnage.
        float angle = (float) Math.acos(posPersoBox.produitScalaire(avantPosBox));   
        //Calcul du rayon par rapport au point le plus près du perso. (Collision imparfaite.)
        float rayon = posBox.calculerDistance(points[indexMin]);
        //On fait une translation avec la tangeante suivit d'une rotation avec de -angle pour déterminer le point ou se fera la collision avec le perso sur la face.   
        pointCollision = avant.translation((float) (rayon *  Math.tan(angle)), true, true, true);
        pointCollision = avant.rotation(-angle, true, true, true);
        //Rayon Entre le centre et le point de collision.
        rayon = posBox.calculerDistance(pointCollision);
        return (distance < rayon) ? true : false;       
    }   
   
}