try some things

src/main/java/fr/phylisiumstudio/bullet/PhysicsEngineFactory.java

@@ -0,0 +1,40 @@
+package fr.phylisiumstudio.bullet;
+
+import com.bulletphysics.collision.broadphase.BroadphaseInterface;
+import com.bulletphysics.collision.broadphase.DbvtBroadphase;
+import com.bulletphysics.collision.dispatch.CollisionConfiguration;
+import com.bulletphysics.collision.dispatch.CollisionDispatcher;
+import com.bulletphysics.collision.dispatch.DefaultCollisionConfiguration;
+import com.bulletphysics.collision.shapes.BoxShape;
+import com.bulletphysics.collision.shapes.CollisionShape;
+import com.bulletphysics.collision.shapes.SphereShape;
+import com.bulletphysics.dynamics.DiscreteDynamicsWorld;
+import com.bulletphysics.dynamics.RigidBody;
+import com.bulletphysics.dynamics.RigidBodyConstructionInfo;
+import com.bulletphysics.dynamics.constraintsolver.ConstraintSolver;
+import com.bulletphysics.dynamics.constraintsolver.SequentialImpulseConstraintSolver;
+import com.bulletphysics.linearmath.Transform;
+import fr.phylisiumstudio.logic.IPhysicsEngineFactory;
+
+import javax.vecmath.Vector3f;
+
+public class PhysicsEngineFactory implements IPhysicsEngineFactory<DiscreteDynamicsWorld,RigidBody,CollisionShape,Transform> {
+    @Override
+    public DiscreteDynamicsWorld createWorld() {
+        BroadphaseInterface broadphase = new DbvtBroadphase();
+        CollisionConfiguration collisionConfiguration = new DefaultCollisionConfiguration();
+        CollisionDispatcher dispatcher = new CollisionDispatcher(collisionConfiguration);
+        ConstraintSolver solver = new SequentialImpulseConstraintSolver();
+        return new DiscreteDynamicsWorld(dispatcher, broadphase, solver, collisionConfiguration);
+    }
+
+    @Override
+    public RigidBody createRigidBody(float mass, CollisionShape shape, Transform transform) {
+        Vector3f localInertia = new Vector3f(0, 0, 0);
+        shape.calculateLocalInertia(mass, localInertia);
+        RigidBodyConstructionInfo constructionInfo = new RigidBodyConstructionInfo(mass, null, shape, localInertia);
+        RigidBody body = new RigidBody(constructionInfo);
+        body.setWorldTransform(transform);
+        return body;
+    }
+}

src/main/java/fr/phylisiumstudio/bullet/WorldPhysics.java

