peterstockings/rogue
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

changed visual movement speed to be slower and made diagonal movement with arrow keys work

Browse Source
This commit is contained in:
Kyle Banicevic
2026-01-28 18:59:35 +11:00
parent f01d8de15c
commit 80e82f68a0
6 changed files with 185 additions and 142 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/core/config/GameConfig.ts
View File

@@ -130,11 +130,12 @@ export const GAME_CONFIG = {
horizontal: 54, horizontal: 54,
vertical: 55, vertical: 55,
turning: 56 turning: 56
} },
moveDuration: 62 // Visual duration for movement in ms
}, },
ui: { ui: {
// ... rest of content ... // ... rest of content ...
minimapPanelWidth: 340, minimapPanelWidth: 340,
minimapPanelHeight: 220, minimapPanelHeight: 220,
minimapPadding: 20, minimapPadding: 20,

24
src/engine/input/GameInput.ts
View File

@@ -80,12 +80,12 @@ export class GameInput extends Phaser.Events.EventEmitter {
const isShiftDrag = p.isDown && p.event.shiftKey; const isShiftDrag = p.isDown && p.event.shiftKey;
if (isRightDrag || isMiddleDrag || isShiftDrag) { if (isRightDrag || isMiddleDrag || isShiftDrag) {
const { x, y } = p.position; const { x, y } = p.position;
const { x: prevX, y: prevY } = p.prevPosition; const { x: prevX, y: prevY } = p.prevPosition;
const dx = (x - prevX); // Zoom factor needs to be handled by receiver or passed here const dx = (x - prevX); // Zoom factor needs to be handled by receiver or passed here
const dy = (y - prevY); const dy = (y - prevY);
this.emit("pan", dx, dy); this.emit("pan", dx, dy);
} }
} }
}); });
@@ -107,11 +107,17 @@ export class GameInput extends Phaser.Events.EventEmitter {
if (down) dy += 1; if (down) dy += 1;
const anyJustDown = Phaser.Input.Keyboard.JustDown(this.cursors.left!) || const anyJustDown = Phaser.Input.Keyboard.JustDown(this.cursors.left!) ||
Phaser.Input.Keyboard.JustDown(this.cursors.right!) || Phaser.Input.Keyboard.JustDown(this.cursors.right!) ||
Phaser.Input.Keyboard.JustDown(this.cursors.up!) || Phaser.Input.Keyboard.JustDown(this.cursors.up!) ||
Phaser.Input.Keyboard.JustDown(this.cursors.down!); Phaser.Input.Keyboard.JustDown(this.cursors.down!);
return { dx, dy, anyJustDown }; return {
dx, dy, anyJustDown,
isLeft: !!left,
isRight: !!right,
isUp: !!up,
isDown: !!down
};
} }
public cleanup() { public cleanup() {

4
src/engine/world/pathfinding.ts
View File

@@ -49,8 +49,8 @@ export function findPathAStar(
return true; return true;
}; };
// Use rot-js A* pathfinding with 4-directional topology // Use rot-js A* pathfinding with 8-directional topology
const astar = new ROT.Path.AStar(end.x, end.y, passableCallback, { topology: 4 }); const astar = new ROT.Path.AStar(end.x, end.y, passableCallback, { topology: 8 });
const path: Vec2[] = []; const path: Vec2[] = [];

160
src/rendering/DungeonRenderer.ts
View File

@@ -143,7 +143,7 @@ export class DungeonRenderer {
computeFov() { computeFov() {
const player = this.entityAccessor.getPlayer(); const player = this.entityAccessor.getPlayer();
if (player && player.category === "combatant") { if (player && player.category === "combatant") {
this.fovManager.compute(this.world, player.pos); this.fovManager.compute(this.world, player.pos);
} }
} }
@@ -152,9 +152,9 @@ export class DungeonRenderer {
} }
updateTile(x: number, y: number) { updateTile(x: number, y: number) {
if (!this.map || !this.world) return; if (!this.map || !this.world) return;
const t = this.world.tiles[idx(this.world, x, y)]; const t = this.world.tiles[idx(this.world, x, y)];
this.map.putTileAt(t, x, y); this.map.putTileAt(t, x, y);
} }
get seenArray() { get seenArray() {
@@ -243,14 +243,14 @@ export class DungeonRenderer {
const ty = a.pos.y * TILE_SIZE + TILE_SIZE / 2; const ty = a.pos.y * TILE_SIZE + TILE_SIZE / 2;
if (this.playerSprite.x !== tx || this.playerSprite.y !== ty) { if (this.playerSprite.x !== tx || this.playerSprite.y !== ty) {
this.scene.tweens.add({ this.scene.tweens.add({
targets: this.playerSprite, targets: this.playerSprite,
x: tx, x: tx,
y: ty, y: ty,
duration: 120, duration: GAME_CONFIG.rendering.moveDuration,
ease: 'Quad.easeOut', ease: 'Quad.easeOut',
overwrite: true overwrite: true
}); });
} }
this.playerSprite.setVisible(true); this.playerSprite.setVisible(true);
} }
@@ -274,22 +274,22 @@ export class DungeonRenderer {
this.enemySprites.set(a.id, sprite); this.enemySprites.set(a.id, sprite);
sprite.setVisible(true); sprite.setVisible(true);
} else { } else {
if (!sprite.visible) { if (!sprite.visible) {
// If it was hidden, snap to new position immediately // If it was hidden, snap to new position immediately
this.scene.tweens.killTweensOf(sprite); this.scene.tweens.killTweensOf(sprite);
sprite.setPosition(tx, ty); sprite.setPosition(tx, ty);
sprite.setVisible(true); sprite.setVisible(true);
} else if (sprite.x !== tx || sprite.y !== ty) { } else if (sprite.x !== tx || sprite.y !== ty) {
// Only tween if it was already visible and moved // Only tween if it was already visible and moved
this.scene.tweens.add({ this.scene.tweens.add({
targets: sprite, targets: sprite,
x: tx, x: tx,
y: ty, y: ty,
duration: 120, duration: GAME_CONFIG.rendering.moveDuration,
ease: 'Quad.easeOut', ease: 'Quad.easeOut',
overwrite: true overwrite: true
}); });
} }
} }
} else if (a.category === "collectible") { } else if (a.category === "collectible") {
@@ -308,23 +308,23 @@ export class DungeonRenderer {
orb.setVisible(true); orb.setVisible(true);
} }
} else if (a.category === "item_drop") { } else if (a.category === "item_drop") {
if (!isVis) continue; if (!isVis) continue;
activeItemIds.add(a.id); activeItemIds.add(a.id);
let itemContainer = this.itemSprites.get(a.id); let itemContainer = this.itemSprites.get(a.id);
if (!itemContainer) { if (!itemContainer) {
// Use ItemSpriteFactory to create sprite with optional glow // Use ItemSpriteFactory to create sprite with optional glow
itemContainer = ItemSpriteFactory.createItemSprite(this.scene, a.item, 0, 0, 1); itemContainer = ItemSpriteFactory.createItemSprite(this.scene, a.item, 0, 0, 1);
itemContainer.setDepth(40); itemContainer.setDepth(40);
this.itemSprites.set(a.id, itemContainer); this.itemSprites.set(a.id, itemContainer);
} }
const tx = a.pos.x * TILE_SIZE + TILE_SIZE / 2; const tx = a.pos.x * TILE_SIZE + TILE_SIZE / 2;
const ty = a.pos.y * TILE_SIZE + TILE_SIZE / 2; const ty = a.pos.y * TILE_SIZE + TILE_SIZE / 2;
itemContainer.setPosition(tx, ty); itemContainer.setPosition(tx, ty);
itemContainer.setVisible(true); itemContainer.setVisible(true);
// bobbing effect on the container // bobbing effect on the container
itemContainer.y += Math.sin(this.scene.time.now / 300) * 2; itemContainer.y += Math.sin(this.scene.time.now / 300) * 2;
} }
} }
@@ -350,13 +350,13 @@ export class DungeonRenderer {
} }
for (const [id, item] of this.itemSprites.entries()) { for (const [id, item] of this.itemSprites.entries()) {
if (!activeItemIds.has(id)) { if (!activeItemIds.has(id)) {
item.setVisible(false); item.setVisible(false);
if (!this.entityAccessor.hasActor(id)) { if (!this.entityAccessor.hasActor(id)) {
item.destroy(); item.destroy();
this.itemSprites.delete(id); this.itemSprites.delete(id);
}
} }
}
} }
this.minimapRenderer.render(this.world, seen, visible, this.entityAccessor); this.minimapRenderer.render(this.world, seen, visible, this.entityAccessor);
@@ -405,44 +405,44 @@ export class DungeonRenderer {
} }
showProjectile(from: Vec2, to: Vec2, itemId: string, onComplete: () => void) { showProjectile(from: Vec2, to: Vec2, itemId: string, onComplete: () => void) {
// World coords // World coords
const startX = from.x * TILE_SIZE + TILE_SIZE / 2; const startX = from.x * TILE_SIZE + TILE_SIZE / 2;
const startY = from.y * TILE_SIZE + TILE_SIZE / 2; const startY = from.y * TILE_SIZE + TILE_SIZE / 2;
const endX = to.x * TILE_SIZE + TILE_SIZE / 2; const endX = to.x * TILE_SIZE + TILE_SIZE / 2;
const endY = to.y * TILE_SIZE + TILE_SIZE / 2; const endY = to.y * TILE_SIZE + TILE_SIZE / 2;
// Create sprite // Create sprite
// Look up sprite index from config // Look up sprite index from config
const itemConfig = ALL_TEMPLATES[itemId as keyof typeof ALL_TEMPLATES]; const itemConfig = ALL_TEMPLATES[itemId as keyof typeof ALL_TEMPLATES];
const texture = itemConfig?.textureKey ?? "items"; const texture = itemConfig?.textureKey ?? "items";
const frame = itemConfig?.spriteIndex ?? 0; const frame = itemConfig?.spriteIndex ?? 0;
// Use 'items' spritesheet // Use 'items' spritesheet
const sprite = this.scene.add.sprite(startX, startY, texture, frame); const sprite = this.scene.add.sprite(startX, startY, texture, frame);
sprite.setDepth(2000); sprite.setDepth(2000);
// Rotate? // Rotate?
const angle = Phaser.Math.Angle.Between(startX, startY, endX, endY); const angle = Phaser.Math.Angle.Between(startX, startY, endX, endY);
sprite.setRotation(angle + Math.PI / 4); // Adjust for sprite orientation (diagonal usually) sprite.setRotation(angle + Math.PI / 4); // Adjust for sprite orientation (diagonal usually)
const dist = Phaser.Math.Distance.Between(startX, startY, endX, endY); const dist = Phaser.Math.Distance.Between(startX, startY, endX, endY);
const duration = dist * 2; // speed const duration = dist * 2; // speed
this.scene.tweens.add({ this.scene.tweens.add({
targets: sprite, targets: sprite,
x: endX, x: endX,
y: endY, y: endY,
rotation: sprite.rotation + 4 * Math.PI, // Spin effect rotation: sprite.rotation + 4 * Math.PI, // Spin effect
duration: duration, duration: duration,
ease: 'Linear', ease: 'Linear',
onComplete: () => { onComplete: () => {
sprite.destroy(); sprite.destroy();
onComplete(); onComplete();
} }
}); });
} }
shakeCamera() { shakeCamera() {
this.scene.cameras.main.shake(100, 0.01); this.scene.cameras.main.shake(100, 0.01);
} }
} }

