Support for Fixed Facing Direction Independent of Movement Direction

[zbrongyaozb]

Can Grid Engine support a fixed facing direction feature? For example, allowing a player to face forward while moving backward.
In Grid Engine, facing direction seems strongly coupled with movement direction. To achieve this, I have to force set walkingAnimationMapping, which works but becomes cumbersome to manage when the fixed facing direction needs to change dynamically—frequent updates to walkingAnimationMapping are required.

[Annoraaq]

If it is only about the animation I suggest to use custom animations and disable animations in Grid Engine. The only other impact the facing direction has should be https://annoraaq.github.io/grid-engine/api/classes/GridEngineHeadless.html#getfacingposition. Or is there any logic besides the animation that would benefit from this?

[zbrongyaozb]

Hi @Annoraaq ,

Thank you for the suggestion! I understand that using custom animations and disabling the built-in animation system is a possible workaround. However, my concern is not just about the visual representation, but rather the consistency of the engine's internal state.

If I move backward while wanting to face forward, and only "fix" it by overriding animations:

1. Internal Logic Mismatch: Grid Engine's internal facingDirection still updates to the movement direction. This makes methods like getFacingPosition() or getFacingDirection() unreliable for other game logic, such as interacting with NPCs or detecting objects in front of the character.
2. State Management Overhead: I currently have to maintain an external state (via NgRx) to track the "true" logical direction and manually force the sprite frames, which feels like fighting against the engine's core movement logic.

As shown in my implementation from #534 , I have to bypass Grid Engine's state to keep the character looking in the correct direction:

registerStepAnim() {
    const eventState = this.runtimeEvent.eventStore;
    const stepSpeed = (1000 / 60) * (((9 - this.page.moveSpeed) * 3) / 1);

    merge(
      this.gridEngine.movementStarted(),
      this.gridEngine.movementStopped(),
      this.gridEngine.directionChanged()
    )
      .pipe(
        filter((j) => j.charId === this.charId),
        startWith({ 
          charId: this.charId, 
          direction: getGridEngineDirection(eventState.direction()) 
        }),
        map(() => {
          return { 
            isMoving: this.gridEngine.isMoving(this.charId), 
            // Note: I have to pull the "true" logical direction from an external store
            // because Grid Engine's internal direction automatically changes with movement
            direction: getGridEngineDirection(eventState.direction()) 
          };
        }),
        distinctUntilChanged((a, b) => 
          a.isMoving === b.isMoving && a.direction === b.direction
        ),
      )
      .subscribe(({ isMoving, direction }) => {
        const startFrame = GEFrameUtils.getStartFrameForCharIndex(
          direction, 
          this.page.image.characterIndex, 
          this.charsInRow!
        );
        
        if (isMoving) {
          if (this.stepAnim) {
            this.stepAnim.remove();
            this.stepAnim = null;
          }
        } else {
          if (this.stepAnim) this.stepAnim.remove();
          
          this.stepAnim = this.scene.time.addEvent({
            delay: stepSpeed,
            loop: true,
            callback: () => {
              this.pattern++;
              if (this.pattern > 2) this.pattern = 0;
              this.sprite.setFrame(startFrame + this.pattern);
            },
          });
        }
      });
  }

Proposal

Instead of just disabling animations, would it be possible to introduce a feature like a fixedFacing flag?

This would allow a character to move in any direction without updating the internal facingDirection property. This ensures that:

• The logical orientation remains consistent for getFacingPosition().
• The correct walking animations are played naturally based on that fixed orientation.
• It supports "strafing" or "backpedaling" mechanics common in RPGs without complex external state syncing.

What do you think about decoupling the facing direction from the movement direction in this way?

[Annoraaq]

I think the proposed solution (fixedFacing or similar) is a good idea.