object_structs.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * Additional copyright for this file:
 * Copyright (C) 1999-2000 Revolution Software Ltd.
 * This code is based on source code created by Revolution Software,
 * used with permission.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef ICB_OBSTRUCTS
#define ICB_OBSTRUCTS

#include "engines/icb/common/px_common.h"
#include "engines/icb/common/px_game_object.h"
#include "engines/icb/common/px_route_barriers.h"
#include "engines/icb/common/px_array.h"
#include "engines/icb/common/px_string.h"
#include "engines/icb/animation_mega_set.h"
#include "engines/icb/p4_generic.h"
#include "engines/icb/string_vest.h"
#include "engines/icb/route_manager.h"
#include "engines/icb/breath.h"
#include "engines/icb/gfx/rlp_api.h"
#include "engines/icb/common/px_bones.h"

// depth of script logic tree for game objects - 3 is same as Broken Sword games
#define TREE_SIZE 3

namespace ICB {

// high level walk or run mode for mega/player
// used by high level routing and interaction functionality
enum __motion { __MOTION_WALK, __MOTION_RUN };

// high level armed state
// this will be used to construct the animation path name
enum __weapon {
    __NOT_ARMED,
    __GUN,
    __CROUCH_NOT_ARMED,
    __CROUCH_GUN,
    __TOTAL_WEAPONS, // used for searches
    __NOT_SET        // default - will cause error in fn-set-voxel-path
};

// Added this enum for object type field.
enum __object_type { __NO_TYPE_SET = 0, __BUTTON_OPERATED_DOOR, __RECHARGE_POINT, __ORGANIC_MEGA, __NON_ORGANIC_MEGA, __REMORA_CARRIER, __RECHARGE_POINT_WITH_EMP, __AUTO_DOOR };

#define MAX_WEAPON_NAME_LENGTH 16

extern char weapon_text[__TOTAL_WEAPONS][MAX_WEAPON_NAME_LENGTH];
extern bool8 armed_state_table[__TOTAL_WEAPONS];
extern bool8 crouch_state_table[__TOTAL_WEAPONS];

#define MAX_CHAR_NAME_LENGTH 32
#define MAX_OUTFIT_NAME_LENGTH 16
#define MAX_CUSTOM_NAME_LENGTH 16

#define IMAGE_PATH_STR_LEN 144
#define BASE_PATH_STR_LEN 144
#define ANIM_NAME_STR_LEN 144
#define PALETTE_STR_LEN ENGINE_STRING_LEN

// game objects with voxel images need one of these
// assigned at session start when objects are initialised
class _vox_image { // this is badly named - frame info or something

private:
    int8 anim_table[__TOTAL_ANIMS];

public:
    void ___init(const char *chr, const char *set, __weapon weapon);

    // temprarily store these for swapping between voxel and polygons (so we can call ___init() again...
    // when the voxels go these things can go
    char palette[PALETTE_STR_LEN];
    char temp_chr[128];
    char temp_set[128];
    __weapon temp_weapon;
    char alternativeImagePath[128]; // this stores the pcp path for animations (for getting the raj files instead of rai files...
    char alternativeBasePath[128];  // this is same as base path but is pcp (on voxels) - isn't required for polys and can go when we
                                        // ditch
    // setting functions
    bool8 Init_custom_animation(const char *anim_name);
    bool8 Find_anim_type(__mega_set_names *anim, const char *name);
    bool8 Set_texture(const char *texture_name);
    bool8 Set_palette(const char *palette_name);
    bool8 Set_mesh(const char *mesh_name);
    bool8 Set_override_pose(const char *override_pose_name);
    bool8 Cancel_override_pose();
    void Promote_non_generic();
    int8 IsAnimTable(int32 i);
    void MakeAnimEntry(int32 i);
    int Preload_file(const char *file);

    // those hashs in full

    uint32 anim_name_hash[__TOTAL_ANIMS];
    uint32 info_name_hash[__TOTAL_ANIMS];

    uint32 mesh_hash;        // the name of the base mesh
    uint32 shadow_mesh_hash; // the name of the base shadow mesh
    uint32 palette_hash;     // the name of the palette
    uint32 texture_hash;     // the name of the texture (which includes a default palette)
    uint32 pose_hash;        // the name of the ordinary pose/accessory mesh
    uint32 override_pose_hash; // the name of the pose/accessory mesh overrides the default setting
    uint32 custom_pose_hash; // the name of the "custom" pose/accessory mesh

    // base path

    char base_path[BASE_PATH_STR_LEN];
    uint32 base_path_hash; // hash value of the base_path string

    // init'ed by _vox_image::_vox_image which is created by fn-set-voxel-image-path
    // path primitives - require to build path+name to non generic custom specifics
    char image_path[IMAGE_PATH_STR_LEN]; // i.e. karl\, karl_in_coat\, etc. Initially set by objects init script and then by
                                         // interaction/logic

