// WL_ACT1.C

#include "WL_DEF.H"
#pragma hdrstop

/*
=============================================================================

                                                        STATICS

=============================================================================
*/


statobj_t       statobjlist[MAXSTATS];
statobj_t       *laststatobj;


struct
{
        short           picnum;
        stat_t  type;
} statinfo[] =
{

{SPR_OBJ_01,bo_treas1},
{SPR_OBJ_02,bo_treas2},
{SPR_OBJ_03,bo_treas3},
{SPR_OBJ_04,bo_treas4},
{SPR_OBJ_05,bo_treas5},
{SPR_OBJ_06,bo_treas6},
{SPR_OBJ_07,bo_treas7},
{SPR_OBJ_08,bo_treas8},
{SPR_OBJ_09,bo_25clip},
{SPR_OBJ_10},                   // Hint bubble
{SPR_OBJ_11,dir_south},                   // Cobwebs E/W
{SPR_OBJ_12,dir_east},                   // Cobwebs N/S
{SPR_OBJ_13,block},             // Cabinet w/eagle
{SPR_OBJ_14,block},             // Cabinet w/lamp and books
{SPR_OBJ_15,block},             // Reaper statue
{SPR_OBJ_16,block},             // Pedastool
{SPR_OBJ_17,block},             // Lamp
{SPR_OBJ_18},                   // Large overhead bulb

{SPR_STAT_0},                                   // puddle          spr1v
{SPR_STAT_1,block},                             // Green Barrel    "
{SPR_STAT_2,block},                             // Table/chairs    "
{SPR_STAT_3,block},                             // Floor lamp      "
{SPR_STAT_4},                                   // Chandelier      "
{SPR_STAT_5,block},                             // Hanged man      "
{SPR_STAT_6,bo_alpo},                   // Bad food        "
{SPR_STAT_7,block},                             // Red pillar      "
//
// NEW PAGE
//
{SPR_STAT_8,block},                             // Tree            spr2v
{SPR_STAT_9},                                   // Skeleton flat   "
{SPR_STAT_10,block},                    // Sink            " (SOD:gibs)
{SPR_STAT_11,block},                    // Potted plant    "
{SPR_STAT_12,block},                    // Urn             "
{SPR_STAT_13,block},                    // Bare table      "
{SPR_STAT_14},                                  // Ceiling light   "
#ifndef SPEAR
{SPR_STAT_15},                                  // Kitchen stuff   "
#else
{SPR_STAT_15,block},                    // Gibs!
#endif
//
// NEW PAGE
//
{SPR_STAT_16,block},                    // suit of armor   spr3v
{SPR_STAT_17,block},                    // Hanging cage    "
{SPR_STAT_18,block},                    // SkeletoninCage  "
{SPR_STAT_19},                                  // Skeleton relax  "
{SPR_STAT_20,bo_key1},                  // Key 1           "
{SPR_STAT_21,bo_key2},                  // Key 2           "
{SPR_STAT_22,block},                    // stuff                                (SOD:gibs)
{SPR_STAT_23},                                  // stuff
//
// NEW PAGE
//
{SPR_STAT_24,bo_food},                  // Good food       spr4v
{SPR_STAT_25,bo_firstaid},              // First aid       "
{SPR_STAT_26,bo_clip},                  // Clip            "
{SPR_STAT_27,bo_machinegun},    // Machine gun     "
{SPR_STAT_28,bo_chaingun},              // Gatling gun     "
{SPR_STAT_29,bo_cross},                 // Cross           "
{SPR_STAT_30,bo_chalice},               // Chalice         "
{SPR_STAT_31,bo_bible},                 // Bible           "
//
// NEW PAGE
//
{SPR_STAT_32,bo_crown},                 // crown           spr5v
{SPR_STAT_33,bo_fullheal},              // one up          "
{SPR_STAT_34,bo_gibs},                  // gibs            "
{SPR_STAT_35,block},                    // barrel          "
{SPR_STAT_36,block},                    // well            "
{SPR_STAT_37,block},                    // Empty well      "
{SPR_STAT_38,bo_gibs},                  // Gibs 2          "
{SPR_STAT_39,block},                    // flag                         "
//
// NEW PAGE
//
#ifndef SPEAR
{SPR_STAT_40,block},                    // Call Apogee          spr7v
#else
{SPR_STAT_40},                                  // Red light
#endif
//
// NEW PAGE
//
{SPR_STAT_41},                                  // junk            "
{SPR_STAT_42},                                  // junk                    "
{SPR_STAT_43},                                  // junk            "
#ifndef SPEAR
{SPR_STAT_44},                                  // pots            "
#else
{SPR_STAT_44,block},                    // Gibs!
#endif
{SPR_STAT_45,block},                    // stove           " (SOD:gibs)
{SPR_STAT_46,block},                    // spears          " (SOD:gibs)
{SPR_STAT_47},                                  // vines                        "
//
// NEW PAGE
//
#ifdef SPEAR
{SPR_STAT_48,block},                    // marble pillar
{SPR_STAT_49,bo_25clip},                // bonus 25 clip
{SPR_STAT_50,block},                    // truck
{SPR_STAT_51,bo_spear},                 // SPEAR OF DESTINY!
#endif

{SPR_STAT_26,bo_clip2},                 // Clip            "

{SPR_OBJ_19,block},                     // Bushes w/rocks
{SPR_OBJ_20,block},                     // Plant in grey jar
{SPR_OBJ_21},                           // Belt of bullets
{SPR_OBJ_22,block},                     // Black flag
{SPR_OBJ_23,block},                     // Bunk beds
{SPR_OBJ_24,block},                     // Rectangular brown table
{SPR_OBJ_25,block},                     // Table w/eagle
{SPR_OBJ_26,block},                     // Trash can
{SPR_OBJ_27,block},                     // Tree
{SPR_OBJ_28,block},                     // Truck front
{SPR_OBJ_29},                           // Blue overhead light  :-)
{SPR_OBJ_30,bo_key3},                   // Key 3
{SPR_OBJ_31,bo_key4},                   // Key 4
{SPR_OBJ_32,block},                     // Ammo crate
{TABL_EMPTY,block},                     // Table - empty
{TABL_ITEM1,block},                     // Table w/key 1
{TABL_ITEM2,block},                     // Table w/key 2
{TABL_ITEM3,block},                     // Table w/turkey
{TABL_ITEM4,block},                     // Table w/medkit
{TABL_ITEM5,block},                     // Table w/ammo box
{FOOD_EMPTY},                           // Empty turkey plate
{CRAT_EMPTY,block},                     // Empty ammo crate
{TABL_ANIM0,anim_block},                // Table w/candle (lit)


{-1}                                                    // terminator
};

