// ***********************************************
// MAPSETUP.H - stuff used only by map initialisation
// ***********************************************

// **** includes
#include "addrs.h"
#include "useful.h"
#include "global.h"

#include "creation.h"
#include "calcs.h"
#include "mapsetup.h"

// **** private function prototypes
void setCollideMask(MAPINFO *tMap, u_char tX, u_char tZ, u_char tW, u_char tH, short *tVec, short, short);
void setCollideOne(MAPINFO *tMap, u_long tX, u_long tZ);

// **** create the map and basically prepare it
void InitCurrentMap(u_char tMap, u_long tMemAddress)
    {
    SVECTOR tOrientation;
    u_long counter;
    tOrientation.vx = tOrientation.vy = tOrientation.vz = 0;

    CurrentMap = &Maps[tMap];

    SetModelInfo(&SKYMODEL, 0, 0, 0, createSky(tMemAddress));
    BitSet(&SKYMODEL.Object_Handler.attribute, GsDIV1);
    SetModelInfo(&GROUNDMODEL, 0, 0, 0, createGround(0));

	// create all the objects in the scene
    for (counter=0; counter<CurrentMap->objects.numObjects; counter++)
        {
        SetModelInfo(
            &OBJECTMODEL[counter], 
            CurrentMap->objects.object[counter].x, 
            CalculateHeight(CurrentMap->objects.object[counter].x, CurrentMap->objects.object[counter].z),
            CurrentMap->objects.object[counter].z, 
            createObject(CurrentMap->objects.object[counter].type, 0,
                            CurrentMap->objects.object[counter].r, 
                            CurrentMap->objects.object[counter].g, 
                            CurrentMap->objects.object[counter].b));
        RotateModel(&OBJECTMODEL[counter], &tOrientation, 
            0, CurrentMap->objects.object[counter].orientation*1024, 0);
        tOrientation.vx = tOrientation.vy = tOrientation.vz =0;
        }

	// create all the characters in the scene
	for (counter=1; counter<21; counter++)
		{
		CHARINFO[counter].state = 0;
		CHARINFO[counter].howToHandle = 0;
		}
	for (counter=0; counter<CurrentMap->numChars; counter++)
        {
//        if (CurrentMap->characters[counter].type == 26) // the bat thingy
//        	{
//        	printf("wibble too  ");
//        	CurrentMap->characters[counter].scaleX = (rand()%20*512+256)<<4;
//        	CurrentMap->characters[counter].scaleZ = (rand()%20*512+256)<<4;
//        	}
//        printf("wibble  ");
        SetModelInfo(
            &CHARINFO[counter+1].charModel, 
            CurrentMap->characters[counter].scaleX>>4, 
            CalculateHeight(
            	CurrentMap->characters[counter].scaleX>>4, 
            	CurrentMap->characters[counter].scaleZ>>4),
            CurrentMap->characters[counter].scaleZ>>4, 
            CurrentMap->characters[counter].modelAddr
			);
//        	printf("wibble  ");
		CHARINFO[counter+1].charVector.vx = 
			CHARINFO[counter+1].charVector.vy = 
			CHARINFO[counter+1].charVector.vz = 0;
//        	printf("wibble  ");
        RotateModel(&CHARINFO[counter+1].charModel, &CHARINFO[counter+1].charVector, 
            0, CurrentMap->characters[counter].orientation*1024, 0);
		CHARINFO[counter+1].scaleX = CurrentMap->characters[counter].scaleX;
		CHARINFO[counter+1].scaleZ = CurrentMap->characters[counter].scaleZ;
        CHARINFO[counter+1].state = CurrentMap->characters[counter].state;
        CHARINFO[counter+1].type = CurrentMap->characters[counter].type;
        CHARINFO[counter+1].howToHandle = CurrentMap->characters[counter].howToHandle;
  //      	printf("wibble  ");

        

//    	printf(" state, type = %d,%d\n", CHARINFO[counter+1].state, CHARINFO[counter+1].type);
//    	printf(" scaleX, scaleY = %d,%d\n", CHARINFO[counter+1].scaleX, CHARINFO[counter+1].scaleZ);
        }
//    printf(" num chars = %d\n", CurrentMap->numChars);
    }

