OpenRaider/include/World.h

/* -*- Mode: C++; tab-width: 3; indent-tabs-mode: t; c-basic-offset: 3 -*- */
/*================================================================
 *
 * Project : OpenRaider
 * Author  : Terry 'Mongoose' Hendrix II
 * Website : http://www.westga.edu/~stu7440/
 * Email   : stu7440@westga.edu
 * Object  : World
 * License : No use w/o permission (C) 2002 Mongoose
 * Comments: The game world ( model )
 *
 *
 *           This file was generated using Mongoose's C++
 *           template generator script.  <stu7440@westga.edu>
 *
 *-- History ------------------------------------------------
 *
 * 2002.12.16:
 * Mongoose - Created
 ================================================================*/


#ifndef _WORLD_H_
#define _WORLD_H_

#define BAD_BLOOD  // For temp rendering use

#ifdef BAD_BLOOD
#include <SkeletalModel.h>
#endif

#include <List.h>
#include <Vector.h>
#include <MatMath.h>


// Mirrors TombRaider class' room flags really
typedef enum
{
    roomFlag_underWater    = 0x0001

} room_flags_t;

typedef enum
{
    worldMoveType_walkNoSwim   = -1,
    worldMoveType_walk         = 0,
    worldMoveType_noClipping   = 1,
    worldMoveType_fly          = 2,
    worldMoveType_swim         = 3

} worldMoveType;


typedef struct vertex_s
{
    vec3_t pos;

} vertex_t;


typedef struct uv_s
{
    vec2_t uv;

} uv_t;

typedef struct texel_s
{
    vec2_t st;

} texel_t;


typedef struct color_s
{
    vec4_t rgba;

} color_t;


typedef struct sprite_s
{
    int num_verts; // 4 == Quad, 3 == Triangle, renderered as triangles
    vertex_t vertex[4];
    texel_t texel[4];
    float pos[3];
    float radius; // yeah, I know
    int texture;

} sprite_t;


typedef struct sprite_seq_s
{
    int num_sprites;
    sprite_t *sprite;

} sprite_seq_t;


/*! \fixme For now shaders are textures on tex objects
 * and materials on color objects. If -1
 * then it doesn't have that information yet.
 */

typedef struct texture_tri_s
{
    int index[3];
    vec_t st[6];
    int texture;
    unsigned short transparency;

} texture_tri_t;


typedef struct model_mesh_s
{
    Vector<texture_tri_t *> texturedTriangles;
    Vector<texture_tri_t *> coloredTriangles;
    Vector<texture_tri_t *> texturedRectangles;
    Vector<texture_tri_t *> coloredRectangles;

    vec3_t center;
    float radius;

    unsigned int vertexCount;
    vec_t *vertices;

    unsigned int colorCount;
    vec_t *colors;

    unsigned int normalCount;
    vec_t *normals;

} model_mesh_t;


////////////////////////////////////////////////////////////////


typedef struct entity_s
{
    int id;                    // Unique identifier
    float pos[3];              // World position
    float angles[3];           // Eular angles (pitch, yaw, roll)
    int type;                  // {(0x00, item), (0x01, ai), (0x02, player)}
    int room;                  // Current room entity is in
    worldMoveType moveType;    // Type of motion/clipping
    bool moving;               // In motion?
    struct entity_s *master;   // Part of entity chain?

    int state;      // State of the Player, AI, or object
    int objectId;              // What kind of entity?

    int modelId;               // Animation model
    void *tmpHook;
    bool animate;

    /*
      float time, lastTime;
      int state, lastState;
      int event, lastEvent;
      int goal;
     */

} entity_t;


typedef struct static_model_s
{
    int index;     // model_mesh index
    float yaw;     // angle of rotation on Y
    float pos[3];  // position

    //vec3_t bboxMax;
    //vec3_t bboxMin;

} static_model_t;



typedef struct portal_s
{
    float vertices[4][3];
    float normal[3];
    int adjoining_room;

} portal_t;


typedef struct box_s
{
    vertex_t a;
    vertex_t b;
    vertex_t c;
    vertex_t d;

} box_t;

typedef struct sector_s
{
    vec_t floor;
    vec_t ceiling;

    bool wall;

} sector_t;

//! \fixme No room mesh list or sprites and etc
typedef struct room_mesh_s
{
    Vector<int> adjacentRooms;
    Vector<portal_t *> portals;
    Vector<static_model_t *> models;
    Vector<sprite_t *> sprites;
    Vector<box_t *> boxes;
    Vector<sector_t *> sectors;

    int id;
    unsigned int flags;
    unsigned int numXSectors;
    unsigned int numZSectors;
    float pos[3];
    vec3_t bbox_min;
    vec3_t bbox_max;

} room_mesh_t;


