create digging right and digging left states (#379)

* create digging right and digging left states

* put controller on solid blocks in generation

* use digging on left and right

* add digging left and right

* digging is now transparent

* server fire incoming attribute events

* entity controller are set in factories

* attack state last longer and ai uses punch left

* attempt transition doesnt change if already in that state

core/src/core/app/game/GameController.java

@@ -156,7 +156,6 @@ public WaterPosition createWaterPosition(Coordinates coordinates) throws ChunkNo
 
   public Water createWater(Coordinates coordinates) throws ChunkNotFound {
     Water entity = entityFactory.createWater(coordinates.getBase());
-    entity.setEntityController(entityControllerFactory.createWaterController(entity));
 
     // internal event
     eventService.queuePostUpdateEvent(EventTypeFactory.createCreateEntityEventType(entity));

core/src/core/app/screen/assets/animations/AnimationState.java

@@ -8,4 +8,6 @@ public enum AnimationState {
   FALLING,
   PUNCH_LEFT,
   PUNCH_RIGHT,
+  DIGGING_LEFT,
+  DIGGING_RIGHT,
 }

core/src/core/app/screen/assets/animations/GameAnimationFactory.java

@@ -102,6 +102,7 @@ GameAnimation createEntityAnimation() {
       }
     }
 
+    // punch left
     TextureRegion[] punchFramesLeft = new TextureRegion[27];
     for (int i = 0; i < 27; i++) {
       if (i < 10)
@@ -112,6 +113,7 @@ GameAnimation createEntityAnimation() {
             new TextureRegion(new Texture(Gdx.files.internal("punch/punch_00" + i + ".png")));
     }
 
+    // punch right
     TextureRegion[] punchFramesRight = new TextureRegion[27];
     for (int i = 0; i < 27; i++) {
       if (i < 10)
@@ -124,6 +126,30 @@ GameAnimation createEntityAnimation() {
       punchFramesRight[i].flip(true, false);
     }
 
+    // Dig Left
+    TextureRegion[] digFramesLeft = new TextureRegion[17];
+    for (int i = 0; i < 17; i++) {
+      if (i < 10)
+        digFramesLeft[i] =
+            new TextureRegion(new Texture(Gdx.files.internal("pickaxe/pickaxe_000" + i + ".png")));
+      else
+        digFramesLeft[i] =
+            new TextureRegion(new Texture(Gdx.files.internal("pickaxe/pickaxe_00" + i + ".png")));
+    }
+
+    // Dig Right
+    TextureRegion[] digFramesRight = new TextureRegion[17];
+    for (int i = 0; i < 17; i++) {
+      if (i < 10)
+        digFramesRight[i] =
+            new TextureRegion(new Texture(Gdx.files.internal("pickaxe/pickaxe_000" + i + ".png")));
+      else
+        digFramesRight[i] =
+            new TextureRegion(new Texture(Gdx.files.internal("pickaxe/pickaxe_00" + i + ".png")));
+
+      digFramesRight[i].flip(true, false);
+    }
+
     return new GameAnimationBuilder()
         .addAnimation(AnimationState.DEFAULT, new Animation<TextureRegion>(0.25f, defaultFrames))
         .addAnimation(
@@ -134,6 +160,10 @@ GameAnimation createEntityAnimation() {
             AnimationState.PUNCH_LEFT, new Animation<TextureRegion>(0.05f, punchFramesLeft))
         .addAnimation(
             AnimationState.PUNCH_RIGHT, new Animation<TextureRegion>(0.05f, punchFramesRight))
+        .addAnimation(
+            AnimationState.DIGGING_LEFT, new Animation<TextureRegion>(0.05f, digFramesLeft))
+        .addAnimation(
+            AnimationState.DIGGING_RIGHT, new Animation<TextureRegion>(0.05f, digFramesRight))
         .build();
   }
 

core/src/core/entity/EntityFactory.java

@@ -5,6 +5,7 @@
 import core.chunk.world.EntityBodyBuilder;
 import core.common.Clock;
 import core.common.Coordinates;
+import core.entity.controllers.factories.EntityControllerFactory;
 import core.entity.misc.Ladder;
 import core.entity.misc.Orb;
 import core.entity.misc.Projectile;
@@ -20,6 +21,7 @@ public class EntityFactory {
   @Inject BaseAssetManager baseAssetManager;
   @Inject EntityBodyBuilder entityBodyBuilder;
   @Inject EntityStateMachineFactory entityStateMachineFactory;
+  @Inject EntityControllerFactory entityControllerFactory;
 
   @Inject
   EntityFactory() {}
@@ -41,27 +43,33 @@ public Projectile createProjectile(Coordinates coordinates) {
 
   public Turret createTurret(Coordinates coordinates) {
     Turret turret = new Turret(clock, baseAssetManager, entityBodyBuilder, coordinates);
+    turret.setEntityController(entityControllerFactory.createTurretController(turret));
     return turret;
   }
 
   public Orb createOrb(Coordinates coordinates) {
     Orb orb = new Orb(clock, baseAssetManager, entityBodyBuilder, coordinates);
+    orb.setEntityController(entityControllerFactory.createOrbController(orb));
     return orb;
   }
 
   public WaterPosition createWaterPosition(Coordinates coordinates) {
     WaterPosition waterPosition =
         new WaterPosition(clock, baseAssetManager, entityBodyBuilder, coordinates);
+    waterPosition.setEntityController(
+        entityControllerFactory.createWaterPositionController(waterPosition));
     return waterPosition;
   }
 
   public Water createWater(Coordinates coordinates) {
     Water water = new Water(clock, baseAssetManager, entityBodyBuilder, coordinates);
+    water.setEntityController(entityControllerFactory.createWaterController(water));
     return water;
   }
 
   public Sand createSand(Coordinates coordinates) {
     Sand sand = new Sand(clock, baseAssetManager, entityBodyBuilder, coordinates);
+    sand.setEntityController(entityControllerFactory.createSandController(sand));
     return sand;
   }
 }

core/src/core/entity/block/BlockFactory.java

@@ -5,21 +5,25 @@
 import core.chunk.world.EntityBodyBuilder;
 import core.common.Clock;
 import core.common.Coordinates;
+import core.entity.controllers.factories.EntityControllerFactory;
 
 public class BlockFactory {
   @Inject Clock clock;
   @Inject BaseAssetManager baseAssetManager;
   @Inject EntityBodyBuilder entityBodyBuilder;
+  @Inject EntityControllerFactory entityControllerFactory;
 
   BlockFactory() {}
 
   public DirtBlock createDirt(Coordinates coordinates) {
     DirtBlock block = new DirtBlock(clock, baseAssetManager, entityBodyBuilder, coordinates);
+    block.setEntityController(entityControllerFactory.createSolidBlockController(block));
     return block;
   }
 
   public StoneBlock createStone(Coordinates coordinates) {
     StoneBlock stoneBlock = new StoneBlock(clock, baseAssetManager, entityBodyBuilder, coordinates);
+    stoneBlock.setEntityController(entityControllerFactory.createSolidBlockController(stoneBlock));
     return stoneBlock;
   }
 

core/src/core/entity/controllers/EntityPathController.java

@@ -1,6 +1,7 @@
 package core.entity.controllers;
 
 import core.app.game.GameController;
+import core.app.screen.assets.animations.AnimationState;
 import core.common.Coordinates;
 import core.common.GameStore;
 import core.common.events.EventService;
@@ -65,7 +66,7 @@ public void beforeWorldUpdate() {
             .getBase()
             .calcDistance(target.getCoordinatesWrapper().getCoordinates())
         < 2) {
-      gameController.useItem(entity);
+      entity.getEntityStateMachine().attemptTransition(AnimationState.PUNCH_LEFT);
     }
     try {
       this.pathGuider.followPath(target.getCoordinatesWrapper().getCoordinates());

core/src/core/entity/controllers/EntityUserController.java

@@ -43,9 +43,11 @@ public void beforeWorldUpdate() throws EntityNotFound, ChunkNotFound, BodyNotFou
     }
     if (Gdx.input.isKeyPressed(Input.Keys.SPACE)) {
       if (Gdx.input.isKeyPressed(Input.Keys.A)) {
-        this.gameController.placeBlock(this.entity, Direction.LEFT, Optional.empty());
+        //        this.gameController.placeBlock(this.entity, Direction.LEFT, Optional.empty());
+        entity.getEntityStateMachine().attemptTransition(AnimationState.DIGGING_LEFT);
       } else if (Gdx.input.isKeyPressed(Input.Keys.D)) {
-        this.gameController.placeBlock(this.entity, Direction.RIGHT, Optional.empty());
+        entity.getEntityStateMachine().attemptTransition(AnimationState.DIGGING_RIGHT);
+        //        this.gameController.placeBlock(this.entity, Direction.RIGHT, Optional.empty());
       } else if (Gdx.input.isKeyPressed(Input.Keys.S)) {
         this.gameController.placeBlock(this.entity, Direction.DOWN, Optional.empty());
       } else if (Gdx.input.isKeyPressed(Input.Keys.W)) {

core/src/core/entity/controllers/SolidBlockController.java

@@ -0,0 +1,27 @@
+package core.entity.controllers;
+
+import core.app.game.GameController;
+import core.common.GameStore;
+import core.common.events.EventService;
+import core.entity.Entity;
+import core.entity.controllers.actions.EntityActionFactory;
+import core.networking.events.EventTypeFactory;
+
+public class SolidBlockController extends EntityController {
+
+  public SolidBlockController(
+      GameController gameController,
+      GameStore gameStore,
+      EntityActionFactory entityActionFactory,
+      EventService eventService,
+      EventTypeFactory eventTypeFactory,
+      Entity entity) {
+    super(gameController, gameStore, entityActionFactory, eventService, eventTypeFactory, entity);
+  }
+
+  @Override
+  public void beforeWorldUpdate() throws Exception {}
+
+  @Override
+  public void afterWorldUpdate() throws Exception {}
+}

core/src/core/entity/controllers/factories/BaseEntityControllerFactory.java

@@ -26,6 +26,18 @@ public EntityController createEntityPathController(Entity source, Entity target)
         .registerEntityEventConsumer(ChangeHealthEventType.type, changeHealthConsumer);
   }
 
+  @Override
+  public EntityController createSolidBlockController(Entity entity) {
+    return super.createSolidBlockController(entity)
+        .registerEntityEventConsumer(ChangeHealthEventType.type, changeHealthConsumer);
+  }
+
+  @Override
+  public EntityController createSandController(Entity entity) {
+    return super.createSandController(entity)
+        .registerEntityEventConsumer(ChangeHealthEventType.type, changeHealthConsumer);
+  }
+
   @Override
   public EntityController createRemoteBodyController(Entity entity) {
     return super.createRemoteBodyController(entity)

core/src/core/entity/controllers/factories/EntityControllerFactory.java

@@ -18,6 +18,7 @@
 import core.entity.controllers.ProjectileController;
 import core.entity.controllers.RemoteBodyController;
 import core.entity.controllers.SandController;
+import core.entity.controllers.SolidBlockController;
 import core.entity.controllers.TurretController;
 import core.entity.controllers.WaterController;
 import core.entity.controllers.WaterPositionController;
@@ -136,4 +137,9 @@ public EntityController createSandController(Entity entity) {
     return new SandController(
         gameController, gameStore, entityActionFactory, eventService, eventTypeFactory, entity);
   }
+
+  public EntityController createSolidBlockController(Entity entity) {
+    return new SolidBlockController(
+        gameController, gameStore, entityActionFactory, eventService, eventTypeFactory, entity);
+  }
 }

core/src/core/entity/controllers/factories/ServerEntityControllerFactory.java

@@ -32,4 +32,16 @@ public EntityController createRemoteBodyController(Entity entity) {
         .registerEntityEventConsumer(FallDamageEventType.type, fallDamageConsumer)
         .registerEntityEventConsumer(ChangeHealthEventType.type, changeHealthConsumer);
   }
+
+  @Override
+  public EntityController createSolidBlockController(Entity entity) {
+    return super.createSolidBlockController(entity)
+        .registerEntityEventConsumer(ChangeHealthEventType.type, changeHealthConsumer);
+  }
+
+  @Override
+  public EntityController createSandController(Entity entity) {
+    return super.createSandController(entity)
+        .registerEntityEventConsumer(ChangeHealthEventType.type, changeHealthConsumer);
+  }
 }

core/src/core/entity/statemachine/EntityStateMachine.java

@@ -24,10 +24,12 @@ public EntityStateMachine(
 
   public void attemptTransition(AnimationState transition) {
     Set<AnimationState> possibleTransitions = transitions.get(currentState);
+
     if (possibleTransitions == null) return;
-    if (possibleTransitions.contains(transition)) {
-      this.setState(transition);
-    }
+    if (currentState.equals(transition)) return;
+    if (!possibleTransitions.contains(transition)) return;
+
+    this.setState(transition);
   }
 
   public void setState(AnimationState transition) {

core/src/core/entity/statemachine/EntityStateMachineFactory.java

@@ -6,6 +6,8 @@
 import core.entity.Entity;
 import core.entity.statemachine.states.DefaultItemState;
 import core.entity.statemachine.states.DefaultState;
+import core.entity.statemachine.states.DiggingLeftState;
+import core.entity.statemachine.states.DiggingRightState;
 import core.entity.statemachine.states.JumpState;
 import core.entity.statemachine.states.LeftWalkingState;
 import core.entity.statemachine.states.RightWalkingState;
@@ -19,6 +21,8 @@ public class EntityStateMachineFactory {
   @Inject LeftWalkingState leftWalkingState;
   @Inject RightWalkingState rightWalkingState;
   @Inject JumpState jumpState;
+  @Inject DiggingLeftState diggingLeftState;
+  @Inject DiggingRightState diggingRightState;
 
   public EntityStateMachine createEntityStateMachine(Entity entity) {
 
@@ -29,6 +33,8 @@ public EntityStateMachine createEntityStateMachine(Entity entity) {
     stateToNode.put(AnimationState.WALKING_LEFT, leftWalkingState);
     stateToNode.put(AnimationState.WALKING_RIGHT, rightWalkingState);
     stateToNode.put(AnimationState.JUMPING, jumpState);
+    stateToNode.put(AnimationState.DIGGING_LEFT, diggingLeftState);
+    stateToNode.put(AnimationState.DIGGING_RIGHT, diggingRightState);
 
     Map<AnimationState, Set<AnimationState>> transitions = new HashMap<>();
 
@@ -39,14 +45,18 @@ public EntityStateMachine createEntityStateMachine(Entity entity) {
             AnimationState.PUNCH_RIGHT,
             AnimationState.WALKING_LEFT,
             AnimationState.WALKING_RIGHT,
-            AnimationState.JUMPING);
+            AnimationState.JUMPING,
+            AnimationState.DIGGING_LEFT,
+            AnimationState.DIGGING_RIGHT);
 
     transitions.put(AnimationState.DEFAULT, allStates);
     transitions.put(AnimationState.WALKING_LEFT, allStates);
     transitions.put(AnimationState.WALKING_RIGHT, allStates);
     transitions.put(AnimationState.JUMPING, allStates);
     transitions.put(AnimationState.PUNCH_LEFT, Sets.newHashSet());
     transitions.put(AnimationState.PUNCH_RIGHT, Sets.newHashSet());
+    transitions.put(AnimationState.DIGGING_LEFT, Sets.newHashSet());
+    transitions.put(AnimationState.DIGGING_RIGHT, Sets.newHashSet());
 
     return new EntityStateMachine(entity, transitions, stateToNode);
   }

core/src/core/entity/statemachine/states/DefaultItemState.java

@@ -31,6 +31,9 @@ public void callAnimation(Entity entity) {
   public void callAction(Entity entity, long timeInState) {
     if (timeInState > 150) {
       gameController.useItem(entity);
+    }
+
+    if (timeInState > 500) {
       entity.getEntityStateMachine().setState(AnimationState.DEFAULT);
     }
   }

core/src/core/entity/statemachine/states/DiggingLeftState.java

@@ -0,0 +1,61 @@
+package core.entity.statemachine.states;
+
+import com.google.inject.Inject;
+import core.app.screen.assets.animations.AnimationState;
+import core.common.Coordinates;
+import core.common.exceptions.EntityNotFound;
+import core.entity.Entity;
+import core.entity.attributes.msc.AnimationStateWrapper;
+import core.entity.attributes.msc.Health;
+import core.entity.block.Block;
+import core.entity.block.SolidBlock;
+import core.entity.collision.RayCastService;
+import core.entity.statemachine.EntityStateMachineNodeInterface;
+import java.util.Set;
+
+public class DiggingLeftState extends EntityStateMachineNodeInterface {
+
+  @Inject RayCastService rayCastService;
+
+  @Override
+  public void callAnimation(Entity entity) {
+    if (!entity
+        .getAnimationStateWrapper()
+        .getAnimationState()
+        .equals(AnimationState.DIGGING_LEFT)) {
+      try {
+        gameController.updateEntityAttribute(
+            entity.getUuid(), new AnimationStateWrapper(AnimationState.DIGGING_LEFT));
+      } catch (EntityNotFound e) {
+        e.printStackTrace();
+      }
+    }
+  }
+
+  @Override
+  public void callAction(Entity entity, long timeInState) {
+
+    if (timeInState < 350) return;
+    else entity.getEntityStateMachine().setState(AnimationState.DEFAULT);
+
+    // after time
+
+    Coordinates entityCoordinates = entity.getCoordinatesWrapper().getCoordinates();
+    Coordinates targetCoordinates = entityCoordinates.add(-1, 0);
+
+    Set<Entity> rayCastSet = rayCastService.rayCast(entityCoordinates, targetCoordinates);
+
+    Block targetBlock =
+        (Block) (rayCastSet.stream().filter(e -> e instanceof SolidBlock).findAny()).orElse(null);
+
+    if (targetBlock == null) return;
+
+    Health newHealth = targetBlock.getHealth().applyDiff(-50);
+
+    try {
+      gameController.updateEntityAttribute(targetBlock.getUuid(), newHealth);
+    } catch (EntityNotFound e) {
+      e.printStackTrace();
+    }
+  }
+}