/*
===============
=
= InitStaticList
=
===============
*/

void InitStaticList (void)
{
        laststatobj = &statobjlist[0];
}



/*
===============
=
= SpawnStatic
=
===============
*/

void SpawnStatic (int tilex, int tiley, int type)
{
        laststatobj->shapenum = statinfo[type].picnum;
        laststatobj->tilex = tilex;
        laststatobj->tiley = tiley;
        laststatobj->visspot = &spotvis[tilex][tiley];

        switch (statinfo[type].type)
        {
        case block:
                actorat[tilex][tiley] = (objtype *) 64;          // consider it a blocking tile
        case dressing:
                laststatobj->flags = 0;
                break;

        case    bo_cross:
        case    bo_chalice:
        case    bo_bible:
        case    bo_crown:
        case    bo_treas1:
        case    bo_treas2:
        case    bo_treas3:
        case    bo_treas4:
        case    bo_treas5:
        case    bo_treas6:
        case    bo_treas7:
        case    bo_treas8:
        case    bo_fullheal:
                if (!loadedgame)
                  gamestate.treasuretotal++;

        case    bo_firstaid:
        case    bo_key1:
        case    bo_key2:
        case    bo_key3:
        case    bo_key4:
        case    bo_clip:
        case    bo_25clip:
        case    bo_machinegun:
        case    bo_chaingun:
        case    bo_food:
        case    bo_alpo:
        case    bo_gibs:
        case    bo_spear:
                laststatobj->flags = FL_BONUS;
                laststatobj->itemnumber = statinfo[type].type;
                break;

   case bl_dir_south:
   case bl_dir_south_fw:
   case bl_dir_south_bw:
      actorat[tilex][tiley] = (objtype *) 64; // consider it a blocking tile
   case dir_south:
   case dir_south_fw:
   case dir_south_bw:
      laststatobj->flags=FL_DIRSOUTH;
      break;
   case bl_dir_east:
   case bl_dir_east_fw:
   case bl_dir_east_bw:
      actorat[tilex][tiley] = (objtype *) 64; // consider it a blocking tile
   case dir_east:
   case dir_east_fw:
   case dir_east_bw:
      laststatobj->flags=FL_DIREAST;
      break;
   }
   switch(statinfo[type].type)
   {
      case dir_south_fw:
      case bl_dir_south_fw:
      case dir_east_fw:
      case bl_dir_east_fw:
         laststatobj->flags|=FL_DIRFORWARD;
         break;
      case dir_south_bw:
      case bl_dir_south_bw:
      case dir_east_bw:
      case bl_dir_east_bw:
         laststatobj->flags|=FL_DIRBACKWARD;
         break;

        case    anim_block:
                actorat[tilex][tiley] = (objtype *) 64;          // consider it a blocking tile
        case    anim:
                laststatobj->flags = FL_ANIMATED;
                break;

}

        laststatobj++;

        if (laststatobj == &statobjlist[MAXSTATS])
                Quit ("Too many static objects!\n");
}


