tankz/src/common/haxe/ru/m/tankz/engine/Engine.hx

package ru.m.tankz.engine;

import ru.m.tankz.core.Bullet;
import ru.m.tankz.proto.GameObjectType;
import ru.m.tankz.proto.GameChangeType;
import ru.m.tankz.proto.GameChange;
import ru.m.tankz.proto.Person;
import ru.m.tankz.core.Direction;
import ru.m.tankz.core.IMobileEntity;
//import flash.geom.Rectangle;
import ru.m.tankz.config.TankzConfig;
import ru.m.tankz.core.Tank;
import ru.m.tankz.map.TankzMap;
import ru.m.tankz.map.ITankzMap;

class Engine implements IEngine {

  public var config(default, default):TankzConfig;
  public var map(default, null):ITankzMap;

  public var tanks(default, null):Map<Int, Tank>;
  public var mobileEntities(default, null):Map<Int, IMobileEntity>;

  private var x_limit:Float;
  private var y_limit:Float;

  public function new() {}

  public function clear():Void {
    tanks = new Map<Int, Tank>();
  }

  private function buildTank(personId:Int, id:Int, x:Float, y:Float, direction:Direction):Tank {
    return new Tank(personId, id, x, y, direction);
  }

  public function init(config:TankzConfig):Void {
    this.config = config;
    map = new TankzMap(config.map);
    tanks = new Map<Int, Tank>();
    mobileEntities = new Map<Int, IMobileEntity>();
    x_limit = map.gridWidth * map.cellWidth;
    y_limit = map.gridHeight * map.cellHeight;
  }

  public function initTanks(persons:Array<Person>):Array<GameChange> {
    var changes = new Array<GameChange>();
    for (person in persons) {
      var x = 0;
      var y = 100 * persons.indexOf(person);
      var tank = buildTank(person.id, 0, x, y, Direction.BOTTOM);
      this.tanks.set(tank.personId, tank);
      this.mobileEntities.set(tank.id, tank);
      changes.push(new GameChange()
        .setType(GameChangeType.APPEND)
        .setObjectType(GameObjectType.TANK)
        .setPersonId(tank.personId)
        .setObjectId(tank.id)
        .setX(tank.x)
        .setY(tank.y)
        .setDirectionX(tank.direction.x)
        .setDirectionY(tank.direction.y)
      );
    }
    return changes;
  }

  public function updateFromChanges(changes:Array<GameChange>):Void {
    for (change in changes) {
      switch (change.type) {
        case GameChangeType.APPEND:
          switch (change.objectType) {
            case GameObjectType.TANK:
              var tank:Tank = buildTank(change.personId, change.objectId, change.x, change.y, Direction.from(change.directionX, change.directionY));
              mobileEntities.set(tank.id, tank);
              tanks.set(tank.personId, tank);
            case GameObjectType.BULLET:
              var bullet:Bullet = new Bullet(change.personId, change.objectId, change.x, change.y, 0, Direction.from(change.directionX, change.directionY));
              mobileEntities.set(bullet.id, bullet);
          }
        case GameChangeType.DESTROED:
          mobileEntities.remove(change.objectId);
        case GameChangeType.DIRECTION:
          var target = mobileEntities.get(change.objectId);
          target.direction = Direction.from(change.directionX, change.directionY);
        case GameChangeType.MOVED:
          var target = mobileEntities.get(change.objectId);
          target.x = change.x;
          target.y = change.y;
        case GameChangeType.MODIFIED:
          //
      }
    }
  }

  public function update():Array<GameChange> {
    var changes = new Array<GameChange>();

    for (entiny in mobileEntities) {
      var objectType = -1;
      var personId = Reflect.hasField(entiny, "personId") ? Reflect.field(entiny, "personId") : -1;
      if (Std.is(entiny, Tank)) objectType = GameObjectType.TANK;
      if (Std.is(entiny, Bullet)) objectType = GameObjectType.BULLET;

      if (objectType == GameObjectType.TANK) {
        if (entiny.direction.x != 0) {
          entiny.y = Math.round((entiny.y + entiny.height / 2) / config.map.cellHeight) * config.map.cellHeight - entiny.height / 2;
        }
        if (entiny.direction.y != 0) {
          entiny.x = Math.round((entiny.x + entiny.width / 2) / config.map.cellWidth) * config.map.cellWidth - entiny.width / 2;
        }
      }

      if (entiny.mx != 0 || entiny.my != 0) {
        entiny.x += entiny.mx;
        entiny.y += entiny.my;

        /*var tankR = new Rectangle(tank.x, tank.y, tank.width, tank.height);

        for (t in tanks) if (t != tank) {
          var r = new Rectangle(t.x, t.y, t.width, t.height);
          if (tankR.intersects(r)) {
            if (tank.direction.x > 0) {
              if (tank.x + tank.width > t.x) tank.x = t.x - tank.width;
            } else if (tank.direction.x < 0) {
              if (tank.x < t.x + t.width) tank.x = t.x + t.width;
            }
            if (tank.direction.y > 0) {
              if (tank.y + tank.height > t.y) tank.y = t.y - tank.height;
            } else if (tank.direction.y < 0) {
              if (tank.y < t.y + t.height) tank.y = t.y + t.height;
            }
          }
        }*/

        if (objectType == GameObjectType.TANK) {
          if (entiny.x < 0) entiny.x = 0;
          if (entiny.x + entiny.width  > x_limit) entiny.x = x_limit - entiny.width;
          if (entiny.y < 0) entiny.y = 0;
          if (entiny.y + entiny.height > y_limit) entiny.y = y_limit - entiny.height;
        }


        changes.push(new GameChange()
          .setType(GameChangeType.MOVED)
          .setObjectType(objectType)
          .setPersonId(personId)
          .setObjectId(entiny.id)
          .setX(entiny.x)
          .setY(entiny.y)
        );

        if (objectType == GameObjectType.BULLET) {
          if (entiny.x < 0 || entiny.x + entiny.width  > x_limit || entiny.y < 0 || entiny.y + entiny.height > y_limit) {
            mobileEntities.remove(entiny.id);
            var tank = tanks.get(personId);
            tank.onDestroyBullet();
            changes.push(new GameChange()
              .setType(GameChangeType.DESTROED)
              .setObjectType(objectType)
              .setPersonId(personId)
              .setObjectId(entiny.id)
            );
          }
        }
      }
    }
    return changes;
  }
}