・Colliderコンポーネントの追加・MoveStraightコンポーネントをMoveにRenameし、波移動の機能を追加

Fork: 1

nitta-lab / AlgebraicDataflowArchitectureModel

Browse code ・Colliderコンポーネントの追加・MoveStraightコンポーネントをMoveにRenameし、波移動の機能を追加 gameEngine
1 parent 0d3daf0 commit 9301abb7c376d4754cc62e425a4d3c257e945962 NoranekoFelician authored on 23 Dec

Patch

Unified Split

Showing 4 changed files

                Ignore Space
               Show notes
              View
            
          
          108 ■■■■■
          GameEngine/src/main/java/gameEngine/entites/gameComponents/Collider.java
        
        
        
          0 → 100644
             package gameEngine.entites.gameComponents;
 
import gameEngine.entites.Entity;
import gameEngine.entites.GameObject;
import gameEngine.views.Window;
 
public class Collider extends GameComponent {
    private GameObject parent;
    private boolean isPassable; // すり抜け可能かどうか
 
    public Collider(GameObject parent, boolean isPassable) {
        this.parent = parent;
        this.isPassable = isPassable;
    }
 
    @Override
    public GameComponent copy() {
        return new Collider(parent, isPassable);
    }
 
    @Override
    public void init() {
    }
 
    @Override
    public void update() {
        for (Entity other : Window.get().getScene().entities.values()) {
            GameObject otherObject = (GameObject) other;
            if (otherObject == parent) continue; // 自分自身は無視
 
            Collider otherCollider = otherObject.getComponent(Collider.class);
            if (otherCollider != null && isCollidingWith(otherObject)) {
                System.out.println("Collision detected between "
                        + parent.getName() + " and " + otherObject.getName());
 
                if (!isPassable && !otherCollider.isPassable) {
                    resolveCollision(otherObject);
                }
            }
        }
    }
 
    private boolean isCollidingWith(GameObject other) {
        Mesh thisMesh = parent.getComponent(Mesh.class);
        Mesh otherMesh = other.getComponent(Mesh.class);
 
        if (thisMesh == null || otherMesh == null) {
            return false; // Meshがない場合は判定できない
        }
 
        float thisLeft = parent.transform.position.x;
        float thisRight = thisLeft + thisMesh.getDisplayedWidth();
        float thisTop = parent.transform.position.y;
        float thisBottom = thisTop + thisMesh.getDisplayedHeight();
 
        float otherLeft = other.transform.position.x;
        float otherRight = otherLeft + otherMesh.getDisplayedWidth();
        float otherTop = other.transform.position.y;
        float otherBottom = otherTop + otherMesh.getDisplayedHeight();
 
        return thisRight > otherLeft && thisLeft < otherRight &&
                thisBottom > otherTop && thisTop < otherBottom;
    }
 
    private void resolveCollision(GameObject other) {
        // 衝突を解消する処理
        Mesh thisMesh = parent.getComponent(Mesh.class);
        Mesh otherMesh = other.getComponent(Mesh.class);
 
        if (thisMesh == null || otherMesh == null) {
            return;
        }
 
        float thisLeft = parent.transform.position.x;
        float thisRight = thisLeft + thisMesh.getDisplayedWidth();
        float thisTop = parent.transform.position.y;
        float thisBottom = thisTop + thisMesh.getDisplayedHeight();
 
        float otherLeft = other.transform.position.x;
        float otherRight = otherLeft + otherMesh.getDisplayedWidth();
        float otherTop = other.transform.position.y;
        float otherBottom = otherTop + otherMesh.getDisplayedHeight();
 
        float overlapX = Math.min(thisRight, otherRight) - Math.max(thisLeft, otherLeft);
        float overlapY = Math.min(thisBottom, otherBottom) - Math.max(thisTop, otherTop);
 
        if (overlapX < overlapY) {
            // 横方向の重なりを解消
            if (thisLeft < otherLeft) {
                parent.transform.position.x -= overlapX;
            } else {
                parent.transform.position.x += overlapX;
            }
        } else {
            // 縦方向の重なりを解消
            if (thisTop < otherTop) {
                parent.transform.position.y -= overlapY;
            } else {
                parent.transform.position.y += overlapY;
            }
        }
    }
 