// **** set entrance information
void SetEntrance(MAPINFO* tMap, u_char tNum, u_char tX, u_char tZ, u_char tDirection)
    {
    tMap->entrances[tNum].xPos = tX;
    tMap->entrances[tNum].zPos = tZ;
    tMap->entrances[tNum].direction = tDirection;
    }

// **** set exit information
void SetExit(MAPINFO* tMap, u_char tMapTo, u_char tEntrance, u_char tX0, u_char tZ0, u_char tX1, u_char tZ1)
    {
    tMap->exits.exit[tMap->exits.numExits].x0 = tX0;
    tMap->exits.exit[tMap->exits.numExits].y0 = tZ0;
    tMap->exits.exit[tMap->exits.numExits].x1 = tX1;
    tMap->exits.exit[tMap->exits.numExits].y1 = tZ1;
    tMap->exits.exit[tMap->exits.numExits].mapTo = tMapTo;
    tMap->exits.exit[tMap->exits.numExits].entranceTo = tEntrance;
    tMap->exits.numExits++;
    }

// **** set camera information
void SetCamera(MAPINFO* tMap, long tX, long tY, long tZ, 
        u_char tX0, u_char tY0, u_char tX1, u_char tY1)
    {
    tMap->cameras.camera[tMap->cameras.numCameras].xPos = tX<<9;
    tMap->cameras.camera[tMap->cameras.numCameras].yPos = tY;
    tMap->cameras.camera[tMap->cameras.numCameras].zPos = tZ<<9;
    tMap->cameras.camera[tMap->cameras.numCameras].x0 = tX0;
    tMap->cameras.camera[tMap->cameras.numCameras].y0 = tY0;
    tMap->cameras.camera[tMap->cameras.numCameras].x1 = tX1;
    tMap->cameras.camera[tMap->cameras.numCameras].y1 = tY1;
    tMap->cameras.numCameras++;
    }

// **** set a character in the scene
void SetCharacter(MAPINFO* tMap, u_char tType, u_char tState, u_char tHow, u_long tX, u_long tZ,
            u_char tR, u_char tG, u_char tB, u_char tOrientation, u_long tMemAddress)
    {
    tMap->characters[tMap->numChars].modelAddr = tMemAddress;
    tMap->characters[tMap->numChars].type = tType;
    tMap->characters[tMap->numChars].state = tState;
    tMap->characters[tMap->numChars].howToHandle = tHow;
    tMap->characters[tMap->numChars].scaleX = tX<<4;
    tMap->characters[tMap->numChars].scaleZ = tZ<<4;
    tMap->characters[tMap->numChars].orientation = tOrientation;
    tMap->characters[tMap->numChars].r = tR;
    tMap->characters[tMap->numChars].g = tG;
    tMap->characters[tMap->numChars].b = tB;
    tMap->numChars++;
    }

