doxygen/entity_8h_source.html

/*

** Jo Sega Saturn Engine

** Copyright (c) 2012-2026, Johannes Fetz (johannesfetz@gmail.com)

** All rights reserved.

**

** Redistribution and use in source and binary forms, with or without

** modification, are permitted provided that the following conditions are met:

**     * Redistributions of source code must retain the above copyright

**       notice, this list of conditions and the following disclaimer.

**     * Redistributions in binary form must reproduce the above copyright

**       notice, this list of conditions and the following disclaimer in the

**       documentation and/or other materials provided with the distribution.

**     * Neither the name of the Johannes Fetz nor the

**       names of its contributors may be used to endorse or promote products

**       derived from this software without specific prior written permission.

**

** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

** ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

** WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

** DISCLAIMED. IN NO EVENT SHALL Johannes Fetz BE LIABLE FOR ANY

** DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

** (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

** LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

** ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

** SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/


#ifndef __JO_ENTITY_H__

# define __JO_ENTITY_H__


#if defined(JO_COMPILE_WITH_LEVEL_SUPPORT) && defined(JO_COMPILE_WITH_3D_SUPPORT)


# include "level.h"


# define JO_ENTITY_MAX                      (1024)

# define JO_ENTITY_MAX_CLASSES              (24)

# define JO_ENTITY_MAX_PENDING              (32)

# define JO_ENTITY_MAX_MODELS               (16)

# define JO_ENTITY_WAKE_DISTANCE            (3000)

# define JO_ENTITY_DRAW_DISTANCE            (2000)

# define JO_ENTITY_FAR_DISTANCE             (600)


# define JO_ENTITY_FLAG_DISABLED            (0x0001)

# define JO_ENTITY_FLAG_SOLID               (0x0002)

# define JO_ENTITY_FLAG_HIDDEN              (0x0004)

# define JO_ENTITY_FLAG_DEAD                (0x0100)

# define JO_ENTITY_FLAG_PLAYER_INSIDE       (0x0200)

# define JO_ENTITY_FLAG_DOORWAY             (0x0400)


typedef struct __jo_entity                  jo_entity;


typedef struct

{

    const char                      *name;          // Name in the level (ENTI.cls)

    unsigned int                    data_size;      // Bytes allocated for each entity (entity->data), 0: none

    void                            (*spawn)(jo_entity * const entity);

    void                            (*update)(jo_entity * const entity, const int elapsed);

    bool                            (*action)(jo_entity * const entity, const int action, const int param, jo_entity * const source);

    void                            (*death)(jo_entity * const entity, jo_entity * const source);

    void                            (*draw)(jo_entity * const entity);

}                                   jo_entity_class;


struct __jo_entity

{

    // (the first 32 bytes: what the collisions read for each entity (jo_entities_is_blocked_at()), 2 lines of the cache)

    unsigned int                    flags;          // JO_ENTITY_FLAG_xxx

    jo_pos3D_fixed                  position;       // Foot (world space, Saturn Y down)

    int                             radius;         // Cylinder: collisions, bullets, zone of a trigger (world units)

    int                             height;

    short                           box_x;          // Box turned with the entity (half sizes, world units) for the collisions

    short                           box_z;          // of the player and the entities (jo_entities_get_blocking()), 0: the cylinder

    int                             yaw;            // Degrees

    const jo_entity_class           *cls;

    const char                      *name;

    int                             health;         // 0: can't be damaged (or dead: JO_ENTITY_FLAG_DEAD)

    jo_3d_mesh                      *mesh;          // Model drawn (JO_NULL: none)

    jo_3d_mesh                      *far_mesh;      // Model drawn far away (JO_NULL: mesh)

    jo_pos3D_fixed                  center;         // Bounding sphere of the model (world space)

    int                             mesh_radius;

    int                             far_distance;   // The far model is drawn farther (world units, on the ground)

    int                             draw_distance;  // The model is not drawn farther (world units, on the ground)

    int                             timer;          // Free for the class (milliseconds): the entity stays awake while > 0

    int                             state;          // Free for the class

    void                            *data;          // Data of the class (jo_entity_class.data_size)

    unsigned short                  first_prop;

    unsigned short                  prop_count;

    unsigned short                  first_link;

    unsigned short                  link_count;

    // (internal) The cells of the entity for its depth bias (jo_entities_draw()): at its foot, then on the 4 sides of a

    // door (-2: not found yet), found at this position in this generation of the cells (jo_cells_generation())

    jo_pos3D_fixed                  cell_position;

    short                           cells[5];

    unsigned short                  cell_generation;

} __attribute__((aligned(16)));     // (128 bytes: an entity of the table on 8 lines of the cache, see jo_entities_load())


typedef void                        (*jo_entity_area_damage_callback)(const jo_pos3D_fixed * const center, const int radius,

                                                                      const int damage, jo_entity * const source);


void                                jo_entity_register_class(const jo_entity_class * const cls);


int                                 jo_entities_load(jo_level * const level);


void                                jo_entities_free(void);


void                                jo_entities_update(const jo_pos3D_fixed * const player, const int elapsed);


int                                 jo_entities_draw(void);


int                                 jo_entity_count(void);


jo_entity                           *jo_entity_get(const int index);


jo_entity                           *jo_entity_find(const char * const name);


void                                jo_entity_send(jo_entity * const target, const int action, const int param, jo_entity * const source);


void                                jo_entity_fire(jo_entity * const source, const int event, const int param);


void                                jo_entity_damage(jo_entity * const entity, const int damage, jo_entity * const source);


void                                jo_entities_damage_area(const jo_pos3D_fixed * const center, const int radius, const int damage,

                                                            jo_entity * const source);


void                                jo_entities_set_area_damage_callback(const jo_entity_area_damage_callback callback);


jo_entity                           *jo_entities_ray_hit(const jo_pos3D_fixed * const origin, const jo_pos3D_fixed * const dir,

                                                         const jo_fixed max_t, jo_fixed * const t, jo_pos3D_fixed * const normal);


bool                                jo_entities_is_blocked(const jo_fixed x, const jo_fixed z, const int radius);


bool                                jo_entities_is_blocked_at(const jo_fixed x, const jo_fixed y, const jo_fixed z, const int radius,

                                                              const int height, const jo_entity * const except);


void                                jo_entity_set_solid(jo_entity * const entity, const bool solid);


jo_entity                           *jo_entities_get_blocking(const jo_fixed x, const jo_fixed z, const int radius,

                                                              const jo_entity * const except);


int                                 jo_entity_get_int(const jo_entity * const entity, const char * const key, const int default_value);

jo_fixed                            jo_entity_get_fixed(const jo_entity * const entity, const char * const key, const jo_fixed default_value);

const char                          *jo_entity_get_string(const jo_entity * const entity, const char * const key,

                                                          const char * const default_value);


bool                                jo_entities_get_zone_request(const char ** const level, const char ** const spawn);


void                                jo_entities_clear_zone_request(void);


jo_3d_mesh                          *jo_entity_load_model(const char * const filename);


jo_3d_model                         *jo_entity_get_model(const char * const filename);


void                                jo_entity_set_mesh(jo_entity * const entity, jo_3d_mesh * const mesh);


int                                 jo_entity_view_distance(const jo_entity * const entity);


void                                jo_entities_set_lod_scale(const int scale);


int                                 jo_entity_turn_to(jo_entity * const entity, const jo_fixed x, const jo_fixed z, const int max_step);


/*

** Actors: entities with an animated model (a skeleton, see jo_3d_model_draw_pose()). The class "actor" of the engine plays

** the animation of its property animation (a character who waits, a flag); the classes of the game (enemies) start their

** data with a jo_actor and call jo_actor_spawn(), jo_actor_update() and jo_actor_draw()

*/


