// mapconv.cpp : Converter for map editor
//
// 30.11.1998 / DH - Genesis (quick & dirty)
// 02.12.1998 / DH - Produce binary data file
// 20.12.1998 / DH - Objects read from layer
//
// Copyright (c) 1998 by Daniel Hartmeier. All rights reserved.

#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <mem.h>
#include <iostream.h>

bool readline(FILE *f, unsigned char *b)
  {
    bool done = false, eof = false;
    do
      {
        if (fread(b, 1, 1, f))
          {
            if (*b == '\n')
              {
                *(b-1) = 0;
                done = true;
              }
            else b++;
          }
        else eof = true;
      }
    while (!done && !eof);
    return !eof;
  }

void processLayer(FILE *layer, unsigned char &width, unsigned char &height, unsigned char *&map)
  {
    unsigned char buffer[2048];
    int a[10];
    int count = 0;
    bool data = false;
    while (readline(layer, buffer))
      {
      //cout << buffer << endl;
        if (!data)
          {
            if (!strncmp(buffer, "LayerWidthInTiles=", 18))
              {
                width = atoi(buffer+18);
              //cout << "  width = " << (int)width << endl;
              }
            else if (!strncmp(buffer, "LayerHeightInTiles=", 19))
              {
                height = atoi(buffer+19);
              //cout << "  height = " << (int)height << endl;
              }
            else if (!strcmp(buffer, "[BEGIN_TILE_DATA]"))
              {
                data = true;
                map = new unsigned char[width*height];
                count = 0;
              //cout << "  begin data" << endl;
              }
          }
        else
          {
            if (!strcmp(buffer, "[END_TILE_DATA]"))
              {
                data = false;
              //cout << "  end data (" << count << " bytes)" << endl;
              }
            else
              {
                sscanf(buffer, "%i,%i,%i,%i,%i,%i,%i,%i,%i,%i", &a[0], &a[1], &a[2], &a[3], &a[4], &a[5], &a[6], &a[7], &a[8], &a[9]);
              //cout << "Data: "; for (int j = 0; j < 10; ++j) cout << a[j] << ", "; cout << endl;
                for (int j = 0; (j < 10) && (count < width*height); j += 2)
                  {
                    unsigned char c = 0;
                    if ((a[j] >= 0) && (a[j] < 16) && (a[j+1] >= 0) && (a[j+1] < 16))
                      c = a[j+1]*16 + a[j];
                    map[count++] = c;
                  }
              }
          }
      }
    return;
  }

