/*
 * Copyright (C) 1995-1997 Christopher D. Granz
 *
 * This header may not be removed.
 *
 * Refer to the file "License" included in this package for further
 * information and before using any of the following.
 */

#include <stdio.h>
#include <stdlib.h>

#include "sapphire.h"


/*
 * Functions
 */
void game_update( void )
{
    register ROOM_INDEX_DATA *pRoom, *pRoom2;
    register CHAR_DATA *pChar;
    register OBJ_DATA *pObj;
    register SCRIPT_DATA *pScript;
    register TRIGGER_DATA *pTrigger;
    register RUNNING_SCRIPT_DATA *pRunning;
    RUNNING_SCRIPT_DATA *pRunningNext;
    register int ri;
    register int riDoor;
    static intt iWanderTimer;

    iWanderTimer++;

    for ( ri = 0; ri < iHashListSize; ri++ )
    {
        for ( pChar = ppCharList[ri]; pChar; pChar = pChar->pNext )
        {
            if ( pChar->iWaitTimer > 0 )
                pChar->iWaitTimer--;

            if ( !IS_NPC( pChar ) || pChar->pTerm != NULL
              || ( pRoom = pChar->pInRoom ) == NULL )
                continue;

            if ( pChar->pNPCData->pProgram != NULL )
            {
                for ( pScript = pChar->pNPCData->pProgram->pScripts;
                  pScript != NULL; pScript = pScript->pNext )
                {
                    if ( pScript->bDisabled != TRUE
                      && pScript->bRunning != TRUE )
                    {
                        for ( pTrigger = pScript->pTriggers; pTrigger;
                          pTrigger = pTrigger->pNext )
                        {
                            if ( pTrigger->iTrigger
                              == NUMBER_NPC_TRIGGER_RANDOM
                              && random_percent( )
                              < (intt) *pTrigger->pArgs->pArg )
                            {
                                execute_npc_script(
                                  pChar->pNPCData->pProgram, pScript,
                                  NULL, pChar, NULL, NULL );
                                break;
                            }
                        }
                    }
                }
            }

            if ( iWanderTimer < 5 )
                continue;

            if ( pChar->pNPCData->iWander > 0 )
            {
                riDoor = random_door( );

                if ( random_percent( ) < pChar->pNPCData->iWander
                  || ( pRoom2 = pRoom->eExits[riDoor].uRoom.pRoom ) == NULL
                  || IS_SET( pRoom2->fRoomFlags, FLAG_ROOM_NO_NPCS )
                  || ( IS_SET( pChar->pNPCData->fNPCFlags,
                  FLAG_NPC_STAY_INSIDE )
                  && pRoom2->iSectorType != NUMBER_SECTOR_UNDEFINED
                  && pRoom2->iSectorType != NUMBER_SECTOR_UNDERGROUND
                  && pRoom2->iSectorType != NUMBER_SECTOR_INSIDE )
                  || ( IS_SET( pChar->pNPCData->fNPCFlags,
                  FLAG_NPC_STAY_OUTSIDE )
                  && pRoom2->iSectorType != NUMBER_SECTOR_UNDEFINED
                  && pRoom2->iSectorType != NUMBER_SECTOR_VOID
                  && pRoom2->iSectorType != NUMBER_SECTOR_WATER
                  && pRoom2->iSectorType != NUMBER_SECTOR_WATER_NO_SWIM
                  && pRoom2->iSectorType != NUMBER_SECTOR_CITY ) )
                    continue;

                move_char( pChar, riDoor );
            }
        }
    }

    if ( iWanderTimer >= 5 )
        iWanderTimer = 0;

    for ( ri = 0; ri < iHashListSize; ri++ )
    {
        for ( pObj = ppObjList[ri]; pObj; pObj = pObj->pNext )
        {
            if ( pObj->pProgram != NULL )
            {
                for ( pScript = pObj->pProgram->pScripts; pScript != NULL;
                  pScript = pScript->pNext )
                {
                    if ( pScript->bDisabled != TRUE
                      && pScript->bRunning != TRUE )
                    {
                        for ( pTrigger = pScript->pTriggers; pTrigger;
                          pTrigger = pTrigger->pNext )
                        {
                            if ( pTrigger->iTrigger
                              == NUMBER_OBJ_TRIGGER_RANDOM
                              && random_percent( )
                              < (intt) *pTrigger->pArgs->pArg )
                            {
                                execute_obj_script( pObj->pProgram,
                                  pScript, pObj );
                                break;
                            }
                        }
                    }
                }
            }
        }
    }

    for ( ri = 0; ri < iHashListSize; ri++ )
    {
        for ( pRoom = ppRoomIndexList[ri]; pRoom; pRoom = pRoom->pNext )
        {
            if ( pRoom->pProgram != NULL )
            {
                for ( pScript = pRoom->pProgram->pScripts; pScript;
                  pScript = pScript->pNext )
                {
                    if ( pScript->bDisabled != TRUE
                      && pScript->bRunning != TRUE )
                    {
                        for ( pTrigger = pScript->pTriggers; pTrigger;
                          pTrigger = pTrigger->pNext )
                        {
                            if ( pTrigger->iTrigger
                              == NUMBER_ROOM_TRIGGER_RANDOM
                              && random_percent( )
                              < (intt) *pTrigger->pArgs->pArg )
                            {
                                execute_room_script( pRoom->pProgram,
                                  pScript, NULL, pRoom, NULL, NULL );
                                break;
                            }
                        }
                    }
                }
            }
        }
    }

    for ( pRunning = pRunningScriptList; pRunning != NULL;
      pRunning = pRunningNext )
    {
        pRunningNext = pRunning->pNext;

        switch ( pRunning->iThisType )
        {
          case NUMBER_VAR_POINTER_CHAR:
              execute_npc_script( NULL, NULL, pRunning, NULL, NULL,
                NULL );
              break;

          case NUMBER_VAR_POINTER_OBJ :
              execute_obj_script( NULL, NULL, NULL );
              break;

          case NUMBER_VAR_POINTER_ROOM:
              execute_room_script( NULL, NULL, pRunning, NULL, NULL,
                NULL );
              break;
        }
    }

    reset_rooms( );
}