    public boolean isPassable() {
        return isPassable;
    }
}
+package gameEngine.entites.gameComponents;
+import gameEngine.entites.Entity;
+import gameEngine.entites.GameObject;
+import gameEngine.views.Window;
+public class Collider extends GameComponent {
+    private GameObject parent;
+    private boolean isPassable; // すり抜け可能かどうか
+    public Collider(GameObject parent, boolean isPassable) {
+        this.parent = parent;
+        this.isPassable = isPassable;
+    }
+    @Override
+    public GameComponent copy() {
+        return new Collider(parent, isPassable);
+    }
+    @Override
+    public void init() {
+    }
+    @Override
+    public void update() {
+        for (Entity other : Window.get().getScene().entities.values()) {
+            GameObject otherObject = (GameObject) other;
+            if (otherObject == parent) continue; // 自分自身は無視
+            Collider otherCollider = otherObject.getComponent(Collider.class);
+            if (otherCollider != null && isCollidingWith(otherObject)) {
+                System.out.println("Collision detected between "
+                        + parent.getName() + " and " + otherObject.getName());
+                if (!isPassable && !otherCollider.isPassable) {
+                    resolveCollision(otherObject);
+                }
+            }
+        }
+    }
+    private boolean isCollidingWith(GameObject other) {
+        Mesh thisMesh = parent.getComponent(Mesh.class);
+        Mesh otherMesh = other.getComponent(Mesh.class);
+        if (thisMesh == null || otherMesh == null) {
+            return false; // Meshがない場合は判定できない
+        }
+        float thisLeft = parent.transform.position.x;
+        float thisRight = thisLeft + thisMesh.getDisplayedWidth();
+        float thisTop = parent.transform.position.y;
+        float thisBottom = thisTop + thisMesh.getDisplayedHeight();
+        float otherLeft = other.transform.position.x;
+        float otherRight = otherLeft + otherMesh.getDisplayedWidth();
+        float otherTop = other.transform.position.y;
+        float otherBottom = otherTop + otherMesh.getDisplayedHeight();
+        return thisRight > otherLeft && thisLeft < otherRight &&
+                thisBottom > otherTop && thisTop < otherBottom;
+    }
+    private void resolveCollision(GameObject other) {
+        // 衝突を解消する処理
+        Mesh thisMesh = parent.getComponent(Mesh.class);
+        Mesh otherMesh = other.getComponent(Mesh.class);
+        if (thisMesh == null || otherMesh == null) {
+            return;
+        }
+        float thisLeft = parent.transform.position.x;
+        float thisRight = thisLeft + thisMesh.getDisplayedWidth();
+        float thisTop = parent.transform.position.y;
+        float thisBottom = thisTop + thisMesh.getDisplayedHeight();
+        float otherLeft = other.transform.position.x;
+        float otherRight = otherLeft + otherMesh.getDisplayedWidth();
+        float otherTop = other.transform.position.y;
+        float otherBottom = otherTop + otherMesh.getDisplayedHeight();
+        float overlapX = Math.min(thisRight, otherRight) - Math.max(thisLeft, otherLeft);
+        float overlapY = Math.min(thisBottom, otherBottom) - Math.max(thisTop, otherTop);
+        if (overlapX < overlapY) {
+            // 横方向の重なりを解消
+            if (thisLeft < otherLeft) {
+                parent.transform.position.x -= overlapX;
+            } else {
+                parent.transform.position.x += overlapX;
+            }
+        } else {
+            // 縦方向の重なりを解消
+            if (thisTop < otherTop) {
+                parent.transform.position.y -= overlapY;
+            } else {
+                parent.transform.position.y += overlapY;
+            }
+        }
+    }
+    public boolean isPassable() {
+        return isPassable;
+    }
+}

                Ignore Space
               Show notes
              View
            
          
          81 ■■■■■
          GameEngine/src/main/java/gameEngine/entites/gameComponents/Move.java
        
        
        
          0 → 100644
             package gameEngine.entites.gameComponents;
 
import gameEngine.Time;
import gameEngine.entites.GameObject;
import gameEngine.geometry.Transform;
 
public class Move extends GameComponent{
 
    private GameObject parent;
    private final float moveSpeed = 100;
    public enum Direction {UP, DOWN, LEFT, RIGHT}
    private final Direction direction = Direction.LEFT;
    public enum MoveType{
        Straight, Wave
    }
    private MoveType moveType = MoveType.Wave;
 
    public Move(GameObject parent){
        this.parent = parent;
    }
    @Override
    public GameComponent copy() {
        return this;
    }
 