typedef void                        (*jo_actor_bone_callback)(jo_entity * const entity, const int bone, const jo_fixed (* const matrix)[3]);


typedef struct

{

    jo_3d_model                     *model;

    jo_3d_model                     *far_model;     // (property far_model, with a skeleton too) JO_NULL: model

    short                           animation;      // Index in the model, -1: none

    short                           previous;       // Animation before the change (blended), -1: none

    int                             time;           // Milliseconds from the start of the animation

    int                             previous_time;

    int                             blend;          // Milliseconds left of the blend with the previous animation

    int                             blend_duration;

    jo_actor_bone_callback          bone_callback;  // JO_NULL: none

}                                   jo_actor;


void                                jo_actor_spawn(jo_entity * const entity);


void                                jo_actor_update(jo_entity * const entity, const int elapsed);


void                                jo_actor_draw(jo_entity * const entity);


bool                                jo_actor_play(jo_entity * const entity, const char * const name, const int blend);


bool                                jo_actor_restart(jo_entity * const entity, const char * const name, const int blend);


bool                                jo_actor_is_done(const jo_entity * const entity);


bool                                jo_actor_is_playing(const jo_entity * const entity, const char * const name);


#endif /* !JO_COMPILE_WITH_LEVEL_SUPPORT && JO_COMPILE_WITH_3D_SUPPORT */


#endif /* !__JO_ENTITY_H__ */


/*

** END OF FILE

*/

jo_3d_mesh
Mesh structure.
Definition 3d.h:216

level.h
Levels (.JOL files): the data of a level of a game (terrain, models, plants, decals....

jo_3d_model
3D model loaded from a JOM file
Definition model.h:195

jo_fixed
int jo_fixed
Fixed point Q16.16 number.
Definition types.h:48

jo_pos3D_fixed
3D position using fixed numbers
Definition types.h:92