/*
 * Deals with setting up and timming all resets.
 */
void reset_rooms( void )
{
    register ROOM_INDEX_DATA *pRoom;
    register NPC_RESET_DATA *pNPCReset;
    register OBJ_RESET_DATA *pObjReset;
    register CHAR_DATA *pChar;
    register OBJ_DATA *pObj;
    register int ri;
    register intt ri2;
    register bool rbResetHappened;

    for ( ri = 0; ri < iHashListSize; ri++ )
    {
        for ( pRoom = ppRoomIndexList[ri]; pRoom; pRoom = pRoom->pNext )
        {
            rbResetHappened                     = FALSE;

            for ( ri2 = 0; ri2 < 10; ri2++ )
            {
                if ( pRoom->eExits[ri2].uRoom.pRoom == NULL
                  || pRoom->eExits[ri2].iResetTime < 0 )
                    continue;

                pRoom->eExits[ri2].iResetTimer++;

                if ( pRoom->eExits[ri2].iResetTimer
                  >= pRoom->eExits[ri2].iResetTime )
                {
                    pRoom->eExits[ri2].fCurrFlags
                                           = pRoom->eExits[ri2].fOrigFlags;
                    pRoom->eExits[ri2].iResetTimer = -1;
                    rbResetHappened                = TRUE;
                }
            }

            for ( pNPCReset = pRoom->pNPCResets; pNPCReset != NULL;
              pNPCReset = pNPCReset->pNext )
            {
                if ( pNPCReset->iResetTime < 0 )
                    continue;

                if ( pNPCReset->bAlive != TRUE )
                {
                    pNPCReset->iResetTimer++;

                    if ( pNPCReset->iResetTimer >= pNPCReset->iResetTime )
                    {
                        pNPCReset->iResetTimer  = -1;
                        pNPCReset->bAlive       = TRUE;
                        pChar = new_npc( pNPCReset->u1.pNPCIndex, NULL );
                        pChar->pNPCData->pReset = pNPCReset;
                        char_to_room( pChar, pRoom );
                        rbResetHappened         = TRUE;
                    }
                }
            }

            for ( pObjReset = pRoom->pObjResets; pObjReset != NULL;
              pObjReset = pObjReset->pNext )
            {
                if ( pObjReset->iResetTime < 0 )
                    continue;

                if ( pObjReset->bAlive != TRUE )
                {
                    pObjReset->iResetTimer++;

                    if ( pObjReset->iResetTimer >= pObjReset->iResetTime )
                    {
                        pObjReset->iResetTimer  = -1;
                        pObjReset->bAlive       = TRUE;
                        pObj  = new_object( pObjReset->u1.pObjIndex,
                                  NULL );
                        pObj->pReset            = pObjReset;
                        obj_to_room( pObj, pRoom );
                        rbResetHappened         = TRUE;
                    }
                }
            }
#if 0
            if ( rbResetHappened == TRUE )
                send_game_message( "Time passes.", MESSAGE_DEST_ROOM, TRUE,
                  NULL, NULL, pRoom, FALSE, NUMBER_POSITION_DYING );
#endif
        }
    }
}


/*
 * Creates a list of content objects from a list of object resets.
 */
OBJ_DATA *reset_objects( OBJ_RESET_DATA *pObjResets )
{
    return ( NULL ); /* Not finished. */
}


/*
 * End of update.c
 */