@@ -0,0 +1,104 @@
+package fr.phylisiumstudio.bullet;
+
+import com.bulletphysics.collision.shapes.BoxShape;
+import com.bulletphysics.collision.shapes.SphereShape;
+import com.bulletphysics.dynamics.DiscreteDynamicsWorld;
+import com.bulletphysics.dynamics.RigidBody;
+import com.bulletphysics.linearmath.Transform;
+import fr.phylisiumstudio.logic.IPhysicsEngineFactory;
+import fr.phylisiumstudio.logic.IWorldPhysics;
+import fr.phylisiumstudio.soraxPhysic.models.RigidBlock;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.entity.BlockDisplay;
+import org.bukkit.entity.Interaction;
+import org.bukkit.util.Transformation;
+
+import javax.vecmath.Vector3f;
+import java.util.ArrayList;
+import java.util.List;
+
+public class WorldPhysics implements IWorldPhysics {
+    private final DiscreteDynamicsWorld dynamicsWorld;
+    private final List<RigidBlock> rigidBlocks = new ArrayList<>();
+    private final IPhysicsEngineFactory physicsFactory;
+    private final Object lock = new Object();
+
+    public WorldPhysics(IPhysicsEngineFactory physicsFactory) {
+        this.physicsFactory = physicsFactory;
+        this.dynamicsWorld = physicsFactory.createDynamicsWorld();
+    }
+
+    @Override
+    public void stepSimulation() {
+        synchronized (lock) {
+            dynamicsWorld.stepSimulation(1/20f, 30);
+        }
+    }
+
+    @Override
+    public RigidBody createBoxShape(Location location, Material material, float mass, float xScale, float yScale, float zScale) {
+        // Abstraction de la création des objets physiques
+        Vector3f dimensions = new Vector3f(xScale / 2, yScale / 2, zScale / 2);
+        BoxShape boxShape = physicsFactory.createBoxShape(dimensions);
+
+        Transform transform = new Transform();
+        transform.setIdentity();
+        transform.origin.set((float) location.getX(), (float) location.getY(), (float) location.getZ());
+
+        RigidBody body = physicsFactory.createRigidBody(mass, boxShape, transform);
+        dynamicsWorld.addRigidBody(body);
+
+        // Gestion de l'affichage du bloc dans Bukkit
+        createDisplayAndHitbox(location, material, xScale, yScale, zScale, body);
+
+        return body;
+    }
+
+    @Override
+    public void createSphereShape(Location location, Material material, float mass, float radius) {
+        // Création d'une sphère
+        SphereShape sphereShape = physicsFactory.createSphereShape(radius);
+
+        Transform transform = new Transform();
+        transform.setIdentity();
+        transform.origin.set((float) location.getX(), (float) location.getY(), (float) location.getZ());
+
+        RigidBody body = physicsFactory.createRigidBody(mass, sphereShape, transform);
+        dynamicsWorld.addRigidBody(body);
+
+        createDisplayAndHitbox(location, material, radius, radius, radius, body);
+    }
+
+    private void createDisplayAndHitbox(Location location, Material material, float xScale, float yScale, float zScale, RigidBody body) {
+        BlockDisplay blockDisplay = location.getWorld().spawn(location, BlockDisplay.class, display -> {
+            display.setTeleportDuration(1);
+            display.setBlock(material.createBlockData());
+            Transformation transformation = display.getTransformation();
+            org.joml.Vector3f translation = new org.joml.Vector3f(-xScale / 2, -yScale / 2, -zScale / 2);
+            org.joml.Vector3f scale = new org.joml.Vector3f(xScale, yScale, zScale);
+            display.setTransformation(new Transformation(translation, transformation.getLeftRotation(), scale, transformation.getRightRotation()));
+        });
+
+        Interaction hitbox = location.getWorld().spawn(location, Interaction.class, interaction -> {
+            interaction.setInteractionHeight(yScale);
+            interaction.setInteractionWidth(zScale);
+            interaction.setResponsive(true);
+        });
+
+        RigidBlock rigidBlock = new RigidBlock(body, blockDisplay, hitbox);
+        rigidBlocks.add(rigidBlock);
+    }
+
+    @Override
+    public void clearAll() {
+        synchronized (lock) {
+            for (RigidBlock rigidBlock : rigidBlocks) {
+                dynamicsWorld.removeRigidBody(rigidBlock.getRigidBody());
+                rigidBlock.getBlockDisplay().remove();
+                rigidBlock.getInteraction().remove();
+            }
+            rigidBlocks.clear();
+        }
+    }
+}

src/main/java/fr/phylisiumstudio/bullet/fabric/ShapeAbstractFabric.java

@@ -0,0 +1,10 @@
+package fr.phylisiumstudio.bullet.fabric;
+
+import com.bulletphysics.collision.shapes.CollisionShape;
+import fr.phylisiumstudio.logic.fabric.AbstractFactory;
+
+/**
+ * Abstract factory for creating shapes
+ */
+public class ShapeAbstractFabric extends AbstractFactory<CollisionShape, ShapeConstructor> {
+}

src/main/java/fr/phylisiumstudio/bullet/fabric/ShapeConstructor.java

@@ -0,0 +1,10 @@
+package fr.phylisiumstudio.bullet.fabric;
+
+import com.bulletphysics.collision.shapes.CollisionShape;
+import fr.phylisiumstudio.logic.fabric.IConstructor;
+
+/**
+ * Abstract class for the shape constructor
+ */
+public abstract class ShapeConstructor implements IConstructor<CollisionShape> {
+}