    bool8 has_custom_path_built; // says whether or not the current custom anim path has been built - done for preloader which builds
                                 // filename early

    // bone deformations

    BoneDeformation neckBone;
    BoneDeformation jawBone;
    BoneDeformation lookBone;
    SVECTOR
    scriptedLookBoneTarget; // this is the one the scripts set - if this is not <0,0,0> then these values override the look targets

    uint8 padding2;
    uint8 padding3;

    // on the pc we store these strings
    char anim_name[__TOTAL_ANIMS][ANIM_NAME_STR_LEN];
    char info_name[__TOTAL_ANIMS][ANIM_NAME_STR_LEN];
    char mesh_name[ANIM_NAME_STR_LEN];
    char shadow_mesh_name[ANIM_NAME_STR_LEN];
    char texture_name[PALETTE_STR_LEN];
    char palette_name[PALETTE_STR_LEN];
    char pose_name[ANIM_NAME_STR_LEN];
    char custom_pose_name[ANIM_NAME_STR_LEN];
    char override_pose_name[ANIM_NAME_STR_LEN];

    // and so the access functions return the
    // actual thing

    char *get_anim_name(int32 i) { return anim_name[i]; }
    char *get_info_name(int32 i) { return info_name[i]; }
    char *get_mesh_name() { return mesh_name; }
    char *get_shadow_mesh_name() { return shadow_mesh_name; }
    char *get_texture_name() { return texture_name; }
    char *get_palette_name() { return palette_name; }
    char *get_pose_name() { return pose_name; }
    char *get_custom_pose_name() { return custom_pose_name; }
    char *get_override_pose_name() { return override_pose_name; }

};

inline int8 _vox_image::IsAnimTable(int32 i) {
    // If the table has not been set yet : make the anim entry which will set anim_table entry to correct value
    if (anim_table[i] == (int8)-1)
        MakeAnimEntry(i);
    return anim_table[i];
}

#define MAX_bars 96

// Handy constants for accesing the viewState member variable
// <last_cycle_state>_<this_cycle_state>
// The <last_cycle_state> (1 or 0) is in bit 0
// The <this_cycle_state> (1 or 0) is in bit 1
enum CameraStateEnum { OFF_CAMERA = 0x0, ON_CAMERA = 0x1 };

#define THIS_CYCLE_SHIFT 1
#define LAST_CYCLE_SHIFT 0
#define LAST_CYCLE_MASK ((1 << THIS_CYCLE_SHIFT) - 1)

#define MAKE_VIEW_STATE(last, this) (last | (this << THIS_CYCLE_SHIFT))

// off camera last cycle and this cycle : 0x0
#define OFF_OFF_CAMERA MAKE_VIEW_STATE(OFF_CAMERA, OFF_CAMERA)

// on camera last cycle and off this cycle : 0x1
#define ON_OFF_CAMERA MAKE_VIEW_STATE(ON_CAMERA, OFF_CAMERA)

// off camera last cycle and on this cycle : 0x2
#define OFF_ON_CAMERA MAKE_VIEW_STATE(OFF_CAMERA, ON_CAMERA)

// on camera last cycle and on this cycle
#define ON_ON_CAMERA MAKE_VIEW_STATE(ON_CAMERA, ON_CAMERA)

#define DEFAULT_HEIGHT 170

class _mega { // mega logic specific
public:
    ParentBox *cur_parent;   // our owner parent box
    uint32 par_number;       // for players abar list update
    uint32 cur_slice;        // for speedups

    uint32 barrier_list[MAX_bars]; // including animating ones
    uint32 nudge_list[MAX_bars];   // only player builds this - i can't be bothered with putting it in the player struct however

    uint32 number_of_barriers;  // kept for safety
    uint32 number_of_nudge;     // kept for safety
    uint32 number_of_animating; // kept for safety

    __mega_set_names next_anim_type; // queued anim to play after current link anim

    // turn on spot pan stuff
    PXfloat target_pan;        // actual relative distance to turn
    PXfloat actual_target_pan; // actual target pan to clip to if necessary

    PXfloat auto_target_pan; // target pan for auto engine pans - i.e. when routing\bumping

    PXfloat looking_pan;

    uint32 target_id;    // hurray! Its back again!! Id of target object
    PXvector target_xyz; // target coordinate - used for position correcting, etc

    __weapon weapon; // what weapon the mega is carrying
    __motion motion; // walking, running, used by high level anim functions

    // To maintain alignment, the sizes of these arrays must be a multiple of 4.
    char chr_name[MAX_CHAR_NAME_LENGTH];     // i.e. cord
    char anim_set[MAX_OUTFIT_NAME_LENGTH];   // i.e. casual_wear
    char custom_set[MAX_CUSTOM_NAME_LENGTH]; // i.e. mine

