// Layer.cpp : Layer class
//
// 17.11.1998 / DH - Redesign
// 02.12.1998 / DH - Map dynamically from memory
//
// Copyright (c) 1998 Daniel Hartmeier. All rights reserved.

#include "Layer.hpp"
#include <memory.h>

// -------------------------------------------------------------------

Layer::Layer(Level &level, int distance, int width, int height, const unsigned char *table, const unsigned char *map) : level(level), distance(distance), width(width), height(height), map(map), table(table), offsetX(0), offsetY(0), dx(8), dy(8), restX(0), restY(0)
  {
    for (int y = 0; y < 17; ++y)
      for (int x = 0; x < 21; ++x)
        tiles[y*21+x] = 0;
  }

// -------------------------------------------------------------------

Layer::~Layer()
  {
    for (int y = 0; y < 17; ++y)
      for (int x = 0; x < 21; ++x)
        if (tiles[y*21+x])
          delete tiles[y*21+x];
  }

// -------------------------------------------------------------------

void Layer::init()
  {
    offsetX = offsetY = 0;
    dx = dy = 8;
    restX = restY = 0;
    for (int y = 0; y < 17; ++y)
      for (int x = 0; x < 21; ++x)
        {
          if (tiles[y*21+x]) delete tiles[y*21+x];
          tiles[y*21+x] = level.createTile(map[(offsetY+y)*width+offsetX+x]);
        }
    moveTiles();
    return;
  }

// -------------------------------------------------------------------

void Layer::draw(GsOT *ot)
  {
    for (int y = 0; y < 17; ++y)
      for (int x = 0; x < 21; ++x)
        if (tiles[y*21+x])
          tiles[y*21+x]->draw(ot);
    return;
  }

// -------------------------------------------------------------------

int Layer::moveHorz(int x)
  {
    x += restX;
    int rx = x*256/distance;
    restX = x - rx*distance/256;
    dx += rx;

    // Tiles nach links schieben, rechts ansetzen
    while ((dx < -8) && (offsetX < width-21)) 
      {
        offsetX++;
        dx += 16;
        for (int r = 0; r < 17; ++r)
          {
            // Linke Spalte lšschen
            if (tiles[r*21]) delete tiles[r*21];
            // Rechtsliegende Spalten nach links schieben
            for (int c = 0; c < 20; ++c) tiles[r*21+c] = tiles[r*21+c+1];
            // Rechte Spalte neu erstellen
            tiles[r*21+20] = level.createTile(map[(offsetY+r)*width+offsetX+20]);
          }
      }
    if (dx < -8)
      {
        rx -= dx+8;
        dx = -8;
        restX = 0;
      }

    // Tiles nach rechts schieben, links ansetzen
    while ((dx > 8) && (offsetX > 0)) 
      {
        offsetX--;
        dx -= 16;
        for (int r = 0; r < 17; ++r)
          {
            // Rechte Spalte lšschen
            if (tiles[r*21+20]) delete tiles[r*21+20];
            // Linksliegende Spalten nach rechts schieben
            for (int c = 20; c > 0; --c) tiles[r*21+c] = tiles[r*21+c-1];
            // Linke Spalte neu erstellen
            tiles[r*21] = level.createTile(map[(offsetY+r)*width+offsetX]);
          }
      }
    if (dx > 8)
      {
        rx -= dx-8;
        dx = 8;
        restX = 0;
      }


    moveTiles();
    return rx;
  }

// -------------------------------------------------------------------

int Layer::moveVert(int y)
  {
    y += restY;
    int ry = y*256/distance;
    restY = y - ry*distance/256;
    dy += ry;

    // Tiles nach oben schieben, unten ansetzen
    while ((dy < -8) && (offsetY < height-17)) 
      {
        offsetY++;
        dy += 16;
        for (int c = 0; c < 21; ++c)
          {
            // Oberste Zeile lšschen
            if (tiles[c]) delete tiles[c];
            // Untere Zeilen hochschieben
            for (int r = 0; r < 16; ++r) tiles[r*21+c] = tiles[(r+1)*21+c];
            // Unterste Zeile neu erstellen
            tiles[16*21+c] = level.createTile(map[(offsetY+16)*width+offsetX+c]);
          }
      }
    if (dy < -8)
      {
        ry -= dy+8;
        dy = -8;
        restY = 0;
      }
      
    // Tiles nach unten schieben, oben ansetzen
    while ((dy > 8) && (offsetY > 0)) 
      {
        offsetY--;
        dy -= 16;
        for (int c = 0; c < 21; ++c)
          {
            // Unterste Zeile lšschen
            if (tiles[16*21+c]) delete tiles[16*21+c];
            // Obere Zeilen runterschieben
            for (int r = 16; r > 0; --r) tiles[r*21+c] = tiles[(r-1)*21+c];
            // Oberste Zeile neu erstellen
            tiles[c] = level.createTile(map[offsetY*width+offsetX+c]);
          }
      }
    if (dy > 8)
      {
        ry -= dy-8;
        dy = 8;
        restY = 0;
      }


    moveTiles();
    return ry;
  }

// -------------------------------------------------------------------

void Layer::moveTiles()
  {
    for (int r = 0; r < 17; ++r)
      for (int c = 0; c < 21; ++c)
        if (tiles[r*21+c])
          tiles[r*21+c]->move(dx+c*16, dy+r*16);
    return;
  }

// -------------------------------------------------------------------

void Layer::checkCollision(int x, int y, int &cx, int &cy, unsigned char &attr) const
  {
    attr = 0;
    int c = (x + offsetX*16 - dx + 8) / 16;
    int r = (y + offsetY*16 - dy + 8) / 16;
    cx = c*16 - offsetX*16 + dx;
    cy = r*16 - offsetY*16 + dy;
    if ((c >= 0) && (c < width) && (r >= 0) && (r < height))
      {
        unsigned char type = map[r*width+c];
        attr = table[type];
      }
    return;
  }

// -------------------------------------------------------------------