/*
===============
=
= PlaceItemType
=
= Called during game play to drop actors' items.  It finds the proper
= item number based on the item type (bo_???).  If there are no free item
= spots, nothing is done.
=
===============
*/

void PlaceItemType (int itemtype, int tilex, int tiley)
{
        int                     type;
        statobj_t       *spot;

//
// find the item number
//
        for (type=0 ;  ; type++)
        {
                if (statinfo[type].picnum == -1)                // end of list
                        Quit ("PlaceItemType: couldn't find type!");
                if (statinfo[type].type == itemtype)
                        break;
        }

//
// find a spot in statobjlist to put it in
//
        for (spot=&statobjlist[0] ; ; spot++)
        {
                if (spot==laststatobj)
                {
                        if (spot == &statobjlist[MAXSTATS])
                                return;                                                 // no free spots
                        laststatobj++;                                          // space at end
                        break;
                }

                if (spot->shapenum == -1)                               // -1 is a free spot
                        break;
        }
//
// place it
//
        spot->shapenum = statinfo[type].picnum;
        spot->tilex = tilex;
        spot->tiley = tiley;
        spot->visspot = &spotvis[tilex][tiley];
        spot->flags = FL_BONUS;
        spot->itemnumber = statinfo[type].type;
}



/*
=============================================================================

                                                        DOORS

doorobjlist[] holds most of the information for the doors

doorposition[] holds the amount the door is open, ranging from 0 to 0xffff
        this is directly accessed by AsmRefresh during rendering

The number of doors is limited to 64 because a spot in tilemap holds the
        door number in the low 6 bits, with the high bit meaning a door center
        and bit 6 meaning a door side tile

Open doors conect two areas, so sounds will travel between them and sight
        will be checked when the player is in a connected area.

Areaconnect is incremented/decremented by each door. If >0 they connect

Every time a door opens or closes the areabyplayer matrix gets recalculated.
        An area is true if it connects with the player's current spor.

=============================================================================
*/

#define DOORWIDTH       0x7800
#define OPENTICS        300

doorobj_t       doorobjlist[MAXDOORS],*lastdoorobj;
short                   doornum;

word doorposition[MAXDOORS];            // leading edge of door 0=closed
                                                                                // 0xffff = fully open

byte            areaconnect[NUMAREAS][NUMAREAS];

boolean         areabyplayer[NUMAREAS];


/*
==============
=
= ConnectAreas
=
= Scans outward from playerarea, marking all connected areas
=
==============
*/

void RecursiveConnect (int areanumber)
{
        int     i;

        for (i=0;i<NUMAREAS;i++)
        {
                if (areaconnect[areanumber][i] && !areabyplayer[i])
                {
                        areabyplayer[i] = true;
                        RecursiveConnect (i);
                }
        }
}


void ConnectAreas (void)
{
        memset (areabyplayer,0,sizeof(areabyplayer));
        areabyplayer[player->areanumber] = true;
        RecursiveConnect (player->areanumber);
}


void InitAreas (void)
{
        if (player->areanumber < NUMAREAS)
        {
                memset (areabyplayer,0,sizeof(areabyplayer));
                areabyplayer[player->areanumber] = true;
        }
}