    public void update() {
        if(moveType == MoveType.Straight) moveStraight();
        if(moveType == MoveType.Wave) moveWave();
    }
 
    private void moveStraight(){
        Transform transform = parent.transform;
        if (transform != null) {
            float x = transform.position.x;
            float y = transform.position.y;
            float z = transform.position.z;
 
            if (direction == Direction.UP) {
                transform.setPosition(x, y - moveSpeed * Time.deltaTime, z);
            }
            if (direction == Direction.LEFT) {
                transform.setPosition(x - moveSpeed * Time.deltaTime, y, z);
            }
            if (direction == Direction.DOWN) {
                transform.setPosition(x, y + moveSpeed * Time.deltaTime, z);
            }
            if (direction == Direction.RIGHT) {
                transform.setPosition(x + moveSpeed * Time.deltaTime, y, z);
            }
        }
    }
 
    private float waveAmplitude = 2f; // 振幅
    private float waveFrequency = 4.0f; // 周波数
    private float waveTime = 0.0f;
 
    private void moveWave(){
        Transform transform = parent.transform;
        if (transform != null) {
            float x = transform.position.x;
            float y = transform.position.y;
            float z = transform.position.z;
 
            waveTime += Time.deltaTime;
 
            if (direction == Direction.UP || direction == Direction.DOWN) {
                float baseY = direction == Direction.UP ? y - moveSpeed * Time.deltaTime : y + moveSpeed * Time.deltaTime;
                float offsetX = (float) Math.sin(waveTime * waveFrequency) * waveAmplitude;
                transform.setPosition(x + offsetX, baseY, z);
            }
 
            if (direction == Direction.LEFT || direction == Direction.RIGHT) {
                float baseX = direction == Direction.LEFT ? x - moveSpeed * Time.deltaTime : x + moveSpeed * Time.deltaTime;
                float offsetY = (float) Math.sin(waveTime * waveFrequency) * waveAmplitude;
                transform.setPosition(baseX, y + offsetY, z);
            }
        }
    }
 
}
+package gameEngine.entites.gameComponents;
+import gameEngine.Time;
+import gameEngine.entites.GameObject;
+import gameEngine.geometry.Transform;
+public class Move extends GameComponent{
+    private GameObject parent;
+    private final float moveSpeed = 100;
+    public enum Direction {UP, DOWN, LEFT, RIGHT}
+    private final Direction direction = Direction.LEFT;
+    public enum MoveType{
+        Straight, Wave
+    }
+    private MoveType moveType = MoveType.Wave;
+    public Move(GameObject parent){
+        this.parent = parent;
+    }
+    @Override
+    public GameComponent copy() {
+        return this;
+    }
+    public void update() {
+        if(moveType == MoveType.Straight) moveStraight();
+        if(moveType == MoveType.Wave) moveWave();
+    }
+    private void moveStraight(){
+        Transform transform = parent.transform;
+        if (transform != null) {
+            float x = transform.position.x;
+            float y = transform.position.y;
+            float z = transform.position.z;
+            if (direction == Direction.UP) {
+                transform.setPosition(x, y - moveSpeed * Time.deltaTime, z);
+            }
+            if (direction == Direction.LEFT) {
+                transform.setPosition(x - moveSpeed * Time.deltaTime, y, z);
+            }
+            if (direction == Direction.DOWN) {
+                transform.setPosition(x, y + moveSpeed * Time.deltaTime, z);
+            }
+            if (direction == Direction.RIGHT) {
+                transform.setPosition(x + moveSpeed * Time.deltaTime, y, z);
+            }
+        }
+    }
+    private float waveAmplitude = 2f; // 振幅
+    private float waveFrequency = 4.0f; // 周波数
+    private float waveTime = 0.0f;
+    private void moveWave(){
+        Transform transform = parent.transform;
+        if (transform != null) {
+            float x = transform.position.x;
+            float y = transform.position.y;
+            float z = transform.position.z;
+            waveTime += Time.deltaTime;
+            if (direction == Direction.UP || direction == Direction.DOWN) {
+                float baseY = direction == Direction.UP ? y - moveSpeed * Time.deltaTime : y + moveSpeed * Time.deltaTime;
+                float offsetX = (float) Math.sin(waveTime * waveFrequency) * waveAmplitude;
+                transform.setPosition(x + offsetX, baseY, z);
+            }
+            if (direction == Direction.LEFT || direction == Direction.RIGHT) {
+                float baseX = direction == Direction.LEFT ? x - moveSpeed * Time.deltaTime : x + moveSpeed * Time.deltaTime;
+                float offsetY = (float) Math.sin(waveTime * waveFrequency) * waveAmplitude;
+                transform.setPosition(baseX, y + offsetY, z);
+            }
+        }
+    }
+}

                Show notes
              View
            
          
          44 ■■■■■
          GameEngine/src/main/java/gameEngine/entites/gameComponents/MoveStraight.java
        
        
          100644 → 0
             package gameEngine.entites.gameComponents;
 
