#include<stdlib.h>
#include<math.h>
#include"object.h"
#include"monster.h"
#include"level.h"
#include"io.h"
#include"fejs.h"
#include"levels.c"


char mtr[] = "#.<>~+/";
int mcl[] = {C_DARK_GRAY, 0, C_WHITE, C_WHITE, C_LIGHT_BLUE, C_BROWN, C_BROWN};

char *terrains[] = {
  "A wall.",
  "A piece of floor.",
  "The stairs are falling downwards here.",
  "The stairs are rising upwards here.",
  "Water spills out here.",
  "The closed door blocks the way here.",
  "The open door vents here.",
};


void
level_make(tlevel *l, int d) {
/*  int x,y;

  l->h=20; l->w=80;
  l->m=malloc(l->h*sizeof(tceil **));
  for (y=0;y<l->h;y++) {
    l->m[y]=malloc(l->w*sizeof(tceil *));
    for (x=0;x<l->w;x++) {
      l->m[y][x].t=lvl[d][y][x];
      l->m[y][x].f=(char)l->m[y][x].l=l->m[y][x].i=l->m[y][x].k=0;
    }
  }*/
}

void
level_make_clean(tlevel *l) {
  int x, y;

  l->h = 20;
  l->w = 80;
  for (y = 0; y < l->h; y++) {
    for (x = 0; x < l->w; x++) {
      l->m[y][x].t = 0;
      l->m[y][x].f = 0;
      l->m[y][x].l = 0;
      l->m[y][x].i = 0;
      l->m[y][x].k = 0;
    }
  }
}

void
level_load(FILE *f, tlevel *l) {
/*  int x,y;

  fread(&l->h,sizeof(l->h),1,f);
  fread(&l->w,sizeof(l->w),1,f);
  l->m=malloc(l->h*sizeof(tceil **));
  for (y=0;y<l->h;y++) {
    l->m[y]=malloc(l->w*sizeof(tceil *));
    for (x=0;x<l->w;x++) {
      fread(&l->m[y][x],sizeof(tceil),1,f);
    }
  }*/
}

void
level_paint(tlevel *l, int kk) {
  int x, y;
  
  for (y = 0; y < l->h; y++) {
    for (x = 0; x < l->w; x++) {
      if (l->m[y][x].k + kk) {
	pputch(x + sx, y + sy, mtr[l->m[y][x].t], mcl[l->m[y][x].t]);
	
	if (l->m[y][x].o)
	  object_paint(l->m[y][x].o, x, y);
	
	if (l->m[y][x].m)
	  monster_paint(l->m[y][x].m);
	
      } else
	pputch(x + sx, y + sy, ' ', 0);
    }
  }
}

void
step_line(int *x, int *y, int x1, int y1, int x2, int y2) {
  int d, dx, dy, s;
  
  dy = (*y < y1)? y1 - *y: *y - y1;
  dx = (*x < x1)? x1 - *x: *x - x1;
  
  d = ((dy > dx)? dy: dx) + 1;
  
  dy = (y2 < y1)? y1 - y2: y2 - y1;
  dx = (x2 < x1)? x1 - x2: x2 - x1;

  if (dy > dx) {
    s = (d * dx + (dy - 1) / 2) / dy;
    (*x) = (x2 < x1)? (x1 - s): (x1 + s);
    (*y) = (y2 < y1)? (y1 - d): (y1 + d);
  } else {
    s = (d * dy + (dx - 1) / 2) / dx;
    (*y) = (y2 < y1)? (y1 - s): (y1 + s);
    (*x) = (x2 < x1)? (x1 - d): (x1 + d);
  }
}

int
trace_line(int x1, int y1, int x2, int y2, int c, tlevel *l) {
  int d, x = x1, y = y1;

  if (!c)
    c = (int) ceil(sqrt((double) (abs((x1 - x2) * (x1 - x2)) + abs((y1 - y2) * (y1 - y2)))));
  
  for (d = 0; (x != x2) || (y != y2); d++) {
    if (d && (l->m[y][x].t == C_WALL || l->m[y][x].t == C_CDOOR))
      return 0;
    
    step_line(&x, &y, x1, y1, x2, y2);
  }
  
  return 1;
}