// **** set object information
void SetObject(MAPINFO* tMap, u_char tType, u_long tX, u_long tZ,
            u_char tR, u_char tG, u_char tB, u_char tOrientation)
    {
    short   tVec[2][2];
    short   tOffX, tOffZ;
    // tMask will cover 5x5 grid as each grid is split into four smaller collision squares
    tMap->objects.object[tMap->objects.numObjects].x = tX * 512;
    tMap->objects.object[tMap->objects.numObjects].z = tZ * 512;

    switch(tOrientation)
        {
        case 0:         tVec[0][0] = 1; tVec[0][1] = 0; tVec[1][0] = 0; tVec[1][1] = 1; tOffX = 0; tOffZ = 0; break;
        case 1:         tVec[0][0] = 0; tVec[0][1] = -1; tVec[1][0] = 1; tVec[1][1] = 0; tOffX = 0; tOffZ = -1; break;
        case 2:         tVec[0][0] = -1; tVec[0][1] = 0; tVec[1][0] = 0; tVec[1][1] = -1; tOffX = -1; tOffZ = -1; break;
        case 3:         tVec[0][0] = 0; tVec[0][1] = 1; tVec[1][0] = -1; tVec[1][1] = 0; tOffX = -1; tOffZ = 0; break;
        }
    
    switch(tType)
        {
        case TREE_TMD:                  setCollideMask(tMap, tX*2, tZ*2, 1, 1, &tVec[0][0], tOffX, tOffZ); break;
        case SMALL_BUILDING_TMD:        setCollideMask(tMap, tX*2, tZ*2, 4, 4, &tVec[0][0], tOffX, tOffZ); break;
        case CHURCH_TMD:                setCollideMask(tMap, tX*2, tZ*2, 4, 4, &tVec[0][0], tOffX, tOffZ); break;
        case TALL_BUILDING_TMD:        	setCollideMask(tMap, tX*2, tZ*2, 4, 4, &tVec[0][0], tOffX, tOffZ); break;
        }

    tMap->objects.object[tMap->objects.numObjects].orientation = tOrientation;
    tMap->objects.object[tMap->objects.numObjects].type = tType;
    tMap->objects.object[tMap->objects.numObjects].r = tR;
    tMap->objects.object[tMap->objects.numObjects].g = tG;
    tMap->objects.object[tMap->objects.numObjects].b = tB;

    tMap->objects.numObjects++;
    }

// **** clear the mask except for the edges, which are ALWAYS solid
void clearCollideMask(MAPINFO* tMap)
    {
    u_long counter, counter2;
    for (counter=0; counter<5; counter++)
        for (counter2=0; counter2<40; counter2++)
            tMap->collide[counter][40] = 0;
    
    for (counter=0; counter<40; counter++)
        {
        setCollideOne(tMap, 0, counter);
        setCollideOne(tMap, 39, counter);
        setCollideOne(tMap, counter, 0);
        setCollideOne(tMap, counter, 39);
        }
    }


// **** set a rectangle on the collision mask
void setCollideMask(MAPINFO *tMap, u_char tX, u_char tZ, u_char tW, u_char tH, 
                    short *tVec, short tOffX, short tOffZ)
    {
    u_long counter, counter2;
    u_long tXpos, tZpos;
    for (counter=0; counter<tW; counter++)
        {
        for (counter2=0; counter2<tH; counter2++)
            {
            tXpos = tX + (counter * tVec[0]) + (counter2 * tVec[2]) + tOffX;
            tZpos = tZ + (counter * tVec[1]) + (counter2 * tVec[3]) + tOffZ;
            setCollideOne(tMap, tXpos, tZpos);
            }
        }
    }

// **** set a rectangle to be on
void setCollideRectangle(MAPINFO* tMap, u_char tX, u_char tZ, u_char tW, u_char tH)
    {
    u_long counter, counter2;
    for (counter=0; counter<tW; counter++)
        for (counter2=0; counter2<tH; counter2++)
            setCollideOne(tMap, counter+tX, counter2+tZ);
    }

// **** set one particular square to be on
void setCollideOne(MAPINFO *tMap, u_long tX, u_long tZ)
    {
    u_char  tByte = tX/8;
    u_char  tPos = tX%8;

    BitSet(&tMap->collide[tByte][tZ], 1<<tPos);
    }

// **** set one particular square to be off
void setCollideOffOne(MAPINFO *tMap, u_long tX, u_long tZ)
    {
    u_char  tByte = tX/8;
    u_char  tPos = tX%8;

    BitClear(&tMap->collide[tByte][tZ], 1<<tPos);
    }

// **** set the colour for the sky and background    
void SetColour(u_char *tArray, u_char tR, u_char tG, u_char tB)
    {
    tArray[0] = tR;
    tArray[1] = tG;
    tArray[2] = tB;
    }

void	ClearMapInfo()
	{
	u_long counter;
	for (counter=0; counter<NUMMAPS; counter++)
		{
		Maps[counter].numChars = 0;
		Maps[counter].exits.numExits = 0;
		Maps[counter].objects.numObjects = 0;
		Maps[counter].cameras.numCameras = 0;
		}
	}