import gameEngine.Time;
import gameEngine.entites.GameObject;
import gameEngine.geometry.Transform;
 
public class MoveStraight extends GameComponent{
 
    private GameObject parent;
    private final int moveSpeed = 100;
    public enum Direction {UP, DOWN, LEFT, RIGHT}
    private final Direction direction = Direction.LEFT;
 
    public MoveStraight(GameObject parent){
        this.parent = parent;
    }
    @Override
    public GameComponent copy() {
        return this;
    }
 
    public void update() {
        Transform transform = parent.transform;
        if (transform != null) {
            float x = transform.position.x;
            float y = transform.position.y;
            float z = transform.position.z;
 
            if (direction == Direction.UP) {
                transform.setPosition(x, y - moveSpeed * Time.deltaTime, z);
            }
            if (direction == Direction.LEFT) {
                transform.setPosition(x - moveSpeed * Time.deltaTime, y, z);
            }
            if (direction == Direction.DOWN) {
                transform.setPosition(x, y + moveSpeed * Time.deltaTime, z);
            }
            if (direction == Direction.RIGHT) {
                transform.setPosition(x + moveSpeed * Time.deltaTime, y, z);
            }
        }
    }
}
-package gameEngine.entites.gameComponents;
-import gameEngine.Time;
-import gameEngine.entites.GameObject;
-import gameEngine.geometry.Transform;
-public class MoveStraight extends GameComponent{
-    private GameObject parent;
-    private final int moveSpeed = 100;
-    public enum Direction {UP, DOWN, LEFT, RIGHT}
-    private final Direction direction = Direction.LEFT;
-    public MoveStraight(GameObject parent){
-        this.parent = parent;
-    }
-    @Override
-    public GameComponent copy() {
-        return this;
-    }
-    public void update() {
-        Transform transform = parent.transform;
-        if (transform != null) {
-            float x = transform.position.x;
-            float y = transform.position.y;
-            float z = transform.position.z;
-            if (direction == Direction.UP) {
-                transform.setPosition(x, y - moveSpeed * Time.deltaTime, z);
-            }
-            if (direction == Direction.LEFT) {
-                transform.setPosition(x - moveSpeed * Time.deltaTime, y, z);
-            }
-            if (direction == Direction.DOWN) {
-                transform.setPosition(x, y + moveSpeed * Time.deltaTime, z);
-            }
-            if (direction == Direction.RIGHT) {
-                transform.setPosition(x + moveSpeed * Time.deltaTime, y, z);
-            }
-        }
-    }
-}

                Ignore Space
               Show notes
              View
            
          
          3 ■■■■■
          GameEngine/src/main/java/gameEngine/scenes/GameScene.java
                         object.addComponent(new Mesh(object, Mesh.MeshType.SPRITE, componentView.getSpritePath()));
                        break;
                    }
                }
                object.addComponent(new Collider(object, false)); //コライダー（仮）
            }
            if(connectionType == EditorEntity.Connectiontype.MoveImage){
                object.addComponent(new MoveImage(object));
            }
            if(connectionType == EditorEntity.Connectiontype.MoveStraight){
                object.addComponent(new MoveStraight(object));
                object.addComponent(new Move(object));
            }
        }
    }
                         object.addComponent(new Mesh(object, Mesh.MeshType.SPRITE, componentView.getSpritePath()));
                         break;
                     }
                 }
+                object.addComponent(new Collider(object, false)); //コライダー（仮）
             }
             if(connectionType == EditorEntity.Connectiontype.MoveImage){
                 object.addComponent(new MoveImage(object));
             }
             if(connectionType == EditorEntity.Connectiontype.MoveStraight){
+                object.addComponent(new MoveStraight(object));
+                object.addComponent(new Move(object));
             }
         }
     }

Show line notes below