Entitá

Come detto all'inizio di questa serie di post, introduciamo le entitá.

Non andró a realizzare o usare un vero e proprio entity system, perché come detto questo sará solo un esercizio per riprendere la mano dopo tanto tempo che non mi metto alla prova in questo ambito.

Quindi per quanto riguarda l'eroe che moviamo e tutti gli altri mostri li faccio derivare da una classe comune per poter avere comportamenti base e metodi in comune.

Quindi andiamo a vedere come al momento ho ipotizzato la base delle entitá.

La base

Secondo la mia visione, che ripeto non pretendo di avere scelto la strada giusta o la soluzione perfetta, vado a memorizzare solo il tipo che é un numero e il quadrato che rappresenta la rappresentazione grafica (Rectangle).

import Pos from '../utils/pos';
import { C_SIZE } from "../utils/consts";

export default class Entita {
  tipo: number = 0;
  public square: Phaser.GameObjects.Rectangle;

a questo punto andiamo a vedere il costruttore, che prende il tipom la posizione e la scena in cui disegnarsi.

 constructor(
    type: number,
    place: Pos,
    scene: Phaser.Scene,
  ) {
    this.tipo = type;
    this.square = scene.add.rectangle((place.x * (C_SIZE)), (place.y * (C_SIZE)), C_SIZE, C_SIZE, 0x00aa66);
    this.square.setOrigin(0, 0);
  }

Quindi il tipo lo vado a salvare che prevedo possa essermi utile per identificare la tipologia di nemico.

Con la posizione vado a creare il quadratino in quella posizione largo quando definito dalla costante che rappresenta la grandezza di una cella della scacchiera.

Settare l'origine serve per mettere l'origine della grafica non al centro come avviene di default ma nell'angolo alto sinistro.

Concludiamo con due metodi per prendere e settare la posizione dell'entitá ...

  getPos(): Pos {
    return new Pos(this.square.x, this.square.y);
  }
  setPos(p: Pos) {
    this.square.x = p.x;
    this.square.y = p.y;
  }

usanto il tipo Pos visto nel post precedente

Per chiouidere un metodo che al momento sará vuoto, utile quando andró a declinare la classe.

  getListMoveArea(): Pos[] {
    return [];
  }

Che ritorna un array di posizioni, che andranno ad identificare le celle su cui potremmo spostarci nella fase di movimento.

Hero

A questo punto per creare la classe che gestisce il nostro eroe hero.ts.

import Pos from "../utils/pos";
import Entita from "./entita";

export default class Hero extends Entita {}

Che ereditando da Entita tutta la gestione della rappresentazione grafica é fatta.

Quindi l'unica cosa che andremo a modificare é la funzione che va a ritornare la lista delle posizioni, che come detto deve rappresentare la lista delle possibili celle dove postersi spostare nella fase di movimento.

override getListMoveArea(): Pos[] {
    let ret: Pos[] = [];
    ret.push(new Pos(-3, 0));
    ret.push(new Pos(-2, -1));
    ret.push(new Pos(-2, 0));
    ret.push(new Pos(-2, 1));
    ret.push(new Pos(-1, -2));
    ret.push(new Pos(-1, -1));
    ret.push(new Pos(-1, 0));
    ret.push(new Pos(-1, 1));
    ret.push(new Pos(-1, 2));
    ret.push(new Pos(0, -3));
    ret.push(new Pos(0, -2));
    ret.push(new Pos(0, -1));
    ret.push(new Pos(0, 0));
    ret.push(new Pos(0, 1));
    ret.push(new Pos(0, 2));
    ret.push(new Pos(0, 3));
    ret.push(new Pos(1, -2));
    ret.push(new Pos(1, -1));
    ret.push(new Pos(1, 0));
    ret.push(new Pos(1, 1));
    ret.push(new Pos(1, 2));
    ret.push(new Pos(2, -1));
    ret.push(new Pos(2, 0));
    ret.push(new Pos(2, 1));
    ret.push(new Pos(3, 0));
    return ret;
  }

Per rendere possibile questa cosa la lista delle posizioni non sono altro che una lista di offset da applicare alla posizione corrente.

In questo caso l'eroe si puó muovere in un raggio di tre celle, quando avremo finito la prima parte e eseguiremo il codice sará piú chiaro.

Anche per questo post abbiamo finito, non voglio creare post troppo lungi per non annoisare o rendere facilmente capibile a tutti.

Pubblicato 13 Dec 2023