/*
===============
=
= InitDoorList
=
===============
*/

void InitDoorList (void)
{
        memset (areabyplayer,0,sizeof(areabyplayer));
        memset (areaconnect,0,sizeof(areaconnect));

        lastdoorobj = &doorobjlist[0];
        doornum = 0;
}


/*
===============
=
= SpawnDoor
=
===============
*/

void SpawnDoor (int tilex, int tiley, boolean vertical, int lock)
{
        word *map;

        if (doornum==MAXDOORS)
                Quit ("64+ doors on level!");

        doorposition[doornum] = 0;              // doors start out fully closed
        lastdoorobj->tilex = tilex;
        lastdoorobj->tiley = tiley;
        lastdoorobj->vertical = vertical;
        lastdoorobj->lock = lock;
        lastdoorobj->action = dr_closed;

        actorat[tilex][tiley] = (objtype *) (doornum | 0x80);   // consider it a solid wall

//
// make the door tile a special tile, and mark the adjacent tiles
// for door sides
//
        tilemap[tilex][tiley] = doornum | 0x80;
        map = mapsegs[0] + (tiley<<mapshift) +tilex;
        if (vertical)
        {
                *map = *(map-1);                        // set area number
                tilemap[tilex][tiley-1] |= 0x40;
                tilemap[tilex][tiley+1] |= 0x40;
        }
        else
        {
                *map = *(map-mapwidth);                                 // set area number
                tilemap[tilex-1][tiley] |= 0x40;
                tilemap[tilex+1][tiley] |= 0x40;
        }

        doornum++;
        lastdoorobj++;
}

//===========================================================================

/*
=====================
=
= OpenDoor
=
=====================
*/

void OpenDoor (int door)
{
        if (doorobjlist[door].action == dr_open)
                doorobjlist[door].ticcount = 0;                 // reset open time
        else
                doorobjlist[door].action = dr_opening;  // start it opening
}


/*
=====================
=
= CloseDoor
=
=====================
*/

void CloseDoor (int door)
{
        int     tilex,tiley,area;
        objtype *check;

//
// don't close on anything solid
//
        tilex = doorobjlist[door].tilex;
        tiley = doorobjlist[door].tiley;

        if (actorat[tilex][tiley])
                return;

        if (player->tilex == tilex && player->tiley == tiley)
                return;

        if (doorobjlist[door].vertical)
        {
                if ( player->tiley == tiley )
                {
                        if ( ((player->x+MINDIST) >>TILESHIFT) == tilex )
                                return;
                        if ( ((player->x-MINDIST) >>TILESHIFT) == tilex )
                                return;
                }
                check = actorat[tilex-1][tiley];
                if (check && ((check->x+MINDIST) >> TILESHIFT) == tilex )
                        return;
                check = actorat[tilex+1][tiley];
                if (check && ((check->x-MINDIST) >> TILESHIFT) == tilex )
                        return;
        }
        else if (!doorobjlist[door].vertical)
        {
                if (player->tilex == tilex)
                {
                        if ( ((player->y+MINDIST) >>TILESHIFT) == tiley )
                                return;
                        if ( ((player->y-MINDIST) >>TILESHIFT) == tiley )
                                return;
                }
                check = actorat[tilex][tiley-1];
                if (check && ((check->y+MINDIST) >> TILESHIFT) == tiley )
                        return;
                check = actorat[tilex][tiley+1];
                if (check && ((check->y-MINDIST) >> TILESHIFT) == tiley )
                        return;
        }


//
// play door sound if in a connected area
//
        area = *(mapsegs[0] + (doorobjlist[door].tiley<<mapshift)
                        +doorobjlist[door].tilex)-AREATILE;
        if (areabyplayer[area])
        {
                PlaySoundLocTile(CLOSEDOORSND,doorobjlist[door].tilex,doorobjlist[door].tiley); // JAB
        }

        doorobjlist[door].action = dr_closing;
//
// make the door space solid
//
        actorat[tilex][tiley] = (objtype *) (door | 0x80);
}



/*
=====================
=
= OperateDoor
=
= The player wants to change the door's direction
=
=====================
*/