16
src/scenes/GameScene.ts
View File

@@ -51,6 +51,7 @@ export class GameScene extends Phaser.Scene {
public playerPath: Vec2[] = []; public playerPath: Vec2[] = [];
public awaitingPlayer = false; public awaitingPlayer = false;
private lastMoveTime = 0;
// Sub-systems // Sub-systems
public dungeonRenderer!: DungeonRenderer; public dungeonRenderer!: DungeonRenderer;
@@ -138,7 +139,7 @@ export class GameScene extends Phaser.Scene {
const dx = next.x - player.pos.x; const dx = next.x - player.pos.x;
const dy = next.y - player.pos.y; const dy = next.y - player.pos.y;
if (Math.abs(dx) + Math.abs(dy) !== 1) { if (Math.max(Math.abs(dx), Math.abs(dy)) !== 1) {
this.playerPath = []; this.playerPath = [];
return; return;
} }
@@ -156,7 +157,12 @@ export class GameScene extends Phaser.Scene {
} }
} }
if (this.time.now - this.lastMoveTime < GAME_CONFIG.rendering.moveDuration) {
return;
}
this.commitPlayerAction({ type: "move", dx, dy }); this.commitPlayerAction({ type: "move", dx, dy });
this.lastMoveTime = this.time.now;
this.playerPath.shift(); this.playerPath.shift();
return; return;
} }
@@ -164,8 +170,16 @@ export class GameScene extends Phaser.Scene {
let action: Action | null = this.playerInputHandler.handleCursorMovement(); let action: Action | null = this.playerInputHandler.handleCursorMovement();
if (action) { if (action) {
if (action.type === "move" && this.time.now - this.lastMoveTime < GAME_CONFIG.rendering.moveDuration) {
return;
}
this.playerPath = []; this.playerPath = [];
this.commitPlayerAction(action); this.commitPlayerAction(action);
if (action.type === "move") {
this.lastMoveTime = this.time.now;
}
} }
} }

