diff options
Diffstat (limited to 'core/src/main/java/coffee')
25 files changed, 928 insertions, 56 deletions
diff --git a/core/src/main/java/coffee/liz/dyl/DylGame.java b/core/src/main/java/coffee/liz/dyl/DylGame.java new file mode 100644 index 0000000..aa25617 --- /dev/null +++ b/core/src/main/java/coffee/liz/dyl/DylGame.java @@ -0,0 +1,53 @@ +package coffee.liz.dyl; + +import coffee.liz.dyl.config.Settings; +import coffee.liz.dyl.screen.GameScreen; +import com.badlogic.gdx.Game; +import com.badlogic.gdx.Gdx; +import com.badlogic.gdx.InputMultiplexer; +import com.badlogic.gdx.graphics.GL20; +import com.badlogic.gdx.graphics.OrthographicCamera; +import com.badlogic.gdx.graphics.g2d.Batch; +import com.badlogic.gdx.graphics.g2d.SpriteBatch; +import com.badlogic.gdx.utils.viewport.FitViewport; +import com.badlogic.gdx.utils.viewport.Viewport; +import lombok.Getter; + +@Getter +public class DylGame extends Game { + public static final float WORLD_WIDTH = 10f; + public static final float WORLD_HEIGHT = 10f; + public static final float UNIT_SCALE = 1/10f; + + private InputMultiplexer inputMultiplexer; + private Batch batch; + private OrthographicCamera camera; + private Viewport viewport; + private Settings settings = Settings.builder().build(); + + @Override + public void create() { + inputMultiplexer = new InputMultiplexer(); + Gdx.input.setInputProcessor(inputMultiplexer); + + batch = new SpriteBatch(); + camera = new OrthographicCamera(); + viewport = new FitViewport(WORLD_WIDTH, WORLD_HEIGHT, camera); + + setScreen(new GameScreen(this)); + } + + @Override + public void render() { + Gdx.gl.glClearColor(0, 0, 0, 1); + Gdx.gl.glClear(GL20.GL_COLOR_BUFFER_BIT); + + super.render(); + } + + @Override + public void resize(final int width, final int height) { + viewport.update(width, height, true); + super.resize(width, height); + } +} diff --git a/core/src/main/java/coffee/liz/dyl/FirstScreen.java b/core/src/main/java/coffee/liz/dyl/FirstScreen.java deleted file mode 100644 index 4901283..0000000 --- a/core/src/main/java/coffee/liz/dyl/FirstScreen.java +++ /dev/null @@ -1,45 +0,0 @@ -package coffee.liz.dyl; - -import com.badlogic.gdx.Screen; - -/** First screen of the application. Displayed after the application is created. */ -public class FirstScreen implements Screen { - @Override - public void show() { - // Prepare your screen here. - } - - @Override - public void render(float delta) { - // Draw your screen here. "delta" is the time since last render in seconds. - } - - @Override - public void resize(int width, int height) { - // If the window is minimized on a desktop (LWJGL3) platform, width and height are 0, which causes problems. - // In that case, we don't resize anything, and wait for the window to be a normal size before updating. - if(width <= 0 || height <= 0) return; - - // Resize your screen here. The parameters represent the new window size. - } - - @Override - public void pause() { - // Invoked when your application is paused. - } - - @Override - public void resume() { - // Invoked when your application is resumed after pause. - } - - @Override - public void hide() { - // This method is called when another screen replaces this one. - } - - @Override - public void dispose() { - // Destroy screen's assets here. - } -}
\ No newline at end of file diff --git a/core/src/main/java/coffee/liz/dyl/FrameState.java b/core/src/main/java/coffee/liz/dyl/FrameState.java new file mode 100644 index 0000000..7d70cde --- /dev/null +++ b/core/src/main/java/coffee/liz/dyl/FrameState.java @@ -0,0 +1,16 @@ +package coffee.liz.dyl; + +import coffee.liz.dyl.config.Settings; +import lombok.Builder; +import lombok.Getter; +import lombok.RequiredArgsConstructor; + +import java.util.function.Predicate; + +@Builder +@Getter +@RequiredArgsConstructor +public class FrameState { + private final Settings settings; + private final Predicate<Integer> isKeyPressed; +} diff --git a/core/src/main/java/coffee/liz/dyl/Main.java b/core/src/main/java/coffee/liz/dyl/Main.java deleted file mode 100644 index 24fa3de..0000000 --- a/core/src/main/java/coffee/liz/dyl/Main.java +++ /dev/null @@ -1,11 +0,0 @@ -package coffee.liz.dyl; - -import com.badlogic.gdx.Game; - -/** {@link com.badlogic.gdx.ApplicationListener} implementation shared by all platforms. */ -public class Main extends Game { - @Override - public void create() { - setScreen(new FirstScreen()); - } -}
\ No newline at end of file diff --git a/core/src/main/java/coffee/liz/dyl/components/Controllable.java b/core/src/main/java/coffee/liz/dyl/components/Controllable.java new file mode 100644 index 0000000..c476c91 --- /dev/null +++ b/core/src/main/java/coffee/liz/dyl/components/Controllable.java @@ -0,0 +1,6 @@ +package coffee.liz.dyl.components; + +import coffee.liz.ecs.model.Component; + +public class Controllable implements Component { +} diff --git a/core/src/main/java/coffee/liz/dyl/components/Transform.java b/core/src/main/java/coffee/liz/dyl/components/Transform.java new file mode 100644 index 0000000..b2d5a60 --- /dev/null +++ b/core/src/main/java/coffee/liz/dyl/components/Transform.java @@ -0,0 +1,18 @@ +package coffee.liz.dyl.components; + +import coffee.liz.ecs.model.Component; +import com.badlogic.gdx.math.Vector2; +import lombok.AllArgsConstructor; +import lombok.Getter; + +@AllArgsConstructor +@Getter +public class Transform implements Component, Comparable<Transform> { + private Vector2 position; + private int z; + + @Override + public int compareTo(final Transform other) { + return Integer.compare(z, other.getZ()); + } +} diff --git a/core/src/main/java/coffee/liz/dyl/components/Velocity.java b/core/src/main/java/coffee/liz/dyl/components/Velocity.java new file mode 100644 index 0000000..eb981f7 --- /dev/null +++ b/core/src/main/java/coffee/liz/dyl/components/Velocity.java @@ -0,0 +1,16 @@ +package coffee.liz.dyl.components; + +import coffee.liz.ecs.model.Component; +import com.badlogic.gdx.math.Vector2; +import lombok.AllArgsConstructor; +import lombok.Getter; +import lombok.NoArgsConstructor; +import lombok.Setter; + +@AllArgsConstructor +@NoArgsConstructor +@Getter +@Setter +public class Velocity implements Component { + private Vector2 velocity = Vector2.Zero; +} diff --git a/core/src/main/java/coffee/liz/dyl/components/graphic/Graphic.java b/core/src/main/java/coffee/liz/dyl/components/graphic/Graphic.java new file mode 100644 index 0000000..648a930 --- /dev/null +++ b/core/src/main/java/coffee/liz/dyl/components/graphic/Graphic.java @@ -0,0 +1,13 @@ +package coffee.liz.dyl.components.graphic; + +import coffee.liz.dyl.components.Transform; +import coffee.liz.ecs.model.Component; +import com.badlogic.gdx.graphics.g2d.Batch; + +public interface Graphic extends Component { + default Class<? extends Component> getKey() { + return Graphic.class; + } + + void draw(final Batch batch, final Transform transform); +} diff --git a/core/src/main/java/coffee/liz/dyl/components/graphic/TextureGraphic.java b/core/src/main/java/coffee/liz/dyl/components/graphic/TextureGraphic.java new file mode 100644 index 0000000..0d12f1a --- /dev/null +++ b/core/src/main/java/coffee/liz/dyl/components/graphic/TextureGraphic.java @@ -0,0 +1,21 @@ +package coffee.liz.dyl.components.graphic; + +import coffee.liz.dyl.components.Transform; +import com.badlogic.gdx.graphics.Color; +import com.badlogic.gdx.graphics.g2d.Batch; +import com.badlogic.gdx.graphics.g2d.TextureRegion; +import lombok.AllArgsConstructor; +import lombok.Getter; + +@Getter +@AllArgsConstructor +public class TextureGraphic implements Graphic { + private Color color; + private TextureRegion textureRegion; + + @Override + public void draw(final Batch batch, final Transform transform) { + batch.setColor(color); + batch.draw(textureRegion, transform.getPosition().x, transform.getPosition().y); + } +} diff --git a/core/src/main/java/coffee/liz/dyl/config/KeyBinds.java b/core/src/main/java/coffee/liz/dyl/config/KeyBinds.java new file mode 100644 index 0000000..762dc48 --- /dev/null +++ b/core/src/main/java/coffee/liz/dyl/config/KeyBinds.java @@ -0,0 +1,41 @@ +package coffee.liz.dyl.config; +import com.badlogic.gdx.Input; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Getter; +import lombok.RequiredArgsConstructor; + +import java.util.HashSet; +import java.util.Map; +import java.util.Set; +import java.util.function.Predicate; + +@Builder +@AllArgsConstructor +@RequiredArgsConstructor +@Getter +public class KeyBinds { + @Builder.Default + private Set<Integer> moveUpKeys = Set.of(Input.Keys.K, Input.Keys.UP, Input.Keys.W); + @Builder.Default + private Set<Integer> moveDownKeys = Set.of(Input.Keys.J, Input.Keys.DOWN, Input.Keys.S); + @Builder.Default + private Set<Integer> moveLeftKeys = Set.of(Input.Keys.H, Input.Keys.LEFT, Input.Keys.A); + @Builder.Default + private Set<Integer> moveRightKeys = Set.of(Input.Keys.L, Input.Keys.RIGHT, Input.Keys.D); + + public Set<Action> filterActiveActions(final Predicate<Integer> isDown) { + final Set<Action> actions = new HashSet<>(); + Map.of(moveUpKeys, Action.MOVE_UP, moveDownKeys, Action.MOVE_DOWN, moveRightKeys, Action.MOVE_RIGHT, + moveLeftKeys, Action.MOVE_LEFT).forEach((keys, action) -> { + if (keys.stream().anyMatch(isDown)) { + actions.add(action); + } + }); + return actions; + } + + public enum Action { + MOVE_UP, MOVE_LEFT, MOVE_DOWN, MOVE_RIGHT; + } +} diff --git a/core/src/main/java/coffee/liz/dyl/config/Settings.java b/core/src/main/java/coffee/liz/dyl/config/Settings.java new file mode 100644 index 0000000..13fbb3c --- /dev/null +++ b/core/src/main/java/coffee/liz/dyl/config/Settings.java @@ -0,0 +1,16 @@ +package coffee.liz.dyl.config; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Getter; + +@Builder +@AllArgsConstructor +@Getter +public class Settings { + @Builder.Default + private boolean skipIntro = true; + @Builder.Default + private boolean playMusic = true; + @Builder.Default + private KeyBinds keyBinds = KeyBinds.builder().build(); +} diff --git a/core/src/main/java/coffee/liz/dyl/entities/PlayerFactory.java b/core/src/main/java/coffee/liz/dyl/entities/PlayerFactory.java new file mode 100644 index 0000000..f7344c7 --- /dev/null +++ b/core/src/main/java/coffee/liz/dyl/entities/PlayerFactory.java @@ -0,0 +1,31 @@ +package coffee.liz.dyl.entities; + +import coffee.liz.dyl.components.Controllable; +import coffee.liz.dyl.components.Velocity; +import coffee.liz.dyl.components.graphic.TextureGraphic; +import coffee.liz.ecs.model.Entity; +import coffee.liz.ecs.model.World; +import com.badlogic.gdx.Gdx; +import com.badlogic.gdx.files.FileHandle; +import com.badlogic.gdx.graphics.Color; +import com.badlogic.gdx.graphics.Texture; +import com.badlogic.gdx.graphics.g2d.TextureRegion; + +public class PlayerFactory { + private static final int PENGUIN_FRAMES_Y = 4; + private static final int PENGUIN_FRAMES_X = 8; + private static final FileHandle FILE = Gdx.files.internal("player.png"); + + public static Entity addTo(final World<?> world) { + final Texture texture = new Texture(FILE); + final TextureRegion[][] tmp = TextureRegion.split(texture, + texture.getWidth() / PENGUIN_FRAMES_X, + texture.getHeight() / PENGUIN_FRAMES_Y); + return world.createEntity() + .add(new TextureGraphic(Color.PINK, tmp[0][0])) + .add(new Controllable()) + .add(new Velocity()); + } + + private PlayerFactory() { } +} diff --git a/core/src/main/java/coffee/liz/dyl/screen/GameScreen.java b/core/src/main/java/coffee/liz/dyl/screen/GameScreen.java new file mode 100644 index 0000000..54dfda3 --- /dev/null +++ b/core/src/main/java/coffee/liz/dyl/screen/GameScreen.java @@ -0,0 +1,51 @@ +package coffee.liz.dyl.screen; + +import coffee.liz.dyl.DylGame; +import coffee.liz.dyl.FrameState; +import coffee.liz.dyl.world.DylGameWorld; +import com.badlogic.gdx.Gdx; +import com.badlogic.gdx.Screen; +import lombok.RequiredArgsConstructor; + +@RequiredArgsConstructor +public class GameScreen implements Screen { + private final DylGame game; + + private DylGameWorld dylGameWorld; + private FrameState frameState; + + @Override + public void show() { + dylGameWorld = new DylGameWorld(game); + frameState = FrameState.builder() + .settings(game.getSettings()) + .isKeyPressed(Gdx.input::isKeyPressed) + .build(); + } + + @Override + public void render(final float delta) { + dylGameWorld.update(frameState, delta); + } + + @Override + public void resize(final int width, final int height) { + } + + @Override + public void pause() { + } + + @Override + public void resume() { + } + + @Override + public void hide() { + } + + @Override + public void dispose() { + dylGameWorld.dispose(); + } +} diff --git a/core/src/main/java/coffee/liz/dyl/systems/InputSystem.java b/core/src/main/java/coffee/liz/dyl/systems/InputSystem.java new file mode 100644 index 0000000..8a357ba --- /dev/null +++ b/core/src/main/java/coffee/liz/dyl/systems/InputSystem.java @@ -0,0 +1,41 @@ +package coffee.liz.dyl.systems; + +import coffee.liz.dyl.FrameState; +import coffee.liz.dyl.components.Transform; +import coffee.liz.dyl.components.Velocity; +import coffee.liz.dyl.config.KeyBinds; +import coffee.liz.ecs.model.System; +import coffee.liz.ecs.model.World; +import com.badlogic.gdx.math.Vector2; + +import java.util.Collection; +import java.util.Set; + +public class InputSystem implements System<FrameState> { + @Override + public Collection<Class<? extends System<FrameState>>> getDependencies() { + return Set.of(); + } + + @Override + public void update(final World<FrameState> world, final FrameState state, final float deltaSeconds) { + final Set<KeyBinds.Action> currentlyActive = state.getSettings().getKeyBinds() + .filterActiveActions(state.getIsKeyPressed()); + + final Vector2 momentum = Vector2.Zero.cpy(); + currentlyActive.stream().map(InputSystem::actionToMovement).forEach(momentum::add); + + world.queryable().allOf(Velocity.class, Transform.class).forEach(e -> { + e.get(Velocity.class).getVelocity().set(momentum); + }); + } + + private static Vector2 actionToMovement(final KeyBinds.Action action) { + return switch (action) { + case MOVE_UP -> new Vector2(0, 1); + case MOVE_DOWN -> new Vector2(0, -1); + case MOVE_LEFT -> new Vector2(-1, 0); + case MOVE_RIGHT -> new Vector2(1, 0); + }; + } +} diff --git a/core/src/main/java/coffee/liz/dyl/systems/IntegrationSystem.java b/core/src/main/java/coffee/liz/dyl/systems/IntegrationSystem.java new file mode 100644 index 0000000..3fb9b76 --- /dev/null +++ b/core/src/main/java/coffee/liz/dyl/systems/IntegrationSystem.java @@ -0,0 +1,30 @@ +package coffee.liz.dyl.systems; + +import coffee.liz.dyl.FrameState; +import coffee.liz.dyl.components.Transform; +import coffee.liz.dyl.components.Velocity; +import coffee.liz.ecs.model.System; +import coffee.liz.ecs.model.World; +import com.badlogic.gdx.math.Vector2; +import lombok.extern.log4j.Log4j2; + +import java.util.Collection; +import java.util.List; + +@Log4j2 +public class IntegrationSystem implements System<FrameState> { + @Override + public Collection<Class<? extends System<FrameState>>> getDependencies() { + return List.of(InputSystem.class); + } + + @Override + public void update(final World<FrameState> world, final FrameState state, final float deltaSeconds) { + world.queryable().allOf(Velocity.class, Transform.class) + .forEach(e -> { + final Vector2 velocity = e.get(Velocity.class).getVelocity(); + final Vector2 position = e.get(Transform.class).getPosition(); + position.add(velocity.cpy().scl(deltaSeconds)); + }); + } +} diff --git a/core/src/main/java/coffee/liz/dyl/systems/RenderSystem.java b/core/src/main/java/coffee/liz/dyl/systems/RenderSystem.java new file mode 100644 index 0000000..2f185cd --- /dev/null +++ b/core/src/main/java/coffee/liz/dyl/systems/RenderSystem.java @@ -0,0 +1,53 @@ +package coffee.liz.dyl.systems; + +import coffee.liz.dyl.FrameState; +import coffee.liz.dyl.components.graphic.Graphic; +import coffee.liz.dyl.components.Transform; +import coffee.liz.ecs.model.System; +import coffee.liz.ecs.model.World; +import com.badlogic.gdx.graphics.Color; +import com.badlogic.gdx.graphics.OrthographicCamera; +import com.badlogic.gdx.graphics.g2d.Batch; +import com.badlogic.gdx.utils.viewport.Viewport; + +import java.util.Collection; +import java.util.Comparator; +import java.util.Set; + +public class RenderSystem implements System<FrameState> { + private final Batch batch; + private final OrthographicCamera camera; + private final Viewport viewport; + + public RenderSystem(final Batch batch, final Viewport viewport) { + this.batch = batch; + this.viewport = viewport; + this.camera = (OrthographicCamera) viewport.getCamera(); + } + + @Override + public Collection<Class<? extends System<FrameState>>> getDependencies() { + return Set.of(IntegrationSystem.class); + } + + @Override + public void update(final World<FrameState> world, final FrameState state, final float deltaSeconds) { + viewport.apply(); + camera.update(); + + batch.setProjectionMatrix(camera.combined); + batch.begin(); + batch.setColor(Color.WHITE); + + world.queryable().allOf(Transform.class, Graphic.class).stream() + .sorted(Comparator.comparing(e -> e.get(Transform.class))) + .forEach(e -> { + final Transform transform = e.get(Transform.class); + final Graphic graphic = e.get(Graphic.class); + graphic.draw(batch, transform); + }); + + batch.setColor(Color.WHITE); + batch.end(); + } +} diff --git a/core/src/main/java/coffee/liz/dyl/world/DylGameWorld.java b/core/src/main/java/coffee/liz/dyl/world/DylGameWorld.java new file mode 100644 index 0000000..b04a4df --- /dev/null +++ b/core/src/main/java/coffee/liz/dyl/world/DylGameWorld.java @@ -0,0 +1,23 @@ +package coffee.liz.dyl.world; + +import coffee.liz.dyl.DylGame; +import coffee.liz.dyl.FrameState; +import coffee.liz.dyl.components.Transform; +import coffee.liz.dyl.entities.PlayerFactory; +import coffee.liz.dyl.systems.InputSystem; +import coffee.liz.dyl.systems.IntegrationSystem; +import coffee.liz.dyl.systems.RenderSystem; +import coffee.liz.ecs.DAGWorld; +import com.badlogic.gdx.math.Vector2; + +public class DylGameWorld extends DAGWorld<FrameState> { + public DylGameWorld(final DylGame game) { + super( + new InputSystem(), + new IntegrationSystem(), + new RenderSystem(game.getBatch(), game.getViewport()) + ); + PlayerFactory.addTo(this) + .add(new Transform(Vector2.One, 1)); + } +} diff --git a/core/src/main/java/coffee/liz/ecs/DAGWorld.java b/core/src/main/java/coffee/liz/ecs/DAGWorld.java new file mode 100644 index 0000000..1075e5e --- /dev/null +++ b/core/src/main/java/coffee/liz/ecs/DAGWorld.java @@ -0,0 +1,207 @@ +package coffee.liz.ecs; + +import coffee.liz.ecs.model.Component; +import coffee.liz.ecs.model.Entity; +import coffee.liz.ecs.model.Query; +import coffee.liz.ecs.model.System; +import coffee.liz.ecs.model.World; + +import lombok.RequiredArgsConstructor; +import lombok.extern.log4j.Log4j2; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Queue; +import java.util.Set; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.stream.Collectors; + +/** World that updates in {@link System#getDependencies()} topological order. */ +@Log4j2 +@RequiredArgsConstructor +public class DAGWorld<T> implements World<T> { + /** All entities in the world. */ + protected final Set<Entity> entities = Collections.synchronizedSet(new HashSet<>()); + + /** Cache mapping component types to entities having that component. */ + private final Map<Class<? extends Component>, Set<Entity>> componentCache = Collections + .synchronizedMap(new HashMap<>()); + + /** Deterministic ID's for spawned entities. */ + private final AtomicInteger nextEntityId = new AtomicInteger(0); + + /** All registered systems. */ + protected final Map<Class<? extends System<T>>, System<T>> systems; + + /** Ordered list of systems for execution. */ + private final List<System<T>> systemExecutionOrder; + + @SafeVarargs + public DAGWorld(final System<T>... systems) { + this.systems = singletonClazzMap(systems); + this.systemExecutionOrder = buildExecutionOrder(Arrays.asList(systems)); + log.debug("Executing in order: {}", systemExecutionOrder); + } + + @Override + public Entity createEntity() { + final Entity entity = Entity.builder().id(nextEntityId.incrementAndGet()).build(); + entities.add(entity); + return entity; + } + + @Override + public void removeEntity(final Entity entity) { + entity.getComponentMap().keySet().forEach(componentType -> { + final Set<Entity> cachedEntities = componentCache.get(componentType); + if (cachedEntities != null) { + cachedEntities.remove(entity); + } + }); + entities.remove(entity); + } + + @Override + public Set<Entity> resolve(final Query query) { + final Set<Class<? extends Component>> components = query.queryingComponents(); + return switch (query.filter()) { + case ALL_OF -> resolveAllOf(components); + case ANY_OF -> resolveAnyOf(components); + case NONE_OF -> resolveNoneOf(components); + }; + } + + @Override + public void update(final T state, final float deltaSeconds) { + systemExecutionOrder.forEach(system -> { + refreshComponentCache(); + system.update(this, state, deltaSeconds); + }); + refreshComponentCache(); + } + + @SuppressWarnings("unchecked") + @Override + public <S extends System<T>> S getSystem(final Class<S> system) { + return (S) systems.get(system); + } + + private void refreshComponentCache() { + componentCache.clear(); + entities.forEach(entity -> entity.getComponentMap().keySet().forEach( + componentType -> componentCache.computeIfAbsent(componentType, _comp -> new HashSet<>()).add(entity))); + } + + private Set<Entity> resolveAllOf(final Set<Class<? extends Component>> components) { + if (components.isEmpty()) { + return Set.copyOf(entities); + } + + final Class<? extends Component> firstType = components.iterator().next(); + final Set<Entity> candidates = componentCache.get(firstType); + if (candidates == null) { + return Collections.emptySet(); + } + + return candidates.stream().filter(entity -> components.stream().allMatch(entity::has)) + .collect(Collectors.toSet()); + } + + private Set<Entity> resolveAnyOf(final Set<Class<? extends Component>> components) { + if (components.isEmpty()) { + return Collections.emptySet(); + } + + return entities.stream().filter(entity -> components.stream().anyMatch(entity::has)) + .collect(Collectors.toSet()); + } + + private Set<Entity> resolveNoneOf(final Set<Class<? extends Component>> components) { + if (components.isEmpty()) { + return Set.copyOf(entities); + } + + return entities.stream().filter(entity -> components.stream().noneMatch(entity::has)) + .collect(Collectors.toSet()); + } + + private List<System<T>> buildExecutionOrder(final Collection<System<T>> systems) { + if (systems.isEmpty()) { + return Collections.emptyList(); + } + + final Map<Class<?>, System<T>> systemMap = systems.stream() + .collect(Collectors.toMap(System::getClass, system -> system, (_sys, b) -> b, LinkedHashMap::new)); + final Map<Class<?>, Integer> inDegree = new LinkedHashMap<>(); + final Map<Class<?>, Set<Class<?>>> adjacencyList = new LinkedHashMap<>(); + + systems.forEach(system -> { + final Class<?> systemClass = system.getClass(); + inDegree.put(systemClass, 0); + adjacencyList.put(systemClass, new HashSet<>()); + }); + + systems.forEach(system -> { + system.getDependencies().forEach(dependency -> { + if (systemMap.containsKey(dependency)) { + adjacencyList.get(dependency).add(system.getClass()); + inDegree.merge(system.getClass(), 1, Integer::sum); + } + }); + }); + + // Kahn's algorithm + final List<System<T>> result = new ArrayList<>(); + + final Queue<Class<?>> queue = new LinkedList<>( + inDegree.entrySet().stream().filter(entry -> entry.getValue() == 0).map(Map.Entry::getKey).toList()); + + while (!queue.isEmpty()) { + final Class<?> currentClass = queue.poll(); + result.add(systemMap.get(currentClass)); + + adjacencyList.getOrDefault(currentClass, Collections.emptySet()).forEach(dependent -> { + final int newInDegree = inDegree.get(dependent) - 1; + inDegree.put(dependent, newInDegree); + if (newInDegree == 0) { + queue.add(dependent); + } + }); + } + + if (result.size() != systems.size()) { + throw new IllegalStateException("Circular dependency detected in systems"); + } + + return Collections.unmodifiableList(result); + } + + @Override + public void dispose() { + for (final System<T> system : systemExecutionOrder) { + system.dispose(); + } + componentCache.clear(); + entities.clear(); + } + + @SuppressWarnings("unchecked") + private static <T> Map<Class<? extends T>, T> singletonClazzMap(final T... singletons) { + final boolean areSingletons = Arrays.stream(singletons).map(t -> (Class<? extends System<T>>) t.getClass()) + .distinct().count() == singletons.length; + if (!areSingletons) { + throw new IllegalArgumentException("Only one instance may be used per clazz"); + } + + return Arrays.stream(singletons).map(t -> Map.entry((Class<? extends T>) t.getClass(), t)) + .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); + } +} diff --git a/core/src/main/java/coffee/liz/ecs/model/Component.java b/core/src/main/java/coffee/liz/ecs/model/Component.java new file mode 100644 index 0000000..2d3a8e7 --- /dev/null +++ b/core/src/main/java/coffee/liz/ecs/model/Component.java @@ -0,0 +1,8 @@ +package coffee.liz.ecs.model; + +/** Component of an {@link Entity}. */ +public interface Component { + default Class<? extends Component> getKey() { + return getClass(); + } +} diff --git a/core/src/main/java/coffee/liz/ecs/model/Entity.java b/core/src/main/java/coffee/liz/ecs/model/Entity.java new file mode 100644 index 0000000..7dab667 --- /dev/null +++ b/core/src/main/java/coffee/liz/ecs/model/Entity.java @@ -0,0 +1,105 @@ +package coffee.liz.ecs.model; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.Getter; +import lombok.RequiredArgsConstructor; + +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.Set; + +@Getter +@Builder +@RequiredArgsConstructor +@AllArgsConstructor +@Data +public class Entity { + /** Unique id. */ + private final int id; + + /** Instances of {@link Component}s. */ + @Builder.Default + private Map<Class<? extends Component>, Component> componentMap = Collections.synchronizedMap(new HashMap<>()); + + /** + * Check if entity has component type. + * + * @param componentType + * the {@link Component} class + * @return true if component exists + */ + public boolean has(final Class<? extends Component> componentType) { + return componentMap.containsKey(componentType); + } + + /** + * Check if entity has all component types. + * + * @param components + * collection of {@link Component} classes + * @return true if all components exist + */ + public boolean hasAll(final Collection<Class<? extends Component>> components) { + return components.stream().allMatch(this::has); + } + + /** + * Get component by type. + * + * @param componentType + * the {@link Component} class + * @param <C> + * component type + * @return the component or throw {@link IllegalArgumentException} + */ + @SuppressWarnings("unchecked") + public <C extends Component> C get(final Class<C> componentType) { + final C component = (C) componentMap.get(componentType); + if (component == null) { + throw new IllegalArgumentException( + "Entity with id " + getId() + " does not have required component " + componentType.getSimpleName()); + } + return component; + } + + /** + * Add component to entity. + * + * @param component + * the {@link Component} to add + * @param <C> + * component type + * @return this {@link Entity} for chaining + */ + public <C extends Component> Entity add(final C component) { + componentMap.put(component.getKey(), component); + return this; + } + + /** + * Remove component from entity. + * + * @param componentType + * the {@link Component} class to remove + * @param <C> + * component type + * @return this {@link Entity} for chaining + */ + public <C extends Component> Entity remove(final Class<C> componentType) { + componentMap.remove(componentType); + return this; + } + + /** + * Get all component types. + * + * @return set of {@link Component} classes + */ + public Set<Class<? extends Component>> componentTypes() { + return componentMap.keySet(); + } +} diff --git a/core/src/main/java/coffee/liz/ecs/model/Query.java b/core/src/main/java/coffee/liz/ecs/model/Query.java new file mode 100644 index 0000000..679ea49 --- /dev/null +++ b/core/src/main/java/coffee/liz/ecs/model/Query.java @@ -0,0 +1,30 @@ +package coffee.liz.ecs.model; + +import java.util.Arrays; +import java.util.Set; +import java.util.stream.Collectors; + +public record Query(Set<Class<? extends Component>> queryingComponents, QueryFilter filter) { + public Query { + queryingComponents = Set.copyOf(queryingComponents); + } + + @SafeVarargs + public static Query allOf(final Class<? extends Component>... components) { + return new Query(Arrays.stream(components).collect(Collectors.toSet()), QueryFilter.ALL_OF); + } + + @SafeVarargs + public static Query anyOf(final Class<? extends Component>... components) { + return new Query(Arrays.stream(components).collect(Collectors.toSet()), QueryFilter.ANY_OF); + } + + @SafeVarargs + public static Query noneOf(final Class<? extends Component>... components) { + return new Query(Arrays.stream(components).collect(Collectors.toSet()), QueryFilter.NONE_OF); + } + + public enum QueryFilter { + ALL_OF, ANY_OF, NONE_OF + } +} diff --git a/core/src/main/java/coffee/liz/ecs/model/QueryBuilder.java b/core/src/main/java/coffee/liz/ecs/model/QueryBuilder.java new file mode 100644 index 0000000..eba5021 --- /dev/null +++ b/core/src/main/java/coffee/liz/ecs/model/QueryBuilder.java @@ -0,0 +1,25 @@ +package coffee.liz.ecs.model; + +import lombok.RequiredArgsConstructor; + +import java.util.Set; + +@RequiredArgsConstructor +public class QueryBuilder<T> { + private final World<T> world; + + @SafeVarargs + public final Set<Entity> allOf(final Class<? extends Component>... components) { + return world.resolve(Query.allOf(components)); + } + + @SafeVarargs + public final Set<Entity> anyOf(final Class<? extends Component>... components) { + return world.resolve(Query.anyOf(components)); + } + + @SafeVarargs + public final Set<Entity> noneOf(final Class<? extends Component>... components) { + return world.resolve(Query.noneOf(components)); + } +} diff --git a/core/src/main/java/coffee/liz/ecs/model/System.java b/core/src/main/java/coffee/liz/ecs/model/System.java new file mode 100644 index 0000000..c00334a --- /dev/null +++ b/core/src/main/java/coffee/liz/ecs/model/System.java @@ -0,0 +1,32 @@ +package coffee.liz.ecs.model; + +import java.time.Duration; +import java.util.Collection; + +/** + * Updates the {@link World} state. + * + * @param <T> + * is the state of the stuff outside the {@link World}. + */ +public interface System<T> { + /** + * {@link System} clazzes that must run before this system. + * + * @return {@link Collection} of dependencies. + */ + Collection<Class<? extends System<T>>> getDependencies(); + + /** + * @param world + * Is the {@link World}. + * @param state + * Is the {@link T} state outside the {@param world}. + * @param deltaSeconds + * Is the timestamp. + */ + void update(final World<T> world, final T state, final float deltaSeconds); + + default void dispose() { + } +} diff --git a/core/src/main/java/coffee/liz/ecs/model/World.java b/core/src/main/java/coffee/liz/ecs/model/World.java new file mode 100644 index 0000000..82e01a7 --- /dev/null +++ b/core/src/main/java/coffee/liz/ecs/model/World.java @@ -0,0 +1,64 @@ +package coffee.liz.ecs.model; + +import java.time.Duration; +import java.util.Set; + +/** + * The game world. + * + * @param <T> + * is the state of the stuff outside the world. + */ +public interface World<T> { + /** + * Create unique {@link Entity} in the {@link World}. + * + * @return created {@link Entity}. + */ + Entity createEntity(); + + /** + * Remove an entity from the {@link World}. + * + * @param entity + * to remove. + */ + void removeEntity(final Entity entity); + + /** + * Get entities with {@link Component}s. + * + * @param query + * to query. + * @return All entities satisfying {@param query}. + */ + Set<Entity> resolve(final Query query); + + default QueryBuilder<T> queryable() { + return new QueryBuilder<>(this); + } + + /** + * Integrate the {@link World}. + * + * @param state + * Is the state outside the world. + * @param deltaSeconds + * Is the time step. + */ + void update(T state, float deltaSeconds); + + /** + * Get world {@link System}. + * + * @param system + * is the Clazz. + * @param <S> + * is the {@link System} type. + * @return {@link System} instance of {@param system}. + */ + <S extends System<T>> S getSystem(final Class<S> system); + + default void dispose() { + } +} diff --git a/core/src/main/java/coffee/liz/ecs/utils/FunctionUtils.java b/core/src/main/java/coffee/liz/ecs/utils/FunctionUtils.java new file mode 100644 index 0000000..25e81f0 --- /dev/null +++ b/core/src/main/java/coffee/liz/ecs/utils/FunctionUtils.java @@ -0,0 +1,28 @@ +package coffee.liz.ecs.utils; + + +public final class FunctionUtils { + /** + * Runs the provided action and wraps failures into a {@link RuntimeException}. + * + * @param run + * action to execute + */ + public static <E extends Throwable> void wrapCheckedException(final ThrowableRunnable<E> run) { + try { + run.run(); + } catch (final Throwable e) { + throw new RuntimeException(e); + } + } + + @FunctionalInterface + public interface ThrowableRunnable<E extends Throwable> { + /** + * Run. + */ + void run() throws E; + } + + private FunctionUtils() { } +} |