imshvc/noxious_client
1
0
Fork 0
forked from noxious/client
Code Pull Requests Activity

Better variable namings

Browse Source
This commit is contained in:
Dennis Postma
2025-01-09 15:58:02 +01:00
parent 03fef60621
commit 7546116878
11 changed files with 301 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
src/composables/gameComposable.ts
View File

@ -26,6 +26,7 @@ export async function loadTexture(scene: Phaser.Scene, textureData: TextureData)
// If asset is not found, download it
if (!texture) {
console.log('Downloading texture:', textureData.key)
await textureStorage.download(textureData)
texture = await textureStorage.get(textureData.key)
}
@ -70,8 +71,10 @@ export async function loadSpriteTextures(scene: Phaser.Scene, sprite_id: string)
}
for await (const sprite_action of sprite.spriteActions) {
console.log('Loading sprite action:', sprite.id + '-' + sprite_action.action)
const key = sprite.id + '-' + sprite_action.action
await loadTexture(scene, {
key: sprite_action.id + '_' + sprite_action.action,
key,
data: '/textures/sprites/' + sprite.id + '/' + sprite_action.action + '.png',
group: sprite_action.isAnimated ? 'sprite_animations' : 'sprites',
updatedAt: sprite_action.updatedAt,
@ -87,15 +90,15 @@ export async function loadSpriteTextures(scene: Phaser.Scene, sprite_id: string)
if (!sprite_action.isAnimated) continue
// Check if animation already exists
if (scene.anims.get(sprite_action.key)) continue
if (scene.anims.get(key)) continue
// Add the animation to the scene
const anim = scene.textures.get(sprite_action.key)
scene.textures.addSpriteSheet(sprite_action.key, anim, { frameWidth: sprite_action.frameWidth ?? 0, frameHeight: sprite_action.frameHeight ?? 0 })
const anim = scene.textures.get(key)
scene.textures.addSpriteSheet(key, anim, { frameWidth: sprite_action.frameWidth ?? 0, frameHeight: sprite_action.frameHeight ?? 0 })
scene.anims.create({
key: sprite_action.key,
key: key,
frameRate: sprite_action.frameRate,
frames: scene.anims.generateFrameNumbers(sprite_action.key, { start: 0, end: sprite_action.frameCount! - 1 }),
frames: scene.anims.generateFrameNumbers(key, { start: 0, end: sprite_action.frameCount! - 1 }),
repeat: -1
})
}

40
src/composables/mapComposable.ts
View File

@ -9,50 +9,50 @@ import TilemapLayer = Phaser.Tilemaps.TilemapLayer
import Tileset = Phaser.Tilemaps.Tileset
import Tile = Phaser.Tilemaps.Tile
export function getTile(layer: TilemapLayer | Tilemap, x: number, y: number): Tile | undefined {
const tile = layer.getTileAtWorldXY(x, y)
export function getTile(layer: TilemapLayer | Tilemap, positionX: number, positionY: number): Tile | undefined {
const tile = layer.getTileAtWorldXY(positionX, positionY)
if (!tile) return undefined
return tile
}
export function tileToWorldXY(layer: TilemapLayer | Tilemap, pos_x: number, pos_y: number) {
const worldPoint = layer.tileToWorldXY(pos_x, pos_y)
export function tileToWorldXY(layer: TilemapLayer | Tilemap, positionX: number, positionY: number) {
const worldPoint = layer.tileToWorldXY(positionX, positionY)
if (!worldPoint) return { positionX: 0, positionY: 0 }
const positionX = worldPoint.x + config.tile_size.y
const positionY = worldPoint.y
const worldPositionX = worldPoint.x + config.tile_size.height
const worldPositionY = worldPoint.y
return { positionX, positionY }
return { worldPositionX, worldPositionY }
}
export function tileToWorldX(layer: TilemapLayer | Tilemap, pos_x: number, pos_y: number): number {
const worldPoint = layer.tileToWorldXY(pos_x, pos_y)
export function tileToWorldX(layer: TilemapLayer | Tilemap, positionX: number, positionY: number): number {
const worldPoint = layer.tileToWorldXY(positionX, positionY)
if (!worldPoint) return 0
return worldPoint.x + config.tile_size.x / 2
return worldPoint.x + config.tile_size.width / 2
}
export function tileToWorldY(layer: TilemapLayer | Tilemap, pos_x: number, pos_y: number): number {
const worldPoint = layer.tileToWorldXY(pos_x, pos_y)
export function tileToWorldY(layer: TilemapLayer | Tilemap, positionX: number, positionY: number): number {
const worldPoint = layer.tileToWorldXY(positionX, positionY)
if (!worldPoint) return 0
return worldPoint.y + config.tile_size.y * 1.5
return worldPoint.y + config.tile_size.height * 1.5
}
/**
* Can also be used to replace tiles
* @param map
* @param layer
* @param x
* @param y
* @param positionX
* @param positionY
* @param tileName
*/
export function placeTile(map: Tilemap, layer: TilemapLayer, x: number, y: number, tileName: string) {
export function placeTile(map: Tilemap, layer: TilemapLayer, positionX: number, positionY: number, tileName: string) {
let tileImg = map.getTileset(tileName) as Tileset
if (!tileImg) {
tileImg = map.getTileset('blank_tile') as Tileset
}
layer.putTileAt(tileImg.firstgid, x, y)
layer.putTileAt(tileImg.firstgid, positionX, positionY)
}
export function setLayerTiles(map: Tilemap, layer: TilemapLayer, tiles: string[][]) {
@ -69,12 +69,12 @@ export function createTileArray(width: number, height: number, tile: string = 'b
return Array.from({ length: height }, () => Array.from({ length: width }, () => tile))
}
export const calculateIsometricDepth = (x: number, y: number, width: number = 0, height: number = 0, isCharacter: boolean = false) => {
const baseDepth = x + y
export const calculateIsometricDepth = (positionX: number, positionY: number, width: number = 0, height: number = 0, isCharacter: boolean = false) => {
const baseDepth = positionX + positionY
if (isCharacter) {
return baseDepth // @TODO: Fix collision, this is a hack
}
return baseDepth + (width + height) / (2 * config.tile_size.x)
return baseDepth + (width + height) / (2 * config.tile_size.width)
}
export function FlattenMapArray(tiles: string[][]) {

74
src/composables/pointerHandlers/useGamePointerHandlers.ts
View File

@ -10,15 +10,17 @@ export function useGamePointerHandlers(scene: Phaser.Scene, layer: Phaser.Tilema
function updateWaypoint(worldX: number, worldY: number) {
const pointerTile = getTile(layer, worldX, worldY)
if (pointerTile) {
const worldPoint = tileToWorldXY(layer, pointerTile.x, pointerTile.y)
waypoint.value = {
visible: true,
x: worldPoint.positionX,
y: worldPoint.positionY + config.tile_size.y + 15
}
} else {
if (!pointerTile) {
waypoint.value.visible = false
return
}
const worldPoint = tileToWorldXY(layer, pointerTile.x, pointerTile.y)
if (!worldPoint.worldPositionX || !worldPoint.worldPositionX) return
waypoint.value = {
visible: true,
x: worldPoint.worldPositionX,
y: worldPoint.worldPositionY + config.tile_size.height + 15
}
}
@ -28,34 +30,46 @@ export function useGamePointerHandlers(scene: Phaser.Scene, layer: Phaser.Tilema
}
function handlePointerMove(pointer: Phaser.Input.Pointer) {
const { worldX, worldY } = pointer
updateWaypoint(worldX, worldY)
updateWaypoint(pointer.worldX, pointer.worldY)
if (gameStore.game.isPlayerDraggingCamera) {
const distance = Phaser.Math.Distance.Between(pointerStartPosition.value.x, pointerStartPosition.value.y, pointer.x, pointer.y)
if (!gameStore.game.isPlayerDraggingCamera) return
if (distance > dragThreshold) {
const { x, y, prevPosition } = pointer
const { scrollX, scrollY, zoom } = camera
camera.setScroll(scrollX - (x - prevPosition.x) / zoom, scrollY - (y - prevPosition.y) / zoom)
}
}
const distance = Phaser.Math.Distance.Between(
pointerStartPosition.value.x,
pointerStartPosition.value.y,
pointer.x,
pointer.y
)
if (distance <= dragThreshold) return
camera.setScroll(
camera.scrollX - (pointer.x - pointer.prevPosition.x) / camera.zoom,
camera.scrollY - (pointer.y - pointer.prevPosition.y) / camera.zoom
)
}
function handlePointerUp(pointer: Phaser.Input.Pointer) {
const distance = Phaser.Math.Distance.Between(pointerStartPosition.value.x, pointerStartPosition.value.y, pointer.x, pointer.y)
if (distance <= dragThreshold) {
const pointerTile = getTile(layer, pointer.worldX, pointer.worldY)
if (pointerTile) {
gameStore.connection?.emit('map:character:move', {
positionX: pointerTile.x,
positionY: pointerTile.y
})
}
}
gameStore.setPlayerDraggingCamera(false)
const distance = Phaser.Math.Distance.Between(
pointerStartPosition.value.x,
pointerStartPosition.value.y,
pointer.x,
pointer.y
)
if (distance > dragThreshold) return
const pointerTile = getTile(layer, pointer.worldX, pointer.worldY)
if (!pointerTile) return
console.log(pointerTile.x, pointerTile.y)
gameStore.connection?.emit('map:character:move', {
positionX: pointerTile.x,
positionY: pointerTile.y
})
}
const setupPointerHandlers = () => {

11
src/composables/pointerHandlers/useMapEditorPointerHandlers.ts
View File

@ -15,10 +15,12 @@ export function useMapEditorPointerHandlers(scene: Phaser.Scene, layer: Phaser.T
if (pointerTile) {
const worldPoint = tileToWorldXY(layer, pointerTile.x, pointerTile.y)
if (!worldPoint.positionX || !worldPoint.positionY) return
waypoint.value = {
visible: true,
x: worldPoint.positionX,
y: worldPoint.positionY + config.tile_size.y + 15
y: worldPoint.positionY + config.tile_size.height + 15
}
} else {
waypoint.value.visible = false
@ -26,11 +28,8 @@ export function useMapEditorPointerHandlers(scene: Phaser.Scene, layer: Phaser.T
}
function dragMap(pointer: Phaser.Input.Pointer) {
if (gameStore.game.isPlayerDraggingCamera) {
const { x, y, prevPosition } = pointer
const { scrollX, scrollY, zoom } = camera
camera.setScroll(scrollX - (x - prevPosition.x) / zoom, scrollY - (y - prevPosition.y) / zoom)
}
if (!gameStore.game.isPlayerDraggingCamera) return
camera.setScroll(camera.scrollX - (pointer.x - pointer.prevPosition.x) / camera.zoom, scrollY - (pointer.y - pointer.prevPosition.y) / camera.zoom)
}
function handlePointerMove(pointer: Phaser.Input.Pointer) {

0
src/composables/spriteComposable.ts Normal file
View File