    // this is the real game-world coordinate
    PXvector actor_xyz;
    PXvector pushed_actor_xyz;

    uint32 m_phase;
    _route_description m_main_route;

    Breath breath;

    int32 height;   // looking height (El Dorado only)

    // the dynamic lamp (with one state only) and a switch as to whether it is on or off (if >0 then it is on for dynLightOn cycles, if
    // 0 then off, if -1 on until explicitly turned off)
    PSXLamp dynLight;                      // the lamp, filled in partly by logic and partly by stagedraw (rotating with character)
    int32 dynLightOn;                      // if 0-off, >0-on for n cycles (count down), -1 - constant until turned off
    int16 dynLightX, dynLightY, dynLightZ; // cm from centre of character (hip) (hip hurray!)

    SVECTOR bulletPos;
    int16 bulletDX;
    int16 bulletDY;
    int16 bulletInitialHeight;

    uint8 bulletBounced, bulletColour;

    bool8 bulletOn;

    // NOTE THAT THE FOLLOWING DATA MEMBERS HAVE BEEN ARRANGED TO MAKE 4-BYTE ALIGNMENT CLEAR.

    // A status flag containing info if the MEGA was in view last cycle,
    // and is in view this cycle, a change in view state causes an event
    // to be sent to the MEGA saying "oncamera" "offcamera"
    bool8 pushed;
    uint8 viewState;
    bool8 interacting; // yes or no to avoid problems interacting with id=0 !!!!
    bool8 turn_dir;    // 0 right       1 left
    bool8 custom;
    bool8 has_exclusive_coords; // if yes then this object will not have coordinates saved to micro-session - player and chi

    bool8 is_evil;          // true if guard or robot, or some other horrible creature, false if lovely chi or some sort of scientist or whatever.
    bool8 make_remora_beep; // true for robots so the remora picks them up

    uint8 inShadePercentage; // how much light to be in shadow
    bool8 in_shade;          // Set to TRUE8 when mega is in shade, FALSE8 otherwise.
    bool8 use_strike_script; // call a script instead of hitting object
    bool8 use_fire_script;   // call a script instead of shooting object

    bool8 on_players_floor;
    uint8 speech_red;
    uint8 speech_green;
    uint8 speech_blue;

    uint8 anim_speed;    // 1 is normal
    bool8 reverse_route; // routing backwards
    bool8 is_shooting;   // are we firing the gun ?
    bool8 drawShadow;    // sometimes turned off

    // generic async
    bool8 asyncing;        // is loading a generic anim file
    uint8 async_list_pos;  // position in current file list/queue
    __weapon async_weapon; // current set used by asyncer

    // footsteps
    int8 footstep_status;   // current foot left/right status...
    uint8 footstep_weight;  // weight of footstep (100 is Cord) 255 maximum...
    bool8 footstep_special; // whether special or not...

    bool8 display_me; // high level character draw clip

    // generic stair-----------------------------------------------------------
    // stuff for shadow correction on stairs
    bool8 on_stairs;
    PXreal bottom_x, bottom_z;
    PXreal top_x, top_z;
    PXfloat stair_pan;

    uint8 extrap_size;           // route barrier extrapolation size
    bool8 dead;                  // dead or not?
    uint32 slice_hold_tolerance; // y distance to stray before slice hold kicks back in
    uint8 idle_count;            // how int32 just been stood

    bool8 inventoryActive;       // used to toggle the inventory on and off from scripts (El Dorado only)

    // camera control
    bool8 y_locked;
    PXreal y_lock;

    void ___init();

    void InitCartridgeCase(SVECTOR *initPos, int16 initialHeight);

    bool8 Fetch_armed_status();
    bool8 Fetch_custom();
    __weapon Fetch_pose();
    bool8 Is_crouched();

    // Move this cycle view state flag into last cycle view state
    void ShiftViewState();
    // Set the view state for this cycle
    void SetThisViewState(enum CameraStateEnum status);

    void InitDynamicLight();

    // SetDynamicLight(cycles,r,g,b,x,y,z,falloff);
    // where cycles is number of cycles to stay on (-1 for constant, 0 for off)
    // falloff is maximum extent of light, falloff starts 10% of the way from it...
    void SetDynamicLight(int32 in_cycles, int32 in_r, int32 in_g, int32 in_b, int32 in_x, int32 in_y, int32 in_z, int32 falloff);

