instructions-clear/src/index.js

import { Vector2 } from 'three'
import { WebSocketExpress } from 'websocket-express'
import Entity from './entity.js'
import express from 'express'
import Game from './game.js'
import Team from './team.js'
import Template from './template.js'
import Terrain from './terrain.js'
import Level from './level.js'

const app = new WebSocketExpress()
const port = 1280
const game = new Game()

app.use('/', express.static('public'))
app.use('/three/', express.static('node_modules/three'))
app.use('/@tweenjs/', express.static('node_modules/@tweenjs'))
app.use('/stats.js/', express.static('node_modules/stats.js'))
app.use('/tools/', express.static('tools'))
app.use(express.urlencoded({ extended: true }))

app.ws('/ws', async (req, res) => {
  const websocket = await res.accept()

  const subscription = () => websocket.send(JSON.stringify(game))
  game.eventEmitter.on('tick', subscription)

  websocket.on('close', () => {
    game.eventEmitter.removeListener('tick', subscription)
  })

  websocket.on('message', (rawData) => {
    const message = JSON.parse(rawData)
    const entity = message.id != null ? game.entities.find((e) => e.id == message.id) : null
    if (entity == null) {
      console.error({ error: { reason: 'Invalid ID', message } })
      return
    }
    else {
      console.log(message)
    }

    let delay = 0
    // if(message.id == '1') {
    //   delay = 45
    // }

    if (message.action == 'attack') {
      setTimeout(() => entity.attackAction(new Vector2(message.x, message.y)), delay)
    }

    if (message.action == 'cast') {
      setTimeout(() => entity.castAction(message.slot, new Vector2(message.x, message.y)), delay)
    }

    if (message.action == 'halt') {
      setTimeout(() => entity.haltAction(), delay)
    }

    if (message.action == 'stop') {
      setTimeout(() => entity.stopAction(), delay)
    }

    if (message.action == 'move') {
      setTimeout(() => entity.moveAction(new Vector2(message.x, message.y)), delay)
    }
  })
})

function laneScenario() {
  const player1 = new Entity(Template.player({
    id: '1',
    spawnPosition: new Vector2(500, 150),
    team: Team.blue,
  }))
  game.spawnEntity(player1)
  player1.attackAction(new Vector2(500, 150))

  // const player2 = new Entity(Template.player({
  //   id: '2',
  //   spawnPosition: new Vector2(1600, 1800),
  //   team: Team.red,
  // }))
  // game.spawnEntity(player2)
  // player2.attackAction(new Vector2(1600, 1800))

  const gameLogic = function gameLogic() {
    const game = this

    const midRoute = [
      new Vector2(1544, 1572),
      new Vector2(2748, 2792),
      new Vector2(3628, 3688),
      new Vector2(4992, 5000),
      new Vector2(6272, 6188),
      new Vector2(7252, 7200),
      new Vector2(8436, 8408),
    ].map((p) => p.multiplyScalar(1.6))

    const topRoute = [
      new Vector2(868, 1740),
      new Vector2(856, 3480),
      new Vector2(808, 5944),
      new Vector2(816, 7256),
      new Vector2(976, 7772),
      new Vector2(1388, 8384),
      new Vector2(1948, 8940),
      new Vector2(2392, 9152),
      new Vector2(4168, 9196),
      new Vector2(6548, 9168),
      new Vector2(8288, 9176),
    ].map((p) => p.multiplyScalar(1.6))

    const botRoute = [
      new Vector2(1704, 812),
      new Vector2(3460, 828),
      new Vector2(5804, 768),
      new Vector2(7332, 844),
      new Vector2(8052, 1100),
      new Vector2(8528, 1516),
      new Vector2(9080, 2208),
      new Vector2(9224, 2620),
      new Vector2(9172, 4344),
      new Vector2(9136, 6752),
      new Vector2(9136, 8248),
    ].map((p) => p.multiplyScalar(1.6))

    if (game.entities.length < 100) {
      if ([(0 * game.tickRate), (1 * game.tickRate), (2 * game.tickRate)].includes(game.currentTick % (6 * game.tickRate))) {
        game.spawnEntity(new Entity(Template.minion(Team.blue, { ranged: false, route: topRoute })))
        game.spawnEntity(new Entity(Template.minion(Team.blue, { ranged: false, route: midRoute })))
        game.spawnEntity(new Entity(Template.minion(Team.blue, { ranged: false, route: botRoute })))

        game.spawnEntity(new Entity(Template.minion(Team.red, { ranged: false, route: topRoute.toReversed() })))
        game.spawnEntity(new Entity(Template.minion(Team.red, { ranged: false, route: midRoute.toReversed() })))
        game.spawnEntity(new Entity(Template.minion(Team.red, { ranged: false, route: botRoute.toReversed() })))
      }

      if ([(3 * game.tickRate), (4 * game.tickRate), (5 * game.tickRate)].includes(game.currentTick % (6 * game.tickRate))) {
        game.spawnEntity(new Entity(Template.minion(Team.blue, { ranged: true, route: topRoute })))
        game.spawnEntity(new Entity(Template.minion(Team.blue, { ranged: true, route: midRoute })))
        game.spawnEntity(new Entity(Template.minion(Team.blue, { ranged: true, route: botRoute })))

        game.spawnEntity(new Entity(Template.minion(Team.red, { ranged: true, route: topRoute.toReversed() })))
        game.spawnEntity(new Entity(Template.minion(Team.red, { ranged: true, route: midRoute.toReversed() })))
        game.spawnEntity(new Entity(Template.minion(Team.red, { ranged: true, route: botRoute.toReversed() })))
      }
    }

  }
  game.logic = gameLogic
}

app.listen(port, () => {
  console.log(`Server started! Visit http://localhost:${port}`)

  Level.terrains.map((points) => new Terrain(points.map((p) => p.multiplyScalar(1.6)))).forEach((terrain) => game.addTerrain(terrain))
  laneScenario()

  game.start()
})