void OperateDoor (int door)
{
        int     lock;

        lock = doorobjlist[door].lock;
        if (lock >= dr_lock1 && lock <= dr_lock4)
        {
                if ( ! (gamestate.keys & (1 << (lock-dr_lock1) ) ) )
                {
                        SD_PlaySound (NOWAYSND);                // locked
                        return;
                }
        }

        switch (doorobjlist[door].action)
        {
        case dr_closed:
        case dr_closing:
                OpenDoor (door);
                break;
        case dr_open:
        case dr_opening:
                CloseDoor (door);
                break;
        }
}


//===========================================================================

/*
===============
=
= DoorOpen
=
= Close the door after three seconds
=
===============
*/

void DoorOpen (int door)
{
        if ( (doorobjlist[door].ticcount += (short) tics) >= OPENTICS)
                CloseDoor (door);
}



/*
===============
=
= DoorOpening
=
===============
*/

void DoorOpening (int door)
{
        unsigned             area1,area2;
        word *map;
        long    position;

        position = doorposition[door];
        if (!position)
        {
        //
        // door is just starting to open, so connect the areas
        //
                map = mapsegs[0] + (doorobjlist[door].tiley<<mapshift)
                        +doorobjlist[door].tilex;

                if (doorobjlist[door].vertical)
                {
                        area1 = *(map+1);
                        area2 = *(map-1);
                }
                else
                {
                        area1 = *(map-mapwidth);
                        area2 = *(map+mapwidth);
                }
                area1 -= AREATILE;
                area2 -= AREATILE;

                if (area1 < NUMAREAS && area2 < NUMAREAS)
                {
                        areaconnect[area1][area2]++;
                        areaconnect[area2][area1]++;

                        if (player->areanumber < NUMAREAS)
                                ConnectAreas ();

                        if (areabyplayer[area1])
                                PlaySoundLocTile(OPENDOORSND,doorobjlist[door].tilex,doorobjlist[door].tiley);  // JAB
                }
        }

//
// slide the door by an adaptive amount
//
        position += tics<<10;
        if (position >= 0xffff)
        {
        //
        // door is all the way open
        //
                position = 0xffff;
                doorobjlist[door].ticcount = 0;
                doorobjlist[door].action = dr_open;
                actorat[doorobjlist[door].tilex][doorobjlist[door].tiley] = 0;
        }

        doorposition[door] = (word) position;
}


/*
===============
=
= DoorClosing
=
===============
*/

void DoorClosing (int door)
{
        unsigned             area1,area2;//,move;
        word *map;
        long    position;
        int             tilex,tiley;

        tilex = doorobjlist[door].tilex;
        tiley = doorobjlist[door].tiley;

        if ( ((unsigned)actorat[tilex][tiley] != (door | 0x80))
        || (player->tilex == tilex && player->tiley == tiley) )
        {                       // something got inside the door
                OpenDoor (door);
                return;
        };

        position = doorposition[door];

//
// slide the door by an adaptive amount
//
        position -= tics<<10;
        if (position <= 0)
        {
        //
        // door is closed all the way, so disconnect the areas
        //
                position = 0;

                doorobjlist[door].action = dr_closed;

                map = mapsegs[0] + (doorobjlist[door].tiley<<mapshift) + doorobjlist[door].tilex;

                if (doorobjlist[door].vertical)
                {
                        area1 = *(map+1);
                        area2 = *(map-1);
                }
                else
                {
                        area1 = *(map-mapwidth);
                        area2 = *(map+mapwidth);
                }
                area1 -= AREATILE;
                area2 -= AREATILE;

                if (area1 < NUMAREAS && area2 < NUMAREAS)
                {
                        areaconnect[area1][area2]--;
                        areaconnect[area2][area1]--;

                        if (player->areanumber < NUMAREAS)
                                ConnectAreas ();
                }
        }

        doorposition[door] = (word) position;
}




/*
=====================
=
= MoveDoors
=
= Called from PlayLoop
=
=====================
*/

void MoveDoors (void)
{
        int             door;

        if (gamestate.victoryflag)              // don't move door during victory sequence
                return;

        for (door = 0 ; door < doornum ; door++)
                switch (doorobjlist[door].action)
                {
                case dr_open:
                        DoorOpen (door);
                        break;

                case dr_opening:
                        DoorOpening(door);
                        break;

                case dr_closing:
                        DoorClosing(door);
                        break;
                }
}


