server.js

// Constants
const WALK_SPEED = 4;
const FPS = 30;

// Globals
let id = 0;
let map;
let mapSize = { x: 0, y: 0 };
let entities = [];

const express = require('express');
const app = express();
const http = require('http').Server(app);
const io = require('socket.io')(http);
const fs = require('fs');
const _ = require('./public/underscore.js')._;

fs.readFile('public/common.js', 'utf8', (err, data) => {
    if (err) {
        throw err;
    }
    eval(data);
});

io.on('connection', (socket) => {
    socket.emit('map', map);
    socket.emit('players', _.map(entities, (entity) => entity.id));

    let player = new Entity({ x: 110, y: 135 }, 'blue', false, socket.id);
    entities.push(player);

    io.emit('new-player', player.id);

    socket.on('direction-update', (data) => {
        player.action = data ? 'walk' : 'stationary';
        switch (data) {
            case 'N': player.orientation = 'up';    break;
            case 'S': player.orientation = 'down';  break;
            case 'W': player.orientation = 'left';  break;
            case 'E': player.orientation = 'right'; break;
            default: break; // Keep existing orientation if none of the cases match
        }
    });

    socket.emit('show-content', 'welcome');
});

class Entity {
    constructor(pos, colour, npc, socketId) {
        this.id = id++;
        this.pos = pos;
        this.colour = colour;
        this.socketId = socketId;
        this.isViewingPage = true;
        this.action = 'stationary';
        this.orientation = 'down';
    }

    update() {
        if (this.action === 'walk') {
            this.walk();
        }
    }

    walk() {
        let direction = { x: 0, y: 0 };

        switch (this.orientation) {
            case 'left':  this._walk({ x: -WALK_SPEED, y: 0 }); break;
            case 'right': this._walk({ x: WALK_SPEED, y: 0 }); break;
            case 'up':    this._walk({ x: 0, y: -WALK_SPEED }); break;
            case 'down':  this._walk({ x: 0, y: WALK_SPEED }); break;
        }

        let page = this.getObjectsAt(this.pos, "Page");
        if (this.isViewingPage) {
            if (page.length === 0) {
                io.to(this.socketId).emit('hide-content');
                this.isViewingPage = false;
            }
        } else if (page.length === 1) {
            this.isViewingPage = true;
            io.to(this.socketId).emit('show-content', page[0].properties.content);
        }
    }

    _walk(direction) {
        let newPos = {
            x: this.pos.x + direction.x,
            y: this.pos.y + direction.y
        };

        if (this.canMoveTo(newPos)) {
            this.pos = newPos;
        }
    }

    canMoveTo(pos) {
        let impassableObjects = this.getObjectsAt(pos, "Impassable");

        // Can't move outside the map boundary or through impassable terrain
        if (pos.x > mapSize.x || pos.y > mapSize.y || pos.x < 0 || pos.y < 0 || impassableObjects.length !== 0) {
            return false;
        }
        return true;
    }

    getObjectsAt(pos, layerName) {
        let layer = getLayer(map, layerName);
        return layer.objects.filter((object) => {
            return object.x <= pos.x && pos.x <= object.x + object.width &&
                object.y <= pos.y && pos.y <= object.y + object.height;
        });
    }
}

var getLayer = function(map, name) {
    for (key in map.layers) {
        if (name == map.layers[key].name) {
            return map.layers[key];
        }
    }
    return null;
}


function updateEntities() {
    entities.forEach((entity) => entity.update());
}

function gameLoop() {
    updateEntities();
    io.emit('update', entities);
    setTimeout(gameLoop, 1000 / FPS);
}

app.use(express.static(__dirname + '/public'));

app.get('/', (req, res) => {
    res.sendFile(__dirname + '/index.html');
});

fs.readFile(__dirname + '/public/map.json', 'utf8', (err, data) => {
    if (err) {
        throw err;
    }
    map = JSON.parse(data);
    mapSize.x = map.width * map.tilewidth - map.tilewidth;
    mapSize.y = map.height * map.tileheight - 16;
});

http.listen(8080, () => {
    console.log('Server listening on *:8080');
});

gameLoop();