// Workout generic entity and a client class from these entities
typedef struct world_entity_s
{
    vec3_t pos;
    vec3_t lastPos;
    vec3_t angle;
    vec_t ttl;

    int type;
    int state;

    //struct world_entity_s *master;

} world_entity_t;


typedef struct actor_entity_s
{
    vec3_t pos;
    vec3_t lastPos;
    vec3_t angle;
    char clipping;
    float time, eventTime, eventTimer;
    int state, nextState;
    float health;

    // Client
    unsigned int uid;
    char name[32];
    int actor, enemy;

    // Render
    unsigned int model;
    unsigned int skin;
    unsigned int animFrame;

} actor_entity_t;

enum OpenRaiderEvent
{
    eNone            = 0,
    eWeaponDischarge,
    eDying,
    eDead,
    eWounded,
    eRunForward,
    eRunBackward,
    eJump,
    eCrouchWalk,
    eIdle,
    eTaunt,
    eTurn,
    eRespawn,
    eLand
};


class World
{
 public:

    enum WorldFlag
    {
        fEnableHopping = 1
    };

    ////////////////////////////////////////////////////////////
    // Constructors
    ////////////////////////////////////////////////////////////

    World();
    /*------------------------------------------------------
     * Pre  :
     * Post : Constructs an object of World
     *
     *-- History ------------------------------------------
     *
     * 2002.12.16:
     * Mongoose - Created
     ------------------------------------------------------*/

    ~World();
    /*------------------------------------------------------
     * Pre  : World object is allocated
     * Post : Deconstructs an object of World
     *
     *-- History ------------------------------------------
     *
     * 2002.12.16:
     * Mongoose - Created
     ------------------------------------------------------*/


    ////////////////////////////////////////////////////////////
    // Public Accessors
    ////////////////////////////////////////////////////////////

    int getRoomByLocation(int index, float x, float y, float z);
    /*------------------------------------------------------
     * Pre  : index - Guessed room index
     * Post : Returns correct room index or -1 for unknown
     *
     *        NOTE: If it fails to be in a room it gives
     *        closest overlapping room
     *
     *-- History ------------------------------------------
     *
     * 2002.12.20:
     * Mongoose - Created, factored out of Render class
     ------------------------------------------------------*/

    int getRoomByLocation(float x, float y, float z);
    /*------------------------------------------------------
     * Pre  :
     * Post : Returns correct room index or -1 for unknown
     *
     *        NOTE: If it fails to be in a room it gives
     *        closest overlapping room
     *
     *-- History ------------------------------------------
     *
     * 2002.12.20:
     * Mongoose - Created, factored out of Render class
     ------------------------------------------------------*/

    int getAdjoiningRoom(int index,
                                float x, float y, float z,
                                float x2, float y2, float z2);
    /*------------------------------------------------------
     * Pre  :
     * Post : Looks for portal crossings from xyz to xyz2 segment
     *        from room[index] returns index of adjoined room or -1
     *
     *-- History ------------------------------------------
     *
     * 2003.05.29:
     * Mongoose - Created
     ------------------------------------------------------*/

    int getSector(int room, float x, float z);
    int getSector(int room, float x, float z, float *floor, float *ceiling);
    /*------------------------------------------------------
     * Pre  : room - valid room index
     * Post : Gets the sector index of the position in room
     *
     *-- History ------------------------------------------
     *
     * 2002.12.20:
     * Mongoose - Created, factored out of Render class
     ------------------------------------------------------*/

    unsigned int getRoomInfo(int room);
    /*------------------------------------------------------
     * Pre  :
     * Post :
     *
     *-- History ------------------------------------------
     *
     * 2003.05.28:
     * Mongoose - Created
     ------------------------------------------------------*/

    bool isWall(int room, int sector);
    /*------------------------------------------------------
     * Pre  : room - valid room index
     *        sector - valid sector index
     * Post : Returns true if this sector is a wall
     *
     *-- History ------------------------------------------
     *
     * 2002.12.20:
     * Mongoose - Created, factored out of Render class
     ------------------------------------------------------*/

    bool getHeightAtPosition(int index, float x, float *y, float z);
    /*------------------------------------------------------
     * Pre  : index - valid room index
     * Post : Returns true if position is in a room
     *        and sets y to the world height in that room
     *
     *-- History ------------------------------------------
     *
     * 2002.12.20:
     * Mongoose - Created, factored out of Render class
     ------------------------------------------------------*/