src/main/java/fr/phylisiumstudio/bullet/fabric/constructors/CubeConstructor.java

@@ -0,0 +1,23 @@
+package fr.phylisiumstudio.bullet.fabric.constructors;
+
+import com.bulletphysics.collision.shapes.BoxShape;
+import com.bulletphysics.collision.shapes.CollisionShape;
+import fr.phylisiumstudio.bullet.fabric.ShapeConstructor;
+
+import javax.vecmath.Vector3f;
+
+/**
+ * Constructor for the cube shape
+ */
+public class CubeConstructor extends ShapeConstructor {
+    @Override
+    public String getName() {
+        return "cube";
+    }
+
+    @Override
+    public CollisionShape construct(Object... args) {
+        Vector3f size = (Vector3f) args[0];
+        return new BoxShape(size);
+    }
+}

src/main/java/fr/phylisiumstudio/bullet/fabric/constructors/SphereConstructor.java

@@ -0,0 +1,21 @@
+package fr.phylisiumstudio.bullet.fabric.constructors;
+
+import com.bulletphysics.collision.shapes.CollisionShape;
+import com.bulletphysics.collision.shapes.SphereShape;
+import fr.phylisiumstudio.bullet.fabric.ShapeConstructor;
+
+/**
+ * Constructor for the sphere shape
+ */
+public class SphereConstructor extends ShapeConstructor {
+    @Override
+    public String getName() {
+        return "sphere";
+    }
+
+    @Override
+    public CollisionShape construct(Object... args) {
+        float radius = (float) args[0];
+        return new SphereShape(radius);
+    }
+}

src/main/java/fr/phylisiumstudio/logic/IPhysicsEngineFactory.java

@@ -0,0 +1,31 @@
+package fr.phylisiumstudio.logic;
+
+import com.bulletphysics.collision.shapes.BoxShape;
+import com.bulletphysics.collision.shapes.CollisionShape;
+import com.bulletphysics.collision.shapes.SphereShape;
+import com.bulletphysics.dynamics.DiscreteDynamicsWorld;
+import com.bulletphysics.dynamics.RigidBody;
+import com.bulletphysics.linearmath.Transform;
+
+import javax.vecmath.Vector3f;
+
+/**
+ * Factory for creating physics engine objects
+ */
+public interface IPhysicsEngineFactory<T,C,W,V> {
+
+    /**
+     * Create a new dynamics world
+     * @return the new dynamics world
+     */
+    T createWorld();
+
+    /**
+     * Create a new rigid body
+     * @param mass the mass of the rigid body
+     * @param shape the shape of the rigid body
+     * @param transform the transform of the rigid body
+     * @return the new rigid body
+     */
+    C createRigidBody(float mass, W shape, V transform);
+}

src/main/java/fr/phylisiumstudio/logic/IPhysicsManager.java

@@ -0,0 +1,26 @@
+package fr.phylisiumstudio.logic;
+
+import org.bukkit.World;
+
+/**
+ * Interface for the physics manager
+ */
+public interface IPhysicsManager {
+    /**
+     * Get the physics engine for a world
+     * @param world The world
+     * @return The physics engine
+     */
+    IWorldPhysics getWorldPhysics(World world);
+
+    /**
+     * Setup the physics engine for a world
+     * @param world The world
+     */
+    void setupPhysicsEngine(World world);
+
+    /**
+     * Stop the physics engine
+     */
+    void stop();
+}

src/main/java/fr/phylisiumstudio/logic/IWorldPhysics.java

@@ -0,0 +1,19 @@
+package fr.phylisiumstudio.logic;
+
+import java.util.UUID;
+
+/**
+ * Interface for the physics world
+ */
+public interface IWorldPhysics {
+    /**
+     * Step the simulation
+     */
+    void stepSimulation();
+
+    /**
+     * Get the unique id of the world
+     * @return the unique id
+     */
+    UUID uniqueId();
+}