36
src/scenes/systems/PlayerInputHandler.ts
View File

@@ -7,6 +7,12 @@ import type { Action, RangedWeaponItem } from "../../core/types";
export class PlayerInputHandler { export class PlayerInputHandler {
private scene: GameScene; private scene: GameScene;
// Input Chording state
private pendingDx: number = 0;
private pendingDy: number = 0;
private moveChordTime: number = 0;
private readonly CHORD_WINDOW = 40; // ms to wait for diagonal chord
constructor(scene: GameScene) { constructor(scene: GameScene) {
this.scene = scene; this.scene = scene;
} }
@@ -170,10 +176,28 @@ export class PlayerInputHandler {
} }
public handleCursorMovement(): Action | null { public handleCursorMovement(): Action | null {
const { dx, dy, anyJustDown } = this.scene.gameInput.getCursorState(); const { dx, dy, anyJustDown } = this.scene.gameInput.getCursorState() as any;
const now = this.scene.time.now;
if (anyJustDown) { if (anyJustDown) {
if (dx !== 0 || dy !== 0) { // Start or update chord
if (this.moveChordTime === 0) {
this.moveChordTime = now + this.CHORD_WINDOW;
}
if (dx !== 0) this.pendingDx = dx;
if (dy !== 0) this.pendingDy = dy;
}
if (this.moveChordTime > 0 && now >= this.moveChordTime) {
const finalDx = this.pendingDx;
const finalDy = this.pendingDy;
// Reset state
this.moveChordTime = 0;
this.pendingDx = 0;
this.pendingDy = 0;
if (finalDx !== 0 || finalDy !== 0) {
if (this.scene.targetingSystem.isActive) { if (this.scene.targetingSystem.isActive) {
this.scene.targetingSystem.cancel(); this.scene.targetingSystem.cancel();
this.scene.emitUIUpdate(); this.scene.emitUIUpdate();
@@ -181,17 +205,15 @@ export class PlayerInputHandler {
const player = this.scene.entityAccessor.getPlayer(); const player = this.scene.entityAccessor.getPlayer();
if (!player) return null; if (!player) return null;
const targetX = player.pos.x + dx; const targetX = player.pos.x + finalDx;
const targetY = player.pos.y + dy; const targetY = player.pos.y + finalDy;
const enemy = this.scene.entityAccessor.findEnemyAt(targetX, targetY); const enemy = this.scene.entityAccessor.findEnemyAt(targetX, targetY);
if (enemy) { if (enemy) {
return { type: "attack", targetId: enemy.id }; return { type: "attack", targetId: enemy.id };
} else { } else {
if (Math.abs(dx) + Math.abs(dy) === 1) { return { type: "move", dx: finalDx, dy: finalDy };
return { type: "move", dx, dy };
}
} }
} }
} }