    // Temp methods for rendering use until more refactoring is done
#ifdef BAD_BLOOD
    model_mesh_t *getMesh(int index);
    skeletal_model_t *getModel(int index);
    room_mesh_t *getRoom(int index);
    Vector<entity_t *> *getEntities();
    Vector<sprite_seq_t *> *getSprites();
    Vector<room_mesh_t *> *getRooms();
#endif

    ////////////////////////////////////////////////////////////
    // Public Mutators
    ////////////////////////////////////////////////////////////

    void setFlag(WorldFlag flag);
    /*------------------------------------------------------
     * Pre  :
     * Post : Sets option flag
     *
     *-- History ------------------------------------------
     *
     * 2002.12.20:
     * Mongoose - Created, factored out of Render class
     ------------------------------------------------------*/

    void clearFlag(WorldFlag flag);
    /*------------------------------------------------------
     * Pre  :
     * Post : Clears option flag
     *
     *-- History ------------------------------------------
     *
     * 2002.12.20:
     * Mongoose - Created, factored out of Render class
     ------------------------------------------------------*/

    void destroy();
    /*------------------------------------------------------
     * Pre  :
     * Post : Clears all data in world, in future will check
     *        if data is in use before clearing
     *
     *-- History ------------------------------------------
     *
     * 2002.12.20:
     * Mongoose - Created
     ------------------------------------------------------*/

    void addRoom(room_mesh_t *room);
    /*------------------------------------------------------
     * Pre  :
     * Post : Adds object to world
     *
     *-- History ------------------------------------------
     *
     * 2002.12.20:
     * Mongoose - Created, factored out of Render class
     ------------------------------------------------------*/

    void addMesh(model_mesh_t *model);
    /*------------------------------------------------------
     * Pre  :
     * Post : Adds object to world
     *
     *-- History ------------------------------------------
     *
     * 2002.12.20:
     * Mongoose - Created, factored out of Render class
     ------------------------------------------------------*/

    void addEntity(entity_t *e);
    /*------------------------------------------------------
     * Pre  :
     * Post : Adds object to world
     *
     *-- History ------------------------------------------
     *
     * 2002.12.20:
     * Mongoose - Created, factored out of Render class
     ------------------------------------------------------*/

    int addModel(skeletal_model_t *model);
    /*------------------------------------------------------
     * Pre  :
     * Post : Adds object to world, returns next model Id
     *        or -1 if failed to add model to world
     *
     *-- History ------------------------------------------
     *
     * 2002.12.20:
     * Mongoose - Created, factored out of Render class
     ------------------------------------------------------*/

    void addSprite(sprite_seq_t *sprite);
    /*------------------------------------------------------
     * Pre  :
     * Post : Adds object to world
     *
     *-- History ------------------------------------------
     *
     * 2002.12.20:
     * Mongoose - Created, factored out of Render class
     ------------------------------------------------------*/

    void moveEntity(entity_t *e, char movement);
    /*------------------------------------------------------
     * Pre  : movement - 'f' orward
     *                   'b' ackward
     *                   'l' eft
     *                   'r' ight
     *
     * Post : Move entity e in a given direction, unless
     *        a collision ocurrs
     *
     *-- History ------------------------------------------
     *
     * 2002.12.20:
     * Mongoose - Moved to WOrld class
     *
     * 2002.09.02:
     * Mongoose - Created
     ------------------------------------------------------*/


 private:

    ////////////////////////////////////////////////////////////
    // Private Accessors
    ////////////////////////////////////////////////////////////


    ////////////////////////////////////////////////////////////
    // Private Mutators
    ////////////////////////////////////////////////////////////

    void clear();
    /*------------------------------------------------------
     * Pre  :
     * Post : Clears all data in world
     *
     *-- History ------------------------------------------
     *
     * 2002.12.20:
     * Mongoose - Created
     ------------------------------------------------------*/

    bool mClearLock;

    unsigned int mFlags;                   /* World flags */

    Vector<entity_t *> mEntities;            /* World entities */

    Vector<room_mesh_t *> mRooms;            /* Map data and meshes */

    Vector<model_mesh_t *> mMeshes;       /* Unanimated meshes */

    Vector<sprite_seq_t *> mSprites;          /* Sprites */

    Vector<skeletal_model_t *> mModels;     /* Skeletal animation models */
};

#endif