/*
=============================================================================

                                                PUSHABLE WALLS

=============================================================================
*/

word pwallstate;
word pwallpos;                  // amount a pushable wall has been moved (0-63)
word pwallx,pwally;
byte pwalldir,pwalltile;
int dirs[4][2]={{0,-1},{1,0},{0,1},{-1,0}};

char PushwallSteps = 0;

/*
===============
=
= PushWall
=
===============
*/

void PushWall (int checkx, int checky, int dir)
{
        int oldtile, dx, dy;

        if (pwallstate)
           return;


        oldtile = tilemap[checkx][checky];
        if (!oldtile)
           return;

                  dx = dirs[dir][0];
                  dy = dirs[dir][1];

        if (actorat[checkx+dx][checky+dy])
        {
            SD_PlaySound (NOWAYSND);
            return;
        }
        actorat[checkx+dx][checky+dy] = (objtype *) (tilemap[checkx+dx][checky+dy] = oldtile);

        gamestate.secretcount++;
        pwallx = checkx;
        pwally = checky;
        pwalldir = dir;
        pwallstate = 1;
        pwallpos = 0;
        pwalltile = tilemap[pwallx][pwally];
        tilemap[pwallx][pwally] = 64;
                  tilemap[pwallx+dx][pwally+dy] = 64;
        *(mapsegs[1]+(pwally<<mapshift)+pwallx) = 0;   // remove P tile info
        *(mapsegs[0]+(pwally<<mapshift)+pwallx) = *(mapsegs[0]+(player->tiley<<mapshift)+player->tilex); // set correct floorcode (BrotherTank's fix)

        SD_PlaySound (PUSHWALLSND);
}



/*
=================
=
= MovePWalls
=
=================
*/

void MovePWalls (void)
{
        int             oldblock,oldtile;
                  static int ppressed = 0;
                  static long ptimecount = 0;

        if (!pwallstate)
                return;

        oldblock = pwallstate/128;

#ifdef DEBUGKEYS                  
                  if(PushwallSteps)
                  {
                          if(ppressed)
                          {
                                  if(Keyboard[sc_P] && TimeCount-ptimecount<10) return;
                                  ppressed=0;                             
                                  return;
                          }
                          if(!Keyboard[sc_P]) return;
                          ppressed=1;
                          ptimecount = TimeCount;

                          pwallstate += 4;
                  }
                  else
#endif
                          pwallstate += (word)tics;

        if (pwallstate/128 != oldblock)
        {
                // block crossed into a new block
                oldtile = pwalltile; // tilemap[pwallx][pwally] & 63;

                //
                // the tile can now be walked into
                //
                tilemap[pwallx][pwally] = 0;
                actorat[pwallx][pwally] = 0;
                *(mapsegs[0]+(pwally<<mapshift)+pwallx) = player->areanumber+AREATILE;

                                         int dx=dirs[pwalldir][0], dy=dirs[pwalldir][1];
                //
                // see if it should be pushed farther
                //
                if (pwallstate>=256)            // only move two tiles fix
                {
                //
                // the block has been pushed two tiles
                //
                        pwallstate = 0;
                                                                tilemap[pwallx+dx][pwally+dy] = oldtile;
                        return;
                }
                else
                {
                                                                int xl,yl,xh,yh;
                                                                xl = (player->x-PLAYERSIZE) >> TILESHIFT;
                                                                yl = (player->y-PLAYERSIZE) >> TILESHIFT;
                                                                xh = (player->x+PLAYERSIZE) >> TILESHIFT;
                                                                yh = (player->y+PLAYERSIZE) >> TILESHIFT;
                                                                
                                                                pwallx+=dx;
                                                                pwally+=dy;
                                                                
                        if (actorat[pwallx+dx][pwally+dy]
                                                                        || xl<=pwallx+dx && pwallx+dx<=xh && yl<=pwally+dy && pwally+dy<=yh)
                        {
                           pwallstate = 0;
                                                                        tilemap[pwallx][pwally] = oldtile;
                           return;
                        }
                        actorat[pwallx+dx][pwally+dy] = (objtype *) (tilemap[pwallx+dx][pwally+dy] = oldtile);
                                                                tilemap[pwallx+dx][pwally+dy] = 64;
                }
        }

        pwallpos = (pwallstate/2)&63;
}