int main(int argc, char *argv[])
  {
    if (argc != 6) cerr << "mapconv.exe <table> <center> <back> <objects> <output>" << endl;
    else
      {
        cout << endl;
        cout << "mapconv.exe v1.2   Copyright (c) 1998 by Daniel Hartmeier. All rights reserved." << endl;
        cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << endl;
        FILE *table = fopen(argv[1], "rb");
        if (!table) cerr << "Error: Couldn't open table file " << argv[1] << endl;
        else
          {
            FILE *centerlayer = fopen(argv[2], "rb");
            if (!centerlayer) cerr << "Error: Couldn't open layer file " << argv[2] << endl;
            else
              {
                FILE *backlayer = fopen(argv[3], "rb");
                if (!backlayer) cerr << "Error: Couldn't open layer file " << argv[3] << endl;
                else
                  {
                    FILE *objectslayer = fopen(argv[4], "rb");
                    if (!objectslayer) cerr << "Error: Couldn't open objects layer file " << argv[4] << endl;
                    else
                      {
                        FILE *out = fopen(argv[5], "w+b");
                        if (!out) cerr << "Error: Couldn't create output file " << argv[5] << endl;
                        else
                          {
                            cout << "Converting " << argv[1] << ", " << argv[2] << ", " << argv[3] << ", " << argv[4] << " to " << argv[5] << endl;

                            unsigned char buffer[2048];
                            int a[16];

                            unsigned char data_table[256]; memset(data_table, 0, 256);
                            cout << "Reading table file" << endl;
                            int i = 0;
                            while ((i < 16) && readline(table, buffer))
                              {
                                if (buffer[0] && strncmp(buffer, "//", 2))
                                  {
                                    sscanf(buffer, "%i,%i,%i,%i,%i,%i,%i,%i,%i,%i,%i,%i,%i,%i,%i,%i", &a[0], &a[1], &a[2], &a[3], &a[4], &a[5], &a[6], &a[7], &a[8], &a[9], &a[10], &a[11], &a[12], &a[13], &a[14], &a[15]);
                                    for (int j = 0; j < 16; ++j) data_table[i*16+j] = a[j];
                                    i++;
                                  }
                              }
                            if (i < 16) cerr << "Error: Unexpected end of file" << endl;
                            cout << "  done (256 bytes)" << endl;

                            cout << "Reading center layer file" << endl;
                            unsigned char data_center_width = 0, data_center_height = 0;
                            unsigned char *data_center_map = 0;
                            processLayer(centerlayer, data_center_width, data_center_height, data_center_map);
                            cout << "  done (" << (int)data_center_width << "*" << (int)data_center_height << " tiles, " << data_center_width*data_center_height << " bytes)" << endl;

                            cout << "Reading back layer file" << endl;
                            unsigned char data_back_width = 0, data_back_height = 0;
                            unsigned char *data_back_map = 0;
                            processLayer(backlayer, data_back_width, data_back_height, data_back_map);
                            cout << "  done (" << (int)data_back_width << "*" << (int)data_back_height << " tiles, " << data_back_width*data_back_height << " bytes)" << endl;

                            cout << "Reading objects layer file" << endl;
                            unsigned char data_objects_width = 0, data_objects_height = 0;
                            unsigned char *data_objects_map = 0;
                            processLayer(objectslayer, data_objects_width, data_objects_height, data_objects_map);
                            cout << "  done (" << (int)data_objects_width << "*" << (int)data_objects_height << " tiles, " << data_objects_width*data_objects_height << " bytes)" << endl;

                            if      (!data_center_map || !data_back_map || !data_objects_map) cerr << "Error: Invalid layer files" << endl;
                            else if ((data_back_width  != 20+(data_center_width -20)/2) || (data_back_height != 16+(data_center_height-16)/2))
                              cerr << "Error: Size of back layer should be " << (20+(data_center_width-20)/2) << "*" << (16+(data_center_height-16)/2) << " tiles" << endl;
                            else if ((data_objects_width != data_center_width) || (data_objects_height != data_center_height))
                              cerr << "Error: Size of objects layer should be " << data_center_width << "*" << data_center_height << " tiles" << endl;
                            else
                              {

                                unsigned char data_objects[2048];
                                unsigned data_numberofobjects = 0;

                                cout << "Processing objects layer file" << endl;
                                bool set_start = false, set_end = false;
                                for (int y = 0; y < data_objects_height; ++y)
                                  for (int x = 0; x < data_objects_width; ++x)
                                    {
                                      unsigned char c = data_objects_map[y*data_objects_width+x];
                                      if (c)
                                        {
                                        //cout << "  " << (int)c << ", " << x << ", " << y << endl;
                                          unsigned char e = 0;
                                          if      (c ==  19) e =  1; // Start
                                          else if (c ==  35) e =  2; // Ziel
                                          else if (c ==  51) e =  3; // Spinne
                                          else if (c ==  67) e =  4; // Skorpion
                                          else if (c ==  83) e =  5; // Käfer A
                                          else if (c ==  99) e =  6; // Käfer B
                                          else if (c == 115) e =  7; // Käfer C
                                          else if (c == 131) e =  8; // Ente
                                          else if (c == 147) e =  9; // Vogel
                                          else if (c == 163) e = 10; // Schnecke
                                          else if (c == 179) e = 11; // Mücke
                                          else if (c == 195) e = 12; // Libelle
                                          else if (c ==  25) e = 13; // Ameise A
                                          else if (c ==  41) e = 14; // Ameise B
                                          else if (c ==  57) e = 15; // Raupe
                                          else if (c ==  73) e = 16; // Pilz
                                          else if (c ==  89) e = 19; // Krabbe
                                          else if (c == 105) e = 20; // Drache
                                          if (!e) cerr << "Error: Unexpected object " << (int)c << " in tile " << x << ", " << y << endl;
                                          else
                                            {
                                            //cout << "  " << (int)e << ", " << x << ", " << y << endl;
                                              data_objects[data_numberofobjects*3+0] = e;
                                              data_objects[data_numberofobjects*3+1] = x;
                                              data_objects[data_numberofobjects*3+2] = y;
                                              data_numberofobjects++;
                                              if (e == 1) { if (set_start) cerr << "Error: Start doubly defined in objects layer" << endl; else set_start = true; }
                                              if (e == 2) { if (set_end) cerr << "Error: Exit doubly defined in objects layer" << endl; else set_end = true; }
                                            }
                                        }
                                    }
                                if (!set_start) cerr << "Error: Start not defined in objects layer" << endl;
                                if (!set_end) cerr << "Error: Exit not defined in objects layer" << endl;
                                cout << "  done (" << data_numberofobjects << " objects, " << 3*data_numberofobjects << " bytes)" << endl;
/*
                                cout << "Reading objects file" << endl;
                                while (readline(objects, buffer))
                                  {
                                    if (buffer[0] && strncmp(buffer, "//", 2))
                                      {
                                        sscanf(buffer, "%i,%i,%i", &a[0], &a[1], &a[2]);
                                        if (a[0])
                                          {
                                            cout << "  " << a[0] << ": " << a[1] << ", " << a[2] << endl;
                                            for (int i = 0; i < 3; ++i)
                                              data_objects[3*data_numberofobjects+i] = a[i];
                                            data_numberofobjects++;
                                          }
                                      }
                                  }
                                data_objects[3*data_numberofobjects] = 0;
                                cout << "  done" << endl;
*/

                                cout << "Writing output file" << endl;
                                int count = 0;
                                count += fwrite(&data_center_width,  1,   1, out);
                                count += fwrite(&data_center_height, 1,   1, out);
                                count += fwrite(data_table,          1, 256, out);
                                count += fwrite(data_center_map,     1, data_center_width*data_center_height, out);
                                count += fwrite(data_back_map,       1, data_back_width  *data_back_height,   out);
                                count += fwrite(data_objects,        1, 3*data_numberofobjects+1,             out);
                                cout << "  done (" << count << " bytes)" << endl;

                              }

                            if (data_back_map)   delete[] data_back_map;
                            if (data_center_map) delete[] data_center_map;

                            fclose(out);
                          }
                        fclose(objectslayer);
                      }
                    fclose(backlayer);
                  }
                fclose(centerlayer);
              }
            fclose(table);
          }
        cout << "Program complete" << endl;
      }
    return 0;
  }