    void RemoveDynamicLight() { dynLightOn = 0; }
};

// Move this cycle view state flag into last cycle view state
inline void _mega::ShiftViewState() { viewState = (uint8)((viewState >> THIS_CYCLE_SHIFT) & (LAST_CYCLE_MASK)); }

// Set the view state for this cycle
// status is ON_CAMERA or OFF_CAMERA
inline void _mega::SetThisViewState(enum CameraStateEnum status) { viewState = (uint8)((viewState & LAST_CYCLE_MASK) | ((int)status << THIS_CYCLE_SHIFT)); }

enum _object_image_type { PROP, VOXEL };

enum _prop_interact_type { __THREE_SIXTY = 1, __ICB, __RADIAL };

enum _hold_mode {
    prop_camera_hold = 1,
    mega_player_floor_hold,  // hold when not on player floor
    mega_initial_floor_hold, // hold until on player floor then release forever
    mega_slice_hold,         // hold if not on plyer y then release after a set y distance
    none
};

enum _big_mode {
    __SCRIPT,
    __NO_LOGIC,
    __MEGA_SLICE_HELD,
    __MEGA_PLAYER_FLOOR_HELD,
    __MEGA_INITIAL_FLOOR_HELD,
    __CUSTOM_SIMPLE_ANIMATE,
    __CUSTOM_BUTTON_OPERATED_DOOR,
    __CUSTOM_AUTO_DOOR
};

#define MAX_list 10

#define THREE_SIXTY_INTERACT 2
#define PROP_CROUCH_INTERACT 1

// game object logic structure
class _logic {
public:
    uint32 ms_timer; // timer for this object DEBUGGING
    uint32 looping;
    uint32 old_looping;       // logic controller for script functions - such as animators
    uint32 pause;             // logic pause value
    uint32 anim_direction;    // 0 forward, else backward
    _object_status ob_status; // low level internal stuff - see enum _object_status   //held/not held...
    _big_mode big_mode;
    uint32 owner_floor_rect;       // current floor rect number
    uint32 total_list;             // number of items in list
    uint32 list[MAX_list];         // a list available to script logic
    uint32 list_result;            // tempory holding place for the result of list checking functions - that must return true/false
    uint32 sfxVars[3];             // up to 3 different sound effect modifiers per type of object (gunshot,ricochet,tinkle) (door open,door close)
    uint32 logic_level;            // what level?                  0 is the context switch, 1 is the main logic, 2+ are gosubs from level 1
    char *logic[TREE_SIZE];        // pointers to the raw compiled script data
    char *logic_ref[TREE_SIZE];    // holds the initial pointers
    _object_image_type image_type; // object is PROP or VOXEL based
    __object_type object_type;
    uint32 conversation_uid;       // id of conversation we may be in
    // type of current animation - use to index into voxel_image->anim_name;
    __mega_set_names cur_anim_type;
    uint32 anim_pc;         // pc of current animation - i.e. position in track\voxel frame file
    _vox_image *voxel_info; // extra graphic info
    _mega *mega;            // extra mega info
    // prop xyz coord derived from nico
    PXvector prop_xyz;
    PXfloat prop_interact_pan;
    PXreal interact_dist;   //actual distance - can be changed by implementor
    _prop_interact_type prop_interact_method;   //user interaction method
    int32 radial_interact_distance;

    PXfloat pan;        // engine pan
    PXfloat pan_adjust; // pan neutraliser for frames that include a pan from the grab - i.e. turn on spot
    // this is a distance to look up when looking at the object, only useful:
    int32 look_height; // -1 means not used so don't do...
    // auto panning stuff
    PXfloat auto_display_pan;
    //  timers
    uint32 cycle_time;
    uint32 slowest_cycle_time;
    _hold_mode hold_mode;

    int16 sparkleX;
    int16 sparkleY;

    int16 sparkleZ;
    bool8 player_can_interact; // interactable true or false
    bool8 context_request;     // crude switch to force context script rerun

    bool8 prop_coords_set;      // has a prop object been asigned coordinates - for development safety
    uint8 three_sixty_interact; // true then overides the normal tight pan approach to interaction - like a mega in-fact
    bool8 auto_panning;
    bool8 do_not_disturb; // If true, object will not rerun logic context.

    bool8 camera_held;
    bool8 prop_on_this_screen; // actually on this camera - used by closed doors
    bool8 sparkleOn;           // whether or not sparkle is on
    bool8 padding;             // Pad the structure

private:
    char ob_name[ENGINE_STRING_LEN];

public:
    void ___init(const char *name);
    void ___destruct();

    const char *GetName() const { return ob_name; }

    void GetPosition(PXreal &x, PXreal &y, PXreal &z) const {
        bool8 isActor = (bool8)(image_type == VOXEL);

        if (isActor) {
            x = mega->actor_xyz.x;
            y = mega->actor_xyz.y;
            z = mega->actor_xyz.z;
        } else {
            x = prop_xyz.x;
            y = prop_xyz.y;
            z = prop_xyz.z;
        }
    }
};

} // End of namespace ICB

#endif