CMakeLists.txt

@@ -12,8 +12,6 @@ set(COMMON_SOURCES
     "src/assets/cache.cpp"
     "src/assets/cmdfile.hpp"
     "src/assets/cmdfile.cpp"
-    "src/assets/item.hpp"
-    "src/assets/item.cpp"
     "src/assets/map.hpp"
     "src/assets/map.cpp"
     "src/assets/model.hpp"
@@ -27,8 +25,6 @@ set(COMMON_SOURCES
     "src/collision/motionstate.hpp"
     "src/collision/trianglemesh.hpp"
     "src/collision/trianglemesh.cpp"
-    "src/game/camera_controller.hpp"
-    "src/game/camera_controller.cpp"
     "src/game/character_anim_state.hpp"
     "src/game/character_anim_state.cpp"
     "src/game/deform_grid.hpp"
@@ -58,8 +54,6 @@ set(COMMON_SOURCES
 )
 
 set(CLIENT_ONLY_SOURCES
-    "src/assets/effect.hpp"
-    "src/assets/effect.cpp"
     "src/assets/mesh_builder.hpp"
     "src/assets/mesh_builder.cpp"
     "src/audio/defs.hpp"
@@ -90,8 +84,6 @@ set(CLIENT_ONLY_SOURCES
     "src/gameview/mapinstanceview.cpp"
     "src/gameview/markerview.hpp"
     "src/gameview/markerview.cpp"
-    "src/gameview/particle_emitter.hpp"
-    "src/gameview/particle_emitter.cpp"
     "src/gameview/remote_menu_view.hpp"
     "src/gameview/remote_menu_view.cpp"
     "src/gameview/simple_entity_view.hpp"
@@ -134,8 +126,8 @@ set(CLIENT_ONLY_SOURCES
     "src/gui/font.cpp"
     "src/gui/menu.hpp"
     "src/gui/menu.cpp"
-    "src/gui/player_hud.hpp"
+    "src/gui/use_target_hud.hpp"
-    "src/gui/player_hud.cpp"
+    "src/gui/use_target_hud.cpp"
     "src/utils/files.cpp"
 )
 
@@ -158,8 +150,6 @@ set(SERVER_ONLY_SOURCES
     "src/game/game.cpp"
     "src/game/human_character.hpp"
     "src/game/human_character.cpp"
-    "src/game/item_instance.hpp"
-    "src/game/item_instance.cpp"
     "src/game/mapinstance.hpp"
     "src/game/mapinstance.cpp"
     "src/game/marker.hpp"

src/assets/animation.cpp

@@ -97,10 +97,6 @@ std::shared_ptr<const assets::Animation> assets::Animation::LoadFromFile(const s
         {
             iss >> anim->tps_;
         }
-        else if (command == "cyclic")
-        {
-            anim->cyclic_ = true;
-        }
     });
 
     if (anim->channels_.empty())
@@ -124,9 +120,5 @@ std::shared_ptr<const assets::Animation> assets::Animation::LoadFromFile(const s
         channel.frames = &anim->frame_refs_[i * anim->num_frames_];
     }
 
-    // calc duration
-    auto frame_range = anim->cyclic_ ? anim->num_frames_ : anim->num_frames_ - 1;
-    anim->duration_ = static_cast<float>(frame_range) / anim->tps_;
-
     return anim;
 }

src/assets/animation.hpp

@@ -24,8 +24,7 @@ public:
 
     size_t GetNumFrames() const { return num_frames_; }
     float GetTPS() const { return tps_; }
-    float GetDuration() const { return duration_; }
+    float GetDuration() const { return static_cast<float>(num_frames_) / tps_; }
-    bool IsCyclic() const { return cyclic_; }
 
     size_t GetNumChannels() const { return channels_.size(); }
     const AnimationChannel& GetChannel(int index) const { return channels_[index]; }
@@ -33,8 +32,6 @@ public:
 private:
     size_t num_frames_ = 0;
     float tps_ = 24.0f;
-    bool cyclic_ = false;
-    float duration_ = 0.0f;
 
     std::vector<AnimationChannel> channels_;
     std::vector<const Transform*> frame_refs_;

src/assets/cache.cpp

@@ -4,9 +4,7 @@ assets::SkeletonCache assets::CacheManager::skeleton_cache_;
 assets::ModelCache assets::CacheManager::model_cache_;
 assets::MapCache assets::CacheManager::map_cache_;
 assets::VehicleCache assets::CacheManager::vehicle_cache_;
-assets::ItemCache assets::CacheManager::item_cache_;
 
 CLIENT_ONLY(assets::TextureCache assets::CacheManager::texture_cache_;)
 CLIENT_ONLY(assets::SoundCache assets::CacheManager::sound_cache_;)
 CLIENT_ONLY(assets::FontCache assets::CacheManager::font_cache_;)
-CLIENT_ONLY(assets::EffectCache assets::CacheManager::effect_cache_;)

src/assets/cache.hpp

@@ -4,7 +4,6 @@
 #include "model.hpp"
 #include "skeleton.hpp"
 #include "vehiclemdl.hpp"
-#include "item.hpp"
 
 #include "utils/defs.hpp"
 
@@ -12,7 +11,6 @@
 #include "audio/sound.hpp"
 #include "gfx/texture.hpp"
 #include "gui/font.hpp"
-#include "effect.hpp"
 #endif
 
 #include <iostream>
@@ -68,12 +66,6 @@ class FontCache final : public Cache<gui::Font>
 protected:
     PtrType Load(const std::string& key) override { return gui::Font::LoadFromFile(key); }
 };
-
-class EffectCache final : public Cache<Effect>
-{
-protected:
-    PtrType Load(const std::string& key) override { return Effect::LoadFromFile(key); }
-};
 #endif // CLIENT
 
 class SkeletonCache final : public Cache<Skeleton>
@@ -100,12 +92,6 @@ protected:
     PtrType Load(const std::string& key) override { return VehicleModel::LoadFromFile(key); }
 };
 
-class ItemCache final : public Cache<Item>
-{
-protected:
-    PtrType Load(const std::string& key) override { return Item::LoadFromFile(key); }
-};
-
 class CacheManager
 {
 public:
@@ -123,11 +109,6 @@ public:
         return vehicle_cache_.Get(filename);
     }
 
-    static std::shared_ptr<const Item> GetItem(const std::string& filename)
-    {
-        return item_cache_.Get(filename);
-    }
-
 #ifdef CLIENT
     static std::shared_ptr<const gfx::Texture> GetTexture(const std::string& filename)
     {
@@ -143,11 +124,6 @@ public:
     {
         return font_cache_.Get(filename);
     }
-    
-    static std::shared_ptr<const Effect> GetEffect(const std::string& filename)
-    {
-        return effect_cache_.Get(filename);
-    }
 #endif
 
 private:
@@ -155,11 +131,9 @@ private:
     static ModelCache model_cache_;
     static MapCache map_cache_;
     static VehicleCache vehicle_cache_;
-    static ItemCache item_cache_;
     CLIENT_ONLY(static TextureCache texture_cache_;)
     CLIENT_ONLY(static SoundCache sound_cache_;)
     CLIENT_ONLY(static FontCache font_cache_;)
-    CLIENT_ONLY(static EffectCache effect_cache_;)
 };
 
 } // namespace assets

src/assets/effect.cpp

@@ -1,78 +0,0 @@
-#include "effect.hpp"
-
-#include "cmdfile.hpp"
-#include "assets/cache.hpp"
-
-std::shared_ptr<const assets::Effect> assets::Effect::LoadFromFile(const std::string& path)
-{
-    auto fx = std::make_shared<Effect>();
-
-    ParticleDef* particle = nullptr;
-
-    LoadCMDFile(path, [&](const std::string& command, std::istringstream& iss) {
-        if (command == "sound")
-        {
-            std::string sound_name;
-            iss >> sound_name;
-            fx->sounds_.emplace_back(assets::CacheManager::GetSound("data/" + sound_name + ".snd"));
-        }
-        else if (command == "particle")
-        {
-            particle = &fx->particle_defs_.emplace_back();
-        }
-        else if (particle)
-        {
-            if (command == "texture")
-            {
-                std::string texture_name;
-                iss >> texture_name;
-                particle->texture = assets::CacheManager::GetTexture("data/" + texture_name + ".png");
-            }
-            else if (command == "blend")
-            {
-                std::string blend_str;
-                iss >> blend_str;
-
-                if (blend_str == "normal")
-                    particle->blend = PTB_BLEND_NORMAL;
-                else if (blend_str == "additive")
-                    particle->blend = PTB_BLEND_ADDITIVE;
-            }
-            else if (command == "size")
-            {
-                iss >> particle->size_min >> particle->size_max;
-            }
-            else if (command == "count")
-            {
-                iss >> particle->count_min >> particle->count_max;
-            }
-            else if (command == "velocity")
-            {
-                iss >> particle->velocity_min >> particle->velocity_max;
-            }
-            else if (command == "dispersion")
-            {
-                iss >> particle->max_dispersion;
-            }
-            else if (command == "gravity")
-            {
-                iss >> particle->gravity_min >> particle->gravity_max;
-            }
-            else if (command == "lifetime")
-            {
-                iss >> particle->lifetime_min >> particle->lifetime_max;
-            }
-            else if (command == "fadetime")
-            {
-                iss >> particle->fadetime_min >> particle->fadetime_max;
-            }
-
-        }
-        else
-        {
-            throw std::runtime_error("Unknown or unexpected command in effect: " + command);
-        }
-    });
-
-    return fx;
-}

src/assets/effect.hpp

@@ -1,55 +0,0 @@
-#pragma once
-
-#include <vector>
-
-#include "gfx/texture.hpp"
-#include "audio/sound.hpp"
-
-namespace assets
-{
-
-enum ParticleBlendType
-{
-    PTB_NONE,
-    PTB_BLEND_NORMAL,
-    PTB_BLEND_ADDITIVE,
-};
-
-struct ParticleDef
-{
-    std::shared_ptr<const gfx::Texture> texture;
-    ParticleBlendType blend = PTB_NONE;
-    float size_min = 1.0f;
-    float size_max = 1.0f;
-    size_t count_min = 1;
-    size_t count_max = 1;
-    float velocity_min = 1.0f;
-    float velocity_max = 1.0f;
-    float max_dispersion = 0.0f;
-    float gravity_min = 1.0f;
-    float gravity_max = 1.0f;
-    float lifetime_min = 1.0f;
-    float lifetime_max = 1.0f;
-    float fadetime_min = 1.0f;
-    float fadetime_max = 1.0f;
-};
-
-class Effect
-{
-public:
-    Effect() = default;
-    static std::shared_ptr<const Effect> LoadFromFile(const std::string& path);
-
-    const std::vector<ParticleDef>& GetParticleDefs() const { return particle_defs_; }
-    const std::vector<std::shared_ptr<const audio::Sound>>& GetSounds() const { return sounds_; }
-
-private:
-
-    std::vector<ParticleDef> particle_defs_;
-    std::vector<std::shared_ptr<const audio::Sound>> sounds_;
-
-};
-
-
-
-}

src/assets/item.cpp

@@ -1,169 +0,0 @@
-#include "item.hpp"
-
-#include "cache.hpp"
-#include "cmdfile.hpp"
-
-std::shared_ptr<assets::Item> assets::Item::LoadFromFile(const std::string& path)
-{
-    auto item = std::make_shared<Item>();
-
-    LoadCMDFile(path, [&](const std::string& command, std::istringstream& iss) {
-        if (command == "type")
-        {
-            std::string type_str;
-            iss >> type_str;
-
-            if (type_str == "consumable")
-                item->type = ITEM_CONSUMABLE;
-            else if (type_str == "weapon")
-                item->type = ITEM_WEAPON;
-            else
-                throw std::runtime_error("Unknown item type " + type_str);
-        }
-        else if (command == "name")
-        {
-            iss >> item->name;
-        }
-        else if (command == "displayname")
-        {
-            item->displayname = ParseString(iss);
-        }
-        else if (command == "anim")
-        {
-            std::string anim_type, anim_name;
-            iss >> anim_type >> anim_name;
-
-            if (anim_type == "idle")
-                item->idle_anim = anim_name;
-            else if (anim_type == "raise")
-                item->raise_anim = anim_name;
-            else if (anim_type == "use" || anim_type == "fire")
-                item->use_anim = anim_name;
-            else if (anim_type == "aim")
-                item->aim_anim = anim_name;
-            else if (anim_type == "aiming")
-                item->aiming_anim = anim_name;
-            else if (anim_type == "reload")
-                item->reload_anim = anim_name;
-            else if (anim_type == "legs")
-                item->legs_anim = anim_name;
-            else
-                throw std::runtime_error("Unknown item anim type " + anim_type);
-        }
-        else if (command == "model")
-        {
-            iss >> item->model_name;
-            item->model = CacheManager::GetModel("data/" + item->model_name + ".mdl");    
-        }
-        else if (command == "attach")
-        {
-            std::string target;
-            iss >> target;
-
-            if (target == "loc")
-            {
-                std::string sk_name, loc_name;
-                iss >> sk_name >> loc_name;
-                
-                auto sk = assets::CacheManager::GetSkeleton("data/" + sk_name + ".sk");
-                auto loc = sk->GetLocation(loc_name);
-                if (!loc)
-                    throw std::runtime_error("Invalid skeleton location: " + loc_name);
-
-                item->bone = loc->bone_name;
-                item->bone_offset = loc->offset;
-            }
-            else
-            {
-                item->bone = target;
-                glm::vec3 position;
-                glm::vec3 angles;
-                iss >> position.x >> position.y >> position.z >> angles.x >> angles.y >> angles.z;
-    
-                item->bone_offset.position = position;
-                item->bone_offset.rotation = glm::quat(glm::radians(angles));
-            }
-
-            // ParseTransform(iss, item->bone_offset);
-        }
-        else if (command == "weapontype")
-        {
-            std::string type_str;
-            iss >> type_str;
-
-            if (type_str == "manual")
-                item->weapon_type = WEAPON_MANUAL;
-            else if (type_str == "semiauto")
-                item->weapon_type = WEAPON_SEMIAUTO;
-            else if (type_str == "auto")
-                item->weapon_type = WEAPON_AUTO;
-            else
-                throw std::runtime_error("Unknown weapon type " + type_str);
-        }
-        else if (command == "firetype")
-        {
-            std::string type_str;
-            iss >> type_str;   
-
-            if (type_str == "melee")
-                item->fire_type = FIRETYPE_MELEE;
-            else if (type_str == "bullet")
-                item->fire_type = FIRETYPE_BULLET;
-            else if (type_str == "projectile")
-                item->fire_type = FIRETYPE_PROJECTILE;
-            else
-                throw std::runtime_error("Unknown weapon type: " + type_str);
-        }
-        else if (command == "ammotype")
-        {
-            iss >> item->ammo_type;
-        }
-        else if (command == "clipsize")
-        {
-            iss >> item->clip_size;
-        }
-        else if (command == "firedelay")
-        {
-            iss >> item->fire_delay;
-        }
-        else if (command == "firesnd")
-        {
-            iss >> item->fire_snd;
-        }
-        else if (command == "firefx")
-        {
-            iss >> item->fire_fx >> item->fire_fx_loc;
-        }
-        else if (command == "dispersion")
-        {
-            iss >> item->dispersion_min >> item->dispersion_max >> item->dispersion_shot >> item->dispersion_decay;
-        }
-        else if (command == "slot")
-        {
-            iss >> item->slot;
-        }
-        else if (command == "twohanded")
-        {
-            item->twohanded = true;
-        }
-        else if (command == "walkspeedmult")
-        {
-            iss >> item->walk_speed_mult;
-        }
-        else if (command == "damage")
-        {
-            iss >> item->damage;
-        }
-        else
-        {
-            throw std::runtime_error("Unknown item command: " + command);
-        }
-    });
-
-    if (item->displayname.empty())
-    {
-        item->displayname = item->name;
-    }
-    
-    return item;
-}

src/assets/item.hpp

@@ -1,90 +0,0 @@
-#pragma once
-
-#include <map>
-
-#include "model.hpp"
-
-namespace assets
-{
-
-enum ItemType
-{
-    ITEM_NONE,
-    ITEM_WEAPON,
-    ITEM_CONSUMABLE,
-};
-
-enum ItemAimType
-{
-    AIMTYPE_NONE,
-    AIMTYPE_AIM,
-    AIMTYPE_SCOPE,
-
-};
-
-enum WeaponType
-{
-    WEAPON_MANUAL,
-    WEAPON_SEMIAUTO,
-    WEAPON_AUTO,
-};
-
-enum WeaponFireType
-{
-    FIRETYPE_MELEE,
-    FIRETYPE_BULLET,
-    FIRETYPE_PROJECTILE,
-};
-
-struct Item
-{
-    ItemType type = ITEM_NONE;
-    std::string name;
-    std::string displayname;
-
-    size_t slot = 0;
-
-    std::string model_name;
-    std::shared_ptr<const assets::Model> model;
-    
-    std::string bone;
-    Transform bone_offset;
-
-    bool twohanded = false;
-
-    float walk_speed_mult = 1.0f;
-
-    std::string legs_anim;
-    std::string raise_anim;
-    std::string idle_anim;
-    std::string use_anim; // use or fire
-    
-    // consumable
-    std::string action;
-
-    // weapon
-    WeaponType weapon_type = WEAPON_MANUAL;
-    WeaponFireType fire_type = FIRETYPE_MELEE;
-    std::string ammo_type;
-    size_t clip_size = 0;
-    size_t fire_delay = 0;
-    float dispersion_min = 0.0f;
-    float dispersion_max = 0.0f;
-    float dispersion_shot = 0.0f;
-    float dispersion_decay = 1.0f;
-    float damage = 1.0f;
-
-    std::string aim_anim;
-    std::string aiming_anim;
-    std::string reload_anim;
-
-    std::string fire_snd;
-    std::string fire_fx;
-    std::string fire_fx_loc;
-
-    static std::shared_ptr<Item> LoadFromFile(const std::string& path);
-};
-
-
-
-}

src/assets/model.cpp

@@ -5,30 +5,6 @@
 
 #include <BulletCollision/CollisionShapes/btShapeHull.h>
 
-static collision::Material GetMaterialByName(const std::string& name)
-{
-    if (name == "stone")
-        return collision::PM_STONE;
-    else if (name == "dirt")
-        return collision::PM_DIRT;
-    else if (name == "grass")
-        return collision::PM_GRASS;
-    else if (name == "wood")
-        return collision::PM_WOOD;
-    else if (name == "metal")
-        return collision::PM_METAL;
-    else if (name == "glass")
-        return collision::PM_GLASS;
-    else if (name == "flesh")
-        return collision::PM_FLESH;
-    else if (name == "car") // TODO: make new material for cars
-        return collision::PM_METAL;
-    else if (name == "carwindow")
-        return collision::PM_NONE;
-    else
-        return collision::PM_STONE;
-}
-
 std::shared_ptr<const assets::Model> assets::Model::LoadFromFile(const std::string& filename)
 {
     auto model = std::make_shared<Model>();
@@ -39,8 +15,6 @@ std::shared_ptr<const assets::Model> assets::Model::LoadFromFile(const std::stri
     std::unique_ptr<btConvexHullShape> temp_hull;
     std::unique_ptr<btCompoundShape> compound;
 
-    collision::Material col_material = collision::PM_NONE;
-
     LoadCMDFile(filename, [&](const std::string& command, std::istringstream& iss) {
         if (command == "v")
         {
@@ -225,28 +199,6 @@ std::shared_ptr<const assets::Model> assets::Model::LoadFromFile(const std::stri
             iss >> key >> val;
             model->params_[key] = val;
         }
-        else if (command == "pm")
-        {
-            std::string pm_name;
-            iss >> pm_name;
-
-            if (model->cmesh_)
-            {
-                model->cmesh_->BeginMaterial(GetMaterialByName(pm_name));
-            }
-        }
-        else if (command == "cpm")
-        {
-            std::string pm_name;
-            iss >> pm_name;
-            col_material = GetMaterialByName(pm_name);
-        }
-        else if (command == "loc")
-        {
-            std::string loc_name;
-            iss >> loc_name;
-            ParseTransform(iss, model->locations_[loc_name]);
-        }
         else
         {
             throw std::runtime_error("Unknown command in model file: " + command);
@@ -277,13 +229,6 @@ std::shared_ptr<const assets::Model> assets::Model::LoadFromFile(const std::stri
         model->cshape_ = std::move(compound);
     }
 
-    if (model->cshape_)
-    {
-        collision::SetShapeMaterial(*model->cshape_, col_material);
-        if (col_material != collision::PM_NONE)
-            model->cshape_is_bullet_target_ = true;
-    }
-
     return model;
 }
 
@@ -312,12 +257,3 @@ bool assets::Model::GetParamFloat(const std::string& key, float& out) const
 
     return true;
 }
-
-const Transform* assets::Model::GetLocation(const std::string& key) const
-{
-    auto it = locations_.find(key);
-    if (it == locations_.end())
-        return nullptr;
-
-    return &it->second;
-}

src/assets/model.hpp

@@ -45,7 +45,6 @@ public:
     const glm::vec3& GetColOffset() const { return col_offset_; }
     const collision::TriangleMesh* GetColMesh() const { return cmesh_.get(); }
     btCollisionShape* GetColShape() const { return cshape_.get(); }
-    bool IsColShapeBulletTarget() const { return cshape_is_bullet_target_; }
 
     const std::shared_ptr<const Skeleton>& GetSkeleton() const { return skeleton_; }
     CLIENT_ONLY(const std::shared_ptr<const Mesh>& GetMesh() const { return mesh_; })
@@ -53,9 +52,7 @@ public:
 
     const std::string* GetParam(const std::string& key) const;
     bool GetParamFloat(const std::string& key, float& out) const;
-    
+
-    const Transform* GetLocation(const std::string& key) const;
-    
 private:
     std::string name_;
     glm::vec3 col_offset_ = glm::vec3(0.0f);
@@ -63,14 +60,12 @@ private:
     // std::vector<ModelCollisionShape> cshapes_;
     std::vector<std::unique_ptr<btCollisionShape>> subshapes_;
     std::unique_ptr<btCollisionShape> cshape_;
-    bool cshape_is_bullet_target_ = false;
 
     std::shared_ptr<const Skeleton> skeleton_;
     CLIENT_ONLY(std::shared_ptr<const Mesh> mesh_;);
     AABB3 aabb_;
 
     std::map<std::string, std::string> params_;
-    std::map<std::string, Transform> locations_;
 
 };
 

src/assets/skeleton.cpp

@@ -1,7 +1,6 @@
 #include "skeleton.hpp"
 
 #include "cmdfile.hpp"
-#include "collision/shape_info.hpp"
 
 #include <stdexcept>
 
@@ -39,49 +38,8 @@ std::shared_ptr<const assets::Skeleton> assets::Skeleton::LoadFromFile(const std
                 Animation::LoadFromFile("data/" + anim_filename + ".anim", skeleton.get());
             skeleton->AddAnimation(anim_name, anim);
         }
-        else if (command == "hitbone")
-        {
-            auto& hitbone = skeleton->hit_bones_.emplace_back();
-
-            std::string shape_name, bone_name;
-            float sy, sz;
-            iss >> hitbone.name >> bone_name >> shape_name;
-            ParseTransform(iss, hitbone.offset);
-            iss >> sy >> sz;
-
-            int bone_idx = skeleton->GetBoneIndex(bone_name);
-            hitbone.bone_idx = bone_idx >= 0 ? bone_idx : 0; 
-
-            glm::vec3 shape_size(hitbone.offset.scale, sy, sz);
-            hitbone.offset.scale = 1.0f;
-
-            if (shape_name == "capsule")
-            {
-                hitbone.col_shape = std::make_unique<btCapsuleShapeZ>(shape_size.x, shape_size.z); // TODO: check dimenmsions
-            }
-            else
-            {
-                throw std::runtime_error("Unknown hitbone shape: " + shape_name);
-            }
-
-            collision::SetShapeMaterial(*hitbone.col_shape, collision::PM_FLESH);
-        }
-        else if (command == "loc")
-        {
-            std::string loc_name, bone_name;
-            iss >> loc_name >> bone_name;
-
-            auto& loc = skeleton->locations_[loc_name];
-            ParseTransform(iss, loc.offset);
-
-            loc.bone_name = bone_name;
-            int bone_idx = skeleton->GetBoneIndex(bone_name);
-            loc.bone_idx = bone_idx >= 0 ? bone_idx : 0; 
-        }
     });
 
-    skeleton->AddAimBones();
-
     return skeleton;
 }
 
@@ -119,15 +77,6 @@ const assets::Animation* assets::Skeleton::GetAnimation(const std::string& name)
     return GetAnimation(GetAnimationIdx(name));
 }
 
-const assets::SkeletonLocation* assets::Skeleton::GetLocation(const std::string& name) const
-{
-    auto it = locations_.find(name);
-    if (it == locations_.end())
-        return nullptr;
-
-    return &it->second;
-}
-
 void assets::Skeleton::AddBone(const std::string& name, const std::string& parent_name, const Transform& transform)
 {
     int index = static_cast<int>(bones_.size());
@@ -146,29 +95,3 @@ void assets::Skeleton::AddAnimation(const std::string& name, const std::shared_p
     anim_idxs_[name] = anims_.size();
     anims_.push_back(anim);
 }
-
-void assets::Skeleton::AddAimBones()
-{
-    AddAimBone("DEF-spine.002", 1.0f, glm::vec3(0.0f, 1.0f, 0.0f), 0.0f, glm::vec3(0.0f));
-    AddAimBone("spine_fk.002", 1.0f, glm::vec3(0.0f, 0.0f, 1.0f), 0.0f, glm::vec3(0.0f));
-
-    AddAimBone("DEF-spine.002", 0.0f, glm::vec3(0.0f), 0.5f, glm::vec3(1.0f, 0.0f, 0.0f));
-    AddAimBone("MCH-spine.002", 0.0f, glm::vec3(0.0f), 0.5f, glm::vec3(1.0f, 0.0f, 0.0f));
-    AddAimBone("DEF-spine.003", 0.0f, glm::vec3(0.0f), 0.5f, glm::vec3(1.0f, 0.0f, 0.0f));
-    AddAimBone("MCH-spine.003", 0.0f, glm::vec3(0.0f), 0.5f, glm::vec3(1.0f, 0.0f, 0.0f));
-}
-
-void assets::Skeleton::AddAimBone(const std::string& name, float yaw_weight, const glm::vec3& yaw_axis, float pitch_weight, const glm::vec3& pitch_axis)
-{
-    auto idx = GetBoneIndex(name);
-    if (idx < 0)
-        return;
-
-    AimBone aimbone{};
-    aimbone.idx = idx;
-    aimbone.yaw_weight = yaw_weight;
-    aimbone.yaw_axis = yaw_axis;
-    aimbone.pitch_weight = pitch_weight;
-    aimbone.pitch_axis = pitch_axis;
-    aim_bones_.emplace_back(aimbone);
-}

src/assets/skeleton.hpp

@@ -22,30 +22,6 @@ struct Bone
 using AnimIdx = uint8_t;
 constexpr AnimIdx NO_ANIM = 255;
 
-struct AimBone
-{
-    size_t idx;
-    float yaw_weight;
-    glm::vec3 yaw_axis;
-    float pitch_weight;
-    glm::vec3 pitch_axis;
-};
-
-struct HitBone
-{
-    size_t bone_idx = 0;
-    std::string name;
-    Transform offset;
-    std::unique_ptr<btCollisionShape> col_shape;
-};
-
-struct SkeletonLocation
-{
-    size_t bone_idx = 0;
-    std::string bone_name;
-    Transform offset;
-};
-
 class Skeleton
 {
 public:
@@ -61,28 +37,16 @@ public:
     const Animation* GetAnimation(AnimIdx idx) const;
     const Animation* GetAnimation(const std::string& name) const;
 
-    const std::vector<AimBone>& GetAimBones() const { return aim_bones_; }
-    const std::vector<HitBone>& GetHitBones() const { return hit_bones_; }
-    const SkeletonLocation* GetLocation(const std::string& name) const;
-
 private:
     void AddBone(const std::string& name, const std::string& parent_name, const Transform& transform);
     void AddAnimation(const std::string& name, const std::shared_ptr<const Animation>& anim);
 
-    void AddAimBones();
-    void AddAimBone(const std::string& name, float yaw_weight, const glm::vec3& yaw_axis, float pitch_weight, const glm::vec3& pitch_axis);
-
 private:
-    std::string name_;
     std::vector<Bone> bones_;
     std::map<std::string, int> bone_map_;
 
     std::vector<std::shared_ptr<const Animation>> anims_;
     std::map<std::string, AnimIdx> anim_idxs_;
-
-    std::vector<AimBone> aim_bones_;
-    std::vector<HitBone> hit_bones_;
-    std::map<std::string, SkeletonLocation> locations_;
 };
 
 } // namespace assets

src/audio/player.cpp

@@ -3,10 +3,10 @@
 audio::Player::Player(Master& master) : master_(master) {}
 
 audio::SoundSource* audio::Player::PlaySound(const std::shared_ptr<const Sound>& sound,
-                                             const game::TransformNode* attach_node)
+                                             const glm::vec3* attach_position)
 {
     SoundSource* source = new SoundSource(this, sound);
-    source->AttachToNode(attach_node);
+    source->AttachToPosition(attach_position);
 
     return source;
 }

src/audio/player.hpp

@@ -14,7 +14,7 @@ public:
     Player(Master& master);
     DELETE_COPY_MOVE(Player)
 
-    SoundSource* PlaySound(const std::shared_ptr<const Sound>& sound, const game::TransformNode* attach_node);
+    SoundSource* PlaySound(const std::shared_ptr<const Sound>& sound, const glm::vec3* attach_position);
 
     void Update();
 

src/audio/source.cpp

@@ -47,11 +47,12 @@ void audio::Source::SetVelocity(const glm::vec3& velocity)
     alSource3f(source_, AL_VELOCITY, velocity.x, velocity.y, velocity.z);
 }
 
-void audio::Source::AttachToNode(const game::TransformNode* node)
+void audio::Source::AttachToPosition(const glm::vec3* position)
 {
-    attach_node_ = node;
+    attach_position_ = position;
-    if (attach_node_)
+    if (attach_position_)
-        SetPosition(attach_node_->GetGlobalPosition());
+        SetPosition(*attach_position_);
+    // TsrDebugf(DML_2, "Attached source %p to position %p\n", this, position);
 }
 
 void audio::Source::SetRelativeToListener(bool relative)
@@ -70,8 +71,8 @@ void audio::Source::SetRelativeToListener(bool relative)
 
 void audio::Source::Update()
 {
-    if (attach_node_)
+    if (attach_position_)
-        SetPosition(attach_node_->GetGlobalPosition());
+        SetPosition(*attach_position_);
 }
 
 void audio::Source::Delete()

src/audio/source.hpp

@@ -3,8 +3,6 @@
 #include "master.hpp"
 #include <memory>
 
-#include "game/transform_node.hpp"
-
 namespace audio
 {
 
@@ -26,7 +24,7 @@ public:
 
     void SetPosition(const glm::vec3& position);
     void SetVelocity(const glm::vec3& velocity);
-    void AttachToNode(const game::TransformNode* node);
+    void AttachToPosition(const glm::vec3* position);
     void SetRelativeToListener(bool relative);
 
     virtual void SetLooping(bool looping) = 0;
@@ -47,7 +45,7 @@ protected:
 
     unsigned int source_ = 0;
 
-    const game::TransformNode* attach_node_ = nullptr;
+    const glm::vec3* attach_position_ = nullptr;
     bool should_play_ = true; // auto play when created
     bool finished_ = false;
     bool delete_on_finish_ = true; // auto delete when finished

src/client/main.cpp

@@ -157,18 +157,6 @@ static const std::map<SDL_Scancode, game::PlayerInputType> s_inputmap = {
     { SDL_SCANCODE_LSHIFT, game::IN_SPRINT },
     { SDL_SCANCODE_LCTRL, game::IN_CROUCH },
     { SDL_SCANCODE_E, game::IN_USE },
-    { SDL_SCANCODE_Q, game::IN_HOLSTER },
-    { SDL_SCANCODE_R, game::IN_RELOAD },
-    { SDL_SCANCODE_1, game::IN_WEAPON_1 },
-    { SDL_SCANCODE_2, game::IN_WEAPON_2 },
-    { SDL_SCANCODE_3, game::IN_WEAPON_3 },
-    { SDL_SCANCODE_4, game::IN_WEAPON_4 },
-    { SDL_SCANCODE_5, game::IN_WEAPON_5 },
-    { SDL_SCANCODE_6, game::IN_WEAPON_6 },
-    { SDL_SCANCODE_7, game::IN_WEAPON_7 },
-    { SDL_SCANCODE_8, game::IN_WEAPON_8 },
-    { SDL_SCANCODE_9, game::IN_WEAPON_9 },
-    { SDL_SCANCODE_0, game::IN_WEAPON_0 },
     { SDL_SCANCODE_F3, game::IN_DEBUG1 },
     { SDL_SCANCODE_F4, game::IN_DEBUG2 },
     { SDL_SCANCODE_F5, game::IN_DEBUG3 },
@@ -208,20 +196,6 @@ static void PollEvents()
             }
             break;
 
-        case SDL_MOUSEBUTTONDOWN:
-        case SDL_MOUSEBUTTONUP:
-            {
-                if (event.button.button == SDL_BUTTON_LEFT)
-                {
-                    s_app->Input(game::IN_ATTACK_PRIMARY, event.button.state == SDL_PRESSED, false);
-                }
-                else if (event.button.button == SDL_BUTTON_RIGHT)
-                {
-                    s_app->Input(game::IN_ATTACK_SECONDARY, event.button.state == SDL_PRESSED, false);
-                }
-            }
-            break;
-
         }
         
     }
@@ -388,6 +362,16 @@ static void Frame()
 	int width, height;
 	SDL_GetWindowSize(s_window, &width, &height);
 	s_app->SetViewportSize(width, height);
+    
+	game::PlayerInputFlags input = 0;
+	const uint8_t* kbd_state = SDL_GetKeyboardState(nullptr);
+    
+
+
+	int mouse_state = SDL_GetMouseState(nullptr, nullptr);
+
+	if (mouse_state & SDL_BUTTON(SDL_BUTTON_LEFT))
+		input |= (1 << game::IN_ATTACK);
 
     s_app->Frame();
 

src/collision/dynamicsworld.cpp

@@ -10,30 +10,3 @@ collision::DynamicsWorld::DynamicsWorld()
 
     bt_broadphase_.getOverlappingPairCache()->setInternalGhostPairCallback(&bt_ghost_pair_cb_);
 }
-
-glm::vec3 collision::DynamicsWorld::CameraSweep(const glm::vec3& start, const glm::vec3& end)
-{
-    const auto& bt_world = GetBtWorld();
-
-    static const btSphereShape shape(0.1f);
-
-    btVector3 bt_start(start.x, start.y, start.z);
-    btVector3 bt_end(end.x, end.y, end.z);
-
-    btTransform from, to;
-    from.setIdentity();
-    from.setOrigin(bt_start);
-    to.setIdentity();
-    to.setOrigin(bt_end);
-
-    btCollisionWorld::ClosestConvexResultCallback cb(bt_start, bt_end);
-    cb.m_collisionFilterGroup = btBroadphaseProxy::DefaultFilter;
-    cb.m_collisionFilterMask = btBroadphaseProxy::StaticFilter;
-
-    bt_world.convexSweepTest(&shape, from, to, cb);
-
-    if (!cb.hasHit())
-        return end;
-
-    return glm::mix(start, end, cb.m_closestHitFraction);
-}

src/collision/dynamicsworld.hpp

@@ -15,8 +15,6 @@ class DynamicsWorld
 public:
     DynamicsWorld();
     
-    glm::vec3 CameraSweep(const glm::vec3& start, const glm::vec3& end);
-
     btDynamicsWorld& GetBtWorld() { return bt_world_; }
     const btDynamicsWorld& GetBtWorld() const { return bt_world_; }
     btDbvtBroadphase& GetBtBroadphase() { return bt_broadphase_; }

src/collision/object_info.hpp

@@ -3,31 +3,9 @@
 #include <cstdint>
 #include <btBulletDynamicsCommon.h>
 
-namespace game
-{
-    struct DamageInfo;
-    class HumanCharacter;
-}
-
 namespace collision
 {
 
-enum ObjectGroup : int
-{
-    OG_DEFAULT = btBroadphaseProxy::DefaultFilter,
-    OG_STATIC = btBroadphaseProxy::StaticFilter,
-    OG_KINEMATIC = btBroadphaseProxy::KinematicFilter,
-    OG_DEBRIS = btBroadphaseProxy::DebrisFilter,
-    OG_SENSOR = btBroadphaseProxy::SensorTrigger,
-    OG_CHARACTER = btBroadphaseProxy::CharacterFilter,
-
-    OG_PROJECTILE = 64,
-    OG_HITBONES_PROXY = 128,
-        
-    OG_ALL = -1,
-
-};
-
 enum ObjectType : int
 {
     OT_UNDEFINED,
@@ -43,7 +21,6 @@ enum ObjectFlag : ObjectFlags
     OF_NOTIFY_CONTACT = 2,
     OF_USABLE = 4,
     OF_DESTRUCTING = 8,
-    OF_CRASH_DAMAGE = 16,
 };
 
 struct ContactInfo
@@ -58,12 +35,7 @@ class ObjectCallback
 public:
     ObjectCallback() = default;
 
-    virtual void ActivateHitBones() {}
-    
     virtual void OnContact(const ContactInfo& info) {}
-    virtual void ReceiveDamage(const game::DamageInfo& damage) {}
-    
-    virtual game::HumanCharacter* GetResponsibleCharacter() { return nullptr; }
 
     virtual ~ObjectCallback() = default;
 };
@@ -80,27 +52,11 @@ inline void AddObjectFlags(btCollisionObject* obj, ObjectFlags flags)
     obj->setUserIndex2(static_cast<int>(static_cast<ObjectFlags>(obj->getUserIndex2())) | flags);
 }
 
-inline ObjectType GetObjectType(const btCollisionObject* obj)
-{
-    return static_cast<ObjectType>(obj->getUserIndex());
-}
-
-inline ObjectFlags GetObjectFlags(const btCollisionObject* obj)
-{
-    return static_cast<ObjectFlags>(obj->getUserIndex2());
-}
-
-inline ObjectCallback* GetObjectCallback(const btCollisionObject* obj)
-{
-    return static_cast<ObjectCallback*>(obj->getUserPointer());
-}
-
-// legacy
 inline void GetObjectInfo(const btCollisionObject* obj, ObjectType& type, ObjectFlags& flags, ObjectCallback*& callback)
 {
-    type = GetObjectType(obj);
+    type = static_cast<ObjectType>(obj->getUserIndex());
-    flags = GetObjectFlags(obj);
+    flags = static_cast<ObjectFlags>(obj->getUserIndex2());
-    callback = GetObjectCallback(obj);
+    callback = static_cast<ObjectCallback*>(obj->getUserPointer());
 }
 
 }

src/collision/shape_info.hpp

@@ -1,48 +0,0 @@
-#pragma once
-
-#include <cstdint>
-#include <btBulletDynamicsCommon.h>
-#include <span>
-
-namespace collision
-{
-
-enum Material : uint8_t
-{
-    PM_NONE,
-    PM_STONE,
-    PM_DIRT,
-    PM_GRASS,
-    PM_WOOD,
-    PM_METAL,
-    PM_GLASS,
-    PM_PLASTIC,
-    PM_FLESH,
-};
-
-struct ShapeInfo
-{
-    std::span<Material> triangle_materials; 
-};
-
-inline void SetShapeMaterial(btCollisionShape& shape, Material material)
-{
-    shape.setUserIndex(material);
-}
-
-inline Material GetShapeMaterial(const btCollisionShape& shape)
-{
-    return static_cast<Material>(shape.getUserIndex());
-}
-
-inline void SetShapeInfo(btCollisionShape& shape, const ShapeInfo* info)
-{
-    shape.setUserPointer(const_cast<ShapeInfo*>(info));
-}
-
-inline const ShapeInfo* GetShapeInfo(const btCollisionShape& shape)
-{
-    return reinterpret_cast<ShapeInfo*>(shape.getUserPointer());
-}
-
-}

src/collision/trianglemesh.cpp

@@ -2,29 +2,19 @@
 
 collision::TriangleMesh::TriangleMesh()
 {
-}
 
-void collision::TriangleMesh::BeginMaterial(Material material)
-{
-	current_material_ = material;
 }
 
 void collision::TriangleMesh::AddTriangle(const glm::vec3& v0, const glm::vec3& v1, const glm::vec3& v2)
 {
-	if (current_material_ == PM_NONE)
-		return;
-
 	btVector3 bt_v0(v0.x, v0.y, v0.z);
 	btVector3 bt_v1(v1.x, v1.y, v1.z);
 	btVector3 bt_v2(v2.x, v2.y, v2.z);
 	bt_mesh_.addTriangle(bt_v0, bt_v1, bt_v2, false);
-	tri_materials_.push_back(current_material_);
 }
 
 void collision::TriangleMesh::Build()
 {
 	bt_shape_ = std::make_unique<btBvhTriangleMeshShape>(&bt_mesh_, true, true);
 
-	shape_info_.triangle_materials = tri_materials_;
-	SetShapeInfo(*bt_shape_, &shape_info_);
 }

src/collision/trianglemesh.hpp

@@ -1,36 +1,26 @@
 #pragma once
 
-#include <memory>
-#include <span>
 #include <vector>
-
+#include <span>
-#include <btBulletCollisionCommon.h>
 #include <glm/glm.hpp>
 
-#include "shape_info.hpp"
+#include <memory>
-#include "utils/defs.hpp"
+
+#include <btBulletCollisionCommon.h>
 
 namespace collision
 {
+	class TriangleMesh
+	{
+		btTriangleMesh bt_mesh_;
+		std::unique_ptr<btBvhTriangleMeshShape> bt_shape_;
 
-class TriangleMesh
+	public:
-{
+		TriangleMesh();
-public:
-    TriangleMesh();
-    DELETE_COPY_MOVE(TriangleMesh)
 
-    void BeginMaterial(Material material);
+		void AddTriangle(const glm::vec3& v0, const glm::vec3& v1, const glm::vec3& v2);
-    void AddTriangle(const glm::vec3& v0, const glm::vec3& v1, const glm::vec3& v2);
+		void Build();
-    void Build();
 
-    btBvhTriangleMeshShape* GetShape() const { return bt_shape_.get(); }
+		btBvhTriangleMeshShape* GetShape() const { return bt_shape_.get(); }
-
+	};
-private:
+}
-    Material current_material_ = PM_NONE;
-    btTriangleMesh bt_mesh_;
-    std::unique_ptr<btBvhTriangleMeshShape> bt_shape_;
-    std::vector<Material> tri_materials_;
-    ShapeInfo shape_info_;
-};
-
-} // namespace collision

src/game/animal.cpp

@@ -2,7 +2,6 @@
 
 #include "player_character.hpp"
 #include "input_mapping.hpp"
-#include "utils/random.hpp"
 
 game::Animal::Animal(World& world, const CharacterTuning& tuning, const glm::vec3& position, float yaw)
     : Character(world, tuning), Usable(root_.matrix), Rideable(*this, RIDEABLE_ANIMAL)
@@ -10,25 +9,10 @@ game::Animal::Animal(World& world, const CharacterTuning& tuning, const glm::vec
     SetPosition(position);
     SetYaw(yaw);
     EnablePhysics(true);
-    SetMovementType(CMT_TURN);
 
     collision::AddObjectFlags(&GetController()->GetBtGhost(), collision::OF_USABLE);
 }
 
-void game::Animal::Update()
-{
-    Think();
-    just_hit_ = false;
-    Super::Update();
-}
-
-void game::Animal::ReceiveDamage(const DamageInfo& damage)
-{
-    Super::ReceiveDamage(damage);
-    just_hit_ = true;
-    hit_from_ = damage.from_pos;
-}
-
 bool game::Animal::QueryUseTarget(PlayerCharacter& character, uint32_t target_id, UseTargetQueryResult& res)
 {
     if (character.GetRideable())
@@ -53,18 +37,12 @@ void game::Animal::Use(PlayerCharacter& character, uint32_t target_id)
 
 void game::Animal::SetRideableInput(PlayerInputFlags in)
 {
-    if (think_state_ == ANIMAL_THINKSTATE_MOUNTED)
+    SetInputs(MapPlayerInputToCharacterInput(in));
-    {
-        SetInputs(MapPlayerInputToCharacterInput(in));
-    }
 }
 
-void game::Animal::SetRideableViewAngles(float yaw, float pitch)
+void game::Animal::SetRideableYaw(float yaw)
 {
-    if (think_state_ == ANIMAL_THINKSTATE_MOUNTED)
+    SetForwardYaw(yaw);
-    {
-        SetViewAngles(yaw, pitch);
-    }
 }
 
 void game::Animal::OnPassengerChanged(size_t seat_idx, HumanCharacter* passenger)
@@ -86,170 +64,3 @@ void game::Animal::AddAnimalSeat(const glm::vec3& offset)
     use_targets_.emplace_back(this, static_cast<uint32_t>(seat_idx), offset + glm::vec3(0.0f, 0.0f, 1.0f),
                               use_message_ + " (místo " + std::to_string(seat_idx + 1) + ")");
 }
-
-bool game::Animal::IsMounted() const
-{
-    return GetPassenger(0) != nullptr;
-}
-
-void game::Animal::ChangeDirection()
-{
-    auto yaw = GetViewYaw();
-    yaw += RandomFloat(-1.0f, 1.0f) * glm::half_pi<float>() * 0.5f;
-    yaw = glm::mod(yaw, glm::two_pi<float>());
-    SetViewAngles(yaw, 0.0f);
-}
-
-void game::Animal::TryMakeSound()
-{
-    auto time = GetWorld().GetTime();
-    if (time - last_sound_time_ < 3000)
-        return;
-
-    last_sound_time_ = time;
-    MakeSound();
-}
-
-void game::Animal::Think()
-{
-    while (true)
-    {
-        auto new_state = CheckThinkStateTransition();
-        if (new_state == think_state_)
-            break;
-
-        EnterThinkState(new_state);
-    }
-}
-
-static game::CharacterInputFlags GetRandomRoamInput()
-{
-    game::CharacterInputFlags in = 0;
-    auto dir_choice = RandomFloat(0.0f, 1.0f);
-
-    if (dir_choice < 0.4f)
-        in |= 1 << game::CIN_FORWARD;
-    else if (dir_choice < 0.6f)
-        in |= (1 << game::CIN_FORWARD) | (1 << game::CIN_RIGHT);
-    else if (dir_choice < 0.8f)
-        in |= (1 << game::CIN_FORWARD) | (1 << game::CIN_RIGHT);
-
-    return in;
-}
-
-static float GetAwayYaw(const glm::vec3& my_pos, const glm::vec3& enemy)
-{
-    auto away_dir = glm::normalize(glm::vec2(my_pos - enemy));
-    auto yaw = glm::atan(-away_dir.x, away_dir.y);
-    return yaw;
-}
-
-void game::Animal::EnterThinkState(AnimalThinkState state)
-{
-    think_state_ = state;
-    think_state_start_ = GetWorld().GetTime();
-
-    switch (state)
-    {
-    case ANIMAL_THINKSTATE_IDLE:
-        SetInputs(0);
-        break;
-
-    case ANIMAL_THINKSTATE_ROAM:
-        SetViewAngles(RandomFloat(0.0f, glm::two_pi<float>()), 0.0f);
-        SetInputs(GetRandomRoamInput());
-        SetWeightSpeedMult(0.3f);
-        break;
-
-    case ANIMAL_THINKSTATE_MOUNTED:
-        SetInputs(0);
-        SetWeightSpeedMult(1.0f);
-        break;
-        
-    case ANIMAL_THINKSTATE_HURT:
-        // SetInput(CIN_JUMP, true);
-        SetWeightSpeedMult(1.0f);
-        MakeHurtSound();
-        break;
-
-    case ANIMAL_THINKSTATE_RUN_AWAY:
-        SetWeightSpeedMult(1.0f);
-        SetInputs((1 << CIN_FORWARD) | (1 << CIN_SPRINT));
-        SetViewAngles(GetAwayYaw(root_.GetGlobalPosition(), hit_from_), 0.0f);
-        break;
-
-    default:
-        break;
-    }
-}
-
-game::AnimalThinkState game::Animal::CheckThinkStateTransition()
-{
-    switch (think_state_)
-    {
-    case ANIMAL_THINKSTATE_IDLE:
-        if (IsMounted())
-            return ANIMAL_THINKSTATE_MOUNTED;
-
-        if (just_hit_)
-            return ANIMAL_THINKSTATE_HURT;
-
-        if (ChanceAvgTime(5.0f) || GetCurrentThinkStateDuration() > 10000)
-            return ANIMAL_THINKSTATE_ROAM;
-
-        if (ChanceAvgTime(15.0f))
-            TryMakeSound();
-
-        return ANIMAL_THINKSTATE_IDLE;
-    
-    case ANIMAL_THINKSTATE_ROAM:
-        if (just_hit_)
-            return ANIMAL_THINKSTATE_HURT;
-    
-        if (ChanceAvgTime(5.0f) || GetCurrentThinkStateDuration() > 15000)
-            return ANIMAL_THINKSTATE_IDLE;
-        
-        if (ChanceAvgTime(1.0f))
-            ChangeDirection();
-
-        return ANIMAL_THINKSTATE_ROAM;
-    
-    case ANIMAL_THINKSTATE_MOUNTED:
-        if (!IsMounted())
-            return ANIMAL_THINKSTATE_IDLE;
-
-        if (just_hit_ && Chance(0.07f))
-            return ANIMAL_THINKSTATE_HURT;
-
-        return ANIMAL_THINKSTATE_MOUNTED;
-
-    case ANIMAL_THINKSTATE_HURT:
-        if (GetCurrentThinkStateDuration() > 0)
-            return ANIMAL_THINKSTATE_RUN_AWAY;
-            
-        return ANIMAL_THINKSTATE_HURT;
-
-    case ANIMAL_THINKSTATE_RUN_AWAY:
-        if (!IsMounted() && GetCurrentThinkStateDuration() > 4000 &&
-            (ChanceAvgTime(7.0f) || GetCurrentThinkStateDuration() > 9000))
-            return ANIMAL_THINKSTATE_ROAM;
-
-        if (IsMounted() && (ChanceAvgTime(1.0f) || GetCurrentThinkStateDuration() > 2000))
-            return ANIMAL_THINKSTATE_IDLE;
-
-        if (ChanceAvgTime(1.0f))
-            ChangeDirection();
-
-        return ANIMAL_THINKSTATE_RUN_AWAY;
-        
-    
-    default:
-        return ANIMAL_THINKSTATE_IDLE;
-    }
-
-}
-
-int64_t game::Animal::GetCurrentThinkStateDuration() const
-{
-    return GetWorld().GetTime() - think_state_start_;
-}

src/game/animal.hpp

@@ -7,61 +7,25 @@
 namespace game
 {
 
-enum AnimalThinkState
-{
-    ANIMAL_THINKSTATE_IDLE,
-    ANIMAL_THINKSTATE_ROAM,
-    ANIMAL_THINKSTATE_MOUNTED,
-    ANIMAL_THINKSTATE_HURT,
-    ANIMAL_THINKSTATE_RUN_AWAY,
-};
-
 class Animal : public Character, public Usable, public Rideable
 {
 public:
-    using Super = Character;
-
     Animal(World& world, const CharacterTuning& tuning, const glm::vec3& position, float yaw);
 
-    virtual void Update() override;
-
-    virtual void ReceiveDamage(const DamageInfo& damage) override;
-
     virtual bool QueryUseTarget(PlayerCharacter& character, uint32_t target_id, UseTargetQueryResult& res) override;
     virtual void Use(PlayerCharacter& character, uint32_t target_id) override;
 
     virtual void SetRideableInput(PlayerInputFlags in) override;
-    virtual void SetRideableViewAngles(float yaw, float pitch) override;
+    virtual void SetRideableYaw(float yaw) override;
 
 protected:
     virtual void OnPassengerChanged(size_t seat_idx, HumanCharacter* passenger) override;
     void SetUseMessage(const std::string& message);
     void AddAnimalSeat(const glm::vec3& offset);
 
-    virtual void MakeSound() {}
-    virtual void MakeHurtSound() {}
-
-private:
-    bool IsMounted() const;
-    void ChangeDirection();
-    void TryMakeSound();
-
-    void Think();
-    void EnterThinkState(AnimalThinkState state);
-    AnimalThinkState CheckThinkStateTransition();
-    int64_t GetCurrentThinkStateDuration() const;
-
 private:
     std::string use_message_;
 
-    AnimalThinkState think_state_ = ANIMAL_THINKSTATE_IDLE;
-    int64_t think_state_start_ = 0;
-    int64_t last_sound_time_ = 0;
-
-    bool just_hit_ = false;
-    // net::EntNum attacker_ = 0;
-    glm::vec3 hit_from_{};
-
 };
 
 }

src/game/camera_controller.cpp

@@ -1,76 +0,0 @@
-#include "camera_controller.hpp"
-
-#include "utils/math.hpp"
-
-void game::CameraController::SetViewAngles(float yaw, float pitch)
-{
-    yaw_ = yaw;
-    pitch_ = pitch;
-    // TODO: validate
-}
-
-static glm::vec3 TranslationFromMatrix(const glm::mat4& matrix)
-{
-    return matrix[3];
-}
-
-static glm::vec3 UpFromMatrix(const glm::mat4& matrix)
-{
-    return matrix[2];
-}
-
-void game::CameraController::Update(float time)
-{
-    // update aim factor
-    MoveToward(aim_factor_, aiming_ ? 1.0f : 0.0f, time * 3.0f);
-}
-
-void game::CameraController::Recalculate(collision::DynamicsWorld* world)
-{
-    float yaw_cos = glm::cos(yaw_);
-    float yaw_sin = glm::sin(yaw_);
-    float pitch_cos = glm::cos(pitch_);
-    float pitch_sin = glm::sin(pitch_);
-    forward_ = glm::vec3(-yaw_sin * pitch_cos, yaw_cos * pitch_cos, pitch_sin);
-    glm::vec3 right = glm::cross(forward_, glm::vec3(0.0f, 0.0f, 1.0f));
-
-    glm::vec3 start_noaim(0.0f);
-    glm::vec3 start_aim(0.0f);
-
-    float distance_noaim = 5.0f;
-    auto aim_end_offset = right * 0.4f - forward_ * 1.8f;
-
-    if (character_transform_)
-    {
-        auto up = UpFromMatrix(*character_transform_);
-        start_noaim = TranslationFromMatrix(*character_transform_) + up * 2.0f;
-        start_aim = start_noaim - up * 0.3f;
-    }
-
-    if (rideable_transform_)
-    {
-        start_noaim = TranslationFromMatrix(*rideable_transform_) + glm::vec3(0.0f, 0.0f, 2.0f);
-        distance_noaim = 8.0f;
-        aim_end_offset = right * 0.3f - forward_ * 4.5f + glm::vec3(0.0f, 0.0f, 0.8f);
-    }
-
-    glm::vec3 end_noaim = start_noaim - forward_ * distance_noaim; 
-    glm::vec3 end_aim = start_aim + aim_end_offset;
-
-    auto aim_factor_smooth = glm::smoothstep(0.0f, 1.0f, aim_factor_);
-    auto start = glm::mix(start_noaim, start_aim, aim_factor_smooth);
-    auto end = glm::mix(end_noaim, end_aim, aim_factor_smooth);
-
-    eye_ = end;
-
-    if (world)
-    {
-        // prevent penetration through static objects
-        eye_ = world->CameraSweep(start, end);
-    }
-}
-
-glm::mat4 game::CameraController::GetViewMatrix() const
-{
-    return glm::lookAt(eye_, eye_ + forward_, glm::vec3(0.0f, 0.0f, 1.0f));
-}

src/game/camera_controller.hpp

@@ -1,46 +0,0 @@
-#pragma once
-
-#include "collision/dynamicsworld.hpp"
-
-namespace game
-{
-
-class CameraController
-{
-public:
-    CameraController() = default;
-
-    void SetCharacterTransform(const glm::mat4* transform) { character_transform_ = transform; }
-    void SetRideableTransform(const glm::mat4* transform) { rideable_transform_ = transform; }
-
-    void SetViewAngles(float yaw, float pitch);
-    float GetYaw() const { return yaw_; }
-    float GetPitch() const { return pitch_; }
-
-    void SetAiming(bool aiming) { aiming_ = aiming; }
-
-    void Update(float time);
-    void Recalculate(collision::DynamicsWorld* world);
-
-    const glm::vec3& GetEye() const { return eye_; }
-    const glm::vec3& GetForward() const { return forward_; }
-    glm::mat4 GetViewMatrix() const;
-    float GetAimFactor() const { return aim_factor_; }
-
-private:
-    const glm::mat4* character_transform_ = nullptr;
-    const glm::mat4* rideable_transform_ = nullptr;
-
-    float yaw_ = 0.0f;
-    float pitch_ = 0.0f;
-
-    bool aiming_ = false;
-    float aim_factor_ = 0.0f;
-
-    glm::vec3 eye_;
-    glm::vec3 forward_;
-
-};
-
-
-}

src/game/camera_info.hpp

@@ -1,21 +0,0 @@
-#pragma once
-
-#include "net/defs.hpp"
-
-namespace game
-{
-
-using CameraFlags = uint8_t;
-enum CameraFlag : CameraFlags
-{
-    CAM_AIMING = 1,
-};
-
-struct CameraInfo
-{
-    net::EntNum character_entnum = 0;
-    net::EntNum rideable_entnum = 0;
-    CameraFlags flags = 0;
-};
-
-}

src/game/character.cpp

@@ -1,13 +1,8 @@
 #include "character.hpp"
-
-#include <format>
-
 #include "assets/cache.hpp"
 #include "net/utils.hpp"
 #include "utils/math.hpp"
 #include "world.hpp"
-#include "utils/random.hpp"
-
 
 game::Character::Character(World& world, const CharacterTuning& tuning)
     : Super(world, net::ET_CHARACTER), tuning_(tuning), bt_shape_(tuning_.shape.radius, tuning_.shape.height)
@@ -15,7 +10,6 @@ game::Character::Character(World& world, const CharacterTuning& tuning)
     z_offset_ = tuning_.shape.height * 0.5f + tuning_.shape.radius - 0.05f;
 
     sk_ = SkeletonInstance(assets::CacheManager::GetSkeleton("data/" + tuning.model_name + ".sk"), &root_);
-    SetupHitBones();
 }
 
 static bool Turn(float& angle, float target, float step)
@@ -42,17 +36,9 @@ void game::Character::Update()
 {
     Super::Update();
 
-    pose_valid_ = false;
-    hitbones_valid_ = false;
-
     SyncTransformFromController();
     UpdateMovement();
-    UpdateAiming();
-    UpdatePain();
-    UpdateAnimAngles();
-    UpdateActionAnim();
     root_.UpdateMatrix();
-    UpdateHitBones();
 
     sync_current_ = 1 - sync_current_;
     UpdateSyncState();
@@ -74,9 +60,6 @@ void game::Character::SendInitData(Player& player, net::OutMessage& msg) const
         net::WriteRGB(msg, clothes.color);
     }
 
-    // write item
-    msg.Write(net::ModelName(item_));
-
     // write state against default
     static const CharacterSyncState default_state;
     size_t fields_pos = msg.Reserve<CharacterSyncFieldFlags>();
@@ -84,49 +67,6 @@ void game::Character::SendInitData(Player& player, net::OutMessage& msg) const
     msg.WriteAt(fields_pos, fields);
 }
 
-void game::Character::ReceiveDamage(const DamageInfo& damage)
-{
-    Super::ReceiveDamage(damage);
-
-    if (!IsAlive())
-    {
-        return; // already ded
-    }
-
-    float actual_damage = damage.damage;
-
-    if (damage.type == DAMAGE_BULLET)
-    {
-        std::string_view hit_name;
-    
-        auto it = hitbone_names_.find(damage.hit_object);
-        if (it != hitbone_names_.end())
-        {
-            hit_name = it->second;
-        }
-
-        actual_damage *= GetHitBoneDamageMultiplier(hit_name);
-
-    }
-
-    health_ -= actual_damage;
-
-    // just died
-    if (health_ <= 0.0f)
-    {
-        health_ = 0.0f;
-        death_time_ = GetWorld().GetTime();
-
-        if (on_death_)
-            on_death_();
-    }
-
-    ApplyPain();
-
-    // std::string text = "au! " + std::string(hit_name);
-    // GetWorld().SendChat(text);
-}
-
 void game::Character::Attach(net::EntNum parentnum)
 {
     Super::Attach(parentnum);
@@ -149,7 +89,6 @@ void game::Character::EnablePhysics(bool enable)
     else if (!enable && controller_)
     {
         controller_.reset();
-        root_.local.rotation = glm::quat(); // reset rotation
     }
 }
 
@@ -161,46 +100,12 @@ void game::Character::SetInput(CharacterInputType type, bool enable)
         in_ &= ~(1 << type);
 }
 
-void game::Character::SetMovementType(CharacterMovementType type)
-{
-    movement_ = type;
-}
-
-void game::Character::SetViewAngles(float yaw, float pitch)
-{
-    view_yaw_ = yaw;
-    view_pitch_ = pitch;
-}
-
 void game::Character::SetPosition(const glm::vec3& position)
 {
     root_.local.position = position;
     SyncControllerTransform();
 }
 
-void game::Character::ActivateHitBones()
-{
-    Super::ActivateHitBones();
-    EnableHitBones(true);
-}
-
-void game::Character::FinalizeFrame()
-{
-    Super::FinalizeFrame();
-    pose_valid_ = false;
-    hitbones_valid_ = false;
-}
-
-int64_t game::Character::GetDeathTime() const
-{
-     return GetWorld().GetTime() - death_time_;
-}
-
-game::Character::~Character()
-{
-    DeleteHitBones();
-}
-
 void game::Character::SetIdleAnim(const std::string& anim_name)
 {
     animstate_.idle_anim_idx = GetAnim(anim_name);
@@ -216,74 +121,6 @@ void game::Character::SetRunAnim(const std::string& anim_name)
     animstate_.run_anim_idx = GetAnim(anim_name);
 }
 
-void game::Character::PlayActionAnim(assets::AnimIdx anim_idx, float speed)
-{
-    action_anim_end_ = (anim_idx != assets::NO_ANIM) ? sk_.GetSkeleton()->GetAnimation(anim_idx)->GetDuration() : 0.0f;
-
-    if (animstate_.action_anim_idx != anim_idx)
-    {
-        // continue from current time if same anim
-        animstate_.action_time = (speed > 0.0f) ? 0.0f : action_anim_end_;
-    }
-    animstate_.action_anim_idx = anim_idx;
-    action_anim_playback_speed_ = speed;
-    action_anim_done_ = anim_idx == assets::NO_ANIM;
-}
-
-void game::Character::PlayActionAnim(const std::string& anim_name, float speed)
-{
-    if (anim_name.empty())
-    {
-        ClearActionAnim();
-        return;
-    }
-
-    PlayActionAnim(GetAnim(anim_name), speed);
-}
-
-void game::Character::ClearActionAnim()
-{
-    PlayActionAnim(assets::NO_ANIM, 0.0f);
-}
-
-void game::Character::SetAimTarget(const glm::vec3& target)
-{
-    aim_target_ = target;
-}
-
-void game::Character::SetViewItem(const std::string& item_name)
-{
-    if (item_ == item_name)
-        return;
-
-    item_ = item_name;
-
-    auto msg = BeginEntMsg(net::EMSG_EQUIP);
-    msg.Write(net::ModelName(item_name));
-}
-
-void game::Character::SendFire()
-{
-    auto msg = BeginEntMsg(net::EMSG_FIRE);
-}
-
-void game::Character::ApplyPain()
-{
-    pain_pitch_ = glm::clamp(pain_pitch_ + RandomFloat(glm::radians(-5.0f), glm::radians(20.0f)), glm::radians(-30.0f), glm::radians(30.0f));
-    pain_yaw_ = glm::clamp(pain_yaw_ + RandomFloat(glm::radians(-20.0f), glm::radians(20.0f)), glm::radians(-30.0f), glm::radians(30.0f));
-}
-
-float game::Character::GetHitBoneDamageMultiplier(const std::string_view hitbone)
-{
-    if (hitbone == "head" || hitbone == "neck")
-        return 3.0f;
-
-    if (hitbone == "torso1" || hitbone == "torso2")
-        return 1.0f;
-
-    return 0.2f;
-}
-
 void game::Character::SyncControllerTransform()
 {
     if (!controller_)
@@ -306,58 +143,42 @@ void game::Character::SyncTransformFromController()
     root_.local.position.z -= z_offset_; // foot pos
 }
 
-static glm::vec2 GetInputDir(game::CharacterInputFlags in)
-{
-    glm::vec2 dir(0.0f);
-
-    if (in & (1 << game::CIN_FORWARD))
-        dir.y += 1.0f;
-
-    if (in & (1 << game::CIN_BACKWARD))
-        dir.y -= 1.0f;
-
-    if (in & (1 << game::CIN_RIGHT))
-        dir.x -= 1.0f;
-
-    if (in & (1 << game::CIN_LEFT))
-        dir.x += 1.0f;
-
-    return dir;
-}
-
 void game::Character::UpdateMovement()
 {
-    if (movement_ == CMT_DISABLED)
-    {
-        animstate_.loco_blend = 0.0f;
-        return;
-    }
-
     constexpr float dt = 1.0f / 25.0f;
     bool walking = false;
     bool running = false;
+    glm::vec2 movedir(0.0f);
 
-    glm::vec3 move_dir(0.0f);
+    if (in_ & (1 << CIN_FORWARD))
+        movedir.y += 1.0f;
 
-    auto input_dir = GetInputDir(in_);
+    if (in_ & (1 << CIN_BACKWARD))
-    if (input_dir.x != 0.0f || input_dir.y != 0.0f)
+        movedir.y -= 1.0f;
+
+    if (in_ & (1 << CIN_RIGHT))
+        movedir.x -= 1.0f;
+
+    if (in_ & (1 << CIN_LEFT))
+        movedir.x += 1.0f;
+
+    glm::vec3 walkdir(0.0f);
+
+    if (movedir.x != 0.0f || movedir.y != 0.0f)
     {
         walking = true;
         
-        if ((in_ & (1 << CIN_SPRINT)) && can_sprint_)
+        if (in_ & (1 << CIN_SPRINT))
             running = true;
 
-        const bool directional = (movement_ == CMT_DIRECTIONAL);
+        float target_yaw = forward_yaw_ + std::atan2(movedir.x, movedir.y);
+        Turn(yaw_, target_yaw, turn_speed_ * dt);
+
+        glm::vec3 forward_dir(-glm::sin(yaw_), glm::cos(yaw_), 0.0f);
+        walkdir = forward_dir * walk_speed_ * dt;
 
-        float relative_yaw = std::atan2(input_dir.x, input_dir.y);
-        float turn_yaw = directional ? view_yaw_ : view_yaw_ + relative_yaw;
-        Turn(yaw_, turn_yaw, turn_speed_ * dt);
-        float move_yaw = directional ? yaw_ + relative_yaw : yaw_;
-    
-        move_dir = glm::vec3(-glm::sin(move_yaw), glm::cos(move_yaw), 0.0f) * walk_speed_ * dt * weight_speed_mult_;
-       
         if (running)
-            move_dir *= run_speed_mult_;
+            walkdir *= run_speed_mult_;
 
     }
 
@@ -366,7 +187,7 @@ void game::Character::UpdateMovement()
     if (controller_)
     {
         auto& bt_character = controller_->GetBtController();
-        bt_character.setWalkDirection(btVector3(move_dir.x, move_dir.y, move_dir.z));
+        bt_character.setWalkDirection(btVector3(walkdir.x, walkdir.y, walkdir.z));
 
         if (in_ & (1 << CIN_JUMP) && bt_character.canJump())
         {
@@ -377,91 +198,12 @@ void game::Character::UpdateMovement()
     // update anim
     float run_blend_target = walking ? 0.5f : 0.0f;
     MoveToward(animstate_.loco_blend, run_blend_target, dt * 2.0f);
-    float anim_speed = glm::mix(0.3f, 1.5f, UnMix(0.0f, 0.5f, animstate_.loco_blend)) * weight_speed_mult_;
+    float anim_speed = glm::mix(0.5f, 1.5f, UnMix(0.0f, 0.5f, animstate_.loco_blend));
     if (running)
         anim_speed *= run_speed_mult_;
     animstate_.loco_phase = glm::mod(animstate_.loco_phase + anim_speed * dt, 1.0f);
 }
 
-void game::Character::UpdateAiming()
-{
-    float delta = 10.0f;
-
-    if (!aiming_)
-    {
-        delta = 6.0f / 25.0f;
-        MoveToward(aim_yaw_, 0.0f, delta);
-        MoveToward(aim_pitch_, 0.0f, delta);
-        UpdateAimDirection();
-        return;
-    }
-
-    // get yaw and pitch relative to transform
-    glm::vec3 dir = aim_target_ - GetRoot().local.position;
-
-    if (parent_)
-    {
-        auto inv_parent =  glm::inverse(parent_->GetRoot().matrix);
-
-        // glm::vec3 character_pos_in_parent = inv_parent * glm::vec4(GetRoot().local.position, 1.0f);
-        glm::vec3 aim_target_in_parent = inv_parent * glm::vec4(aim_target_, 1.0f);
-        dir = aim_target_in_parent - GetRoot().local.position;
-    }
-
-    dir.z -= aim_z_offset_; // from eye
-    dir = glm::normalize(dir);
-
-    float pitch = glm::asin(dir.z);
-    float yaw = glm::atan(-dir.x, dir.y);
-
-    auto target_pitch = glm::clamp(pitch, glm::radians(-60.0f), glm::radians(55.0f)); // clamp to make it less weird
-    MoveToward(aim_pitch_, target_pitch, delta);
-
-    if (movement_ == CMT_DISABLED)
-    {
-        auto target_yaw = glm::mod(yaw + glm::pi<float>(), glm::two_pi<float>()) - glm::pi<float>();
-        const float yaw_limit = glm::radians(120.0f);
-        target_yaw = glm::clamp(target_yaw, -yaw_limit, yaw_limit);
-        MoveToward(aim_yaw_, target_yaw, delta);
-    }
-    else
-    {
-        Turn(yaw_, yaw, delta);
-        MoveToward(aim_yaw_, 0.0f, delta);
-    }
-
-    UpdateAimDirection();
-}
-
-void game::Character::UpdateAimDirection()
-{
-    eye_pos_ = GetRoot().matrix * glm::vec4(0.0f, 0.0f, aim_z_offset_, 1.0f);
-
-    auto pitch = aim_pitch_;
-    auto yaw = yaw_ + aim_yaw_;
-    aim_dir_ = glm::vec3(-glm::sin(yaw) * glm::cos(pitch), glm::cos(yaw) * glm::cos(pitch), glm::sin(pitch));
-
-    if (parent_)
-    {
-        aim_dir_ = glm::normalize(parent_->GetRoot().matrix * glm::vec4(aim_dir_, 0.0f));
-    }
-
-    // GetWorld().Beam(eye_pos_, eye_pos_ + aim_dir_ * 100.0f, 0x0000FF, 1.0f / 25.0f);
-}
-
-void game::Character::UpdatePain()
-{
-    float delta = 1.5f / 25.0f;
-    MoveToward(pain_yaw_, 0.0f, delta);
-    MoveToward(pain_pitch_, 0.0f, delta);
-}
-
-void game::Character::UpdateAnimAngles()
-{
-    animstate_.yaw = aim_yaw_ + pain_yaw_;
-    animstate_.pitch = aim_pitch_ + pain_pitch_;
-}
-
 void game::Character::UpdateSyncState()
 {
     auto& state = sync_[sync_current_];
@@ -478,14 +220,6 @@ void game::Character::UpdateSyncState()
     state.run_anim = animstate_.run_anim_idx;
     state.loco_phase.Encode(animstate_.loco_phase);
     state.loco_blend.Encode(animstate_.loco_blend);
-
-    // action
-    state.action_anim = animstate_.action_anim_idx;
-    state.action_time.Encode(animstate_.action_time);
-
-    // aim
-    state.aim_yaw.Encode(animstate_.yaw);
-    state.aim_pitch.Encode(animstate_.pitch);
 }
 
 void game::Character::SendUpdateMsg()
@@ -548,31 +282,6 @@ game::CharacterSyncFieldFlags game::Character::WriteState(net::OutMessage& msg,
         net::WriteDelta(msg, curr.loco_phase, base.loco_phase);
     }
 
-    // action anim
-    if (curr.action_anim != base.action_anim)
-    {
-        fields |= CSF_ACTION_ANIM;
-
-        msg.Write(curr.action_anim);
-    }
-
-    // action phase
-    if (curr.action_time.value != base.action_time.value)
-    {
-        fields |= CSF_ACTION_TIME;
-
-        net::WriteDelta(msg, curr.action_time, base.action_time);
-    }
-
-    // aim
-    if (curr.aim_yaw.value != base.aim_yaw.value || curr.aim_pitch.value != base.aim_pitch.value)
-    {
-        fields |= CSF_AIM;
-
-        net::WriteDelta(msg, curr.aim_yaw.value, base.aim_yaw.value);
-        net::WriteDelta(msg, curr.aim_pitch.value, base.aim_pitch.value);
-    }
-
     return fields;
 }
 
@@ -581,169 +290,6 @@ assets::AnimIdx game::Character::GetAnim(const std::string& name) const
     return sk_.GetSkeleton()->GetAnimationIdx(name);
 }
 
-void game::Character::SetupHitBones()
-{
-    const auto& sk_hitbones = sk_.GetSkeleton()->GetHitBones();
-    hitbones_.resize(sk_hitbones.size());
-
-    for (size_t i = 0; i < hitbones_.size(); ++i)
-    {
-        auto& hitbone = hitbones_[i];
-        auto& sk_hitbone = sk_hitbones[i];
-
-        // setup node
-        hitbone.node.parent = &sk_.GetBoneNode(sk_hitbone.bone_idx);
-        hitbone.node.local = sk_hitbone.offset;
-
-        // setup object
-        auto& col_obj = hitbone.col_obj;
-        col_obj.setCollisionShape(sk_hitbone.col_shape.get());
-        collision::SetObjectInfo(&col_obj, collision::OT_ENTITY, 0, this);
-
-        hitbone_names_[&col_obj] = sk_hitbone.name;
-    }
-    
-    // setup proxy
-    static btSphereShape proxy_shape(1.5f);
-    hitbone_proxy_.setCollisionShape(&proxy_shape);
-    collision::SetObjectInfo(&hitbone_proxy_, collision::OT_ENTITY, 0, this);
-    GetWorld().GetBtWorld().addCollisionObject(&hitbone_proxy_, collision::OG_HITBONES_PROXY, collision::OG_PROJECTILE);
-}
-
-void game::Character::EnableHitBones(bool enable)
-{
-    if (enable)
-    {
-        hitbones_timer_ = 2; // reset timer
-    }
-
-    if (enable == hitbones_active_)
-        return;
-
-    hitbones_active_ = enable;
-    hitbones_valid_ = false;
-
-    auto& bt_world = GetWorld().GetBtWorld();
-
-    if (enable)
-    {
-        UpdateHitBoneTransforms(); // update transforms first
-
-        for (auto& hitbone : hitbones_)
-        {
-            bt_world.addCollisionObject(&hitbone.col_obj, collision::OG_DEFAULT, collision::OG_PROJECTILE);
-        }
-    }
-    else
-    {
-        for (auto& hitbone : hitbones_)
-        {
-            bt_world.removeCollisionObject(&hitbone.col_obj);
-        }
-    }
-
-}
-
-void game::Character::UpdateHitBones()
-{
-    // update proxy transform
-    glm::vec3 center = GetRoot().matrix * glm::vec4(0.0f, 0.0f, 1.0f, 1.0f);
-    btTransform trans;
-    trans.setIdentity();
-    trans.setOrigin(btVector3(center.x, center.y, center.z));
-    hitbone_proxy_.setWorldTransform(trans);
-
-    if (hitbones_active_)
-    {
-        if (hitbones_timer_ > 0)
-            --hitbones_timer_;
-        else
-            EnableHitBones(false);
-    }
-
-    UpdateHitBoneTransforms();
-}
-
-static btTransform BtTransformFromMat4(const glm::mat4& m)
-{
-    btMatrix3x3 basis(
-        m[0][0], m[1][0], m[2][0],
-        m[0][1], m[1][1], m[2][1],
-        m[0][2], m[1][2], m[2][2]
-    );
-
-    btVector3 origin(
-        m[3][0],
-        m[3][1],
-        m[3][2]
-    );
-
-    btTransform trans;
-    trans.setBasis(basis);
-    trans.setOrigin(origin);
-    return trans;
-}
-
-void game::Character::UpdateHitBoneTransforms()
-{
-    if (hitbones_valid_ || !hitbones_active_)
-        return;
-
-    UpdatePose();
-
-    for (auto& hitbone : hitbones_)
-    {
-        hitbone.node.UpdateMatrix();
-        hitbone.col_obj.setWorldTransform(BtTransformFromMat4(hitbone.node.matrix));
-
-        // debug boxes
-        // GetWorld().BeamBox(hitbone.node.GetGlobalPosition() - 0.05f, hitbone.node.GetGlobalPosition() + 0.05f, 0xFFFF00,
-        //                    1.5f / 25.0f);
-    }
-}
-
-void game::Character::DeleteHitBones()
-{
-    EnableHitBones(false);
-    GetWorld().GetBtWorld().removeCollisionObject(&hitbone_proxy_);
-}
-
-void game::Character::UpdateActionAnim()
-{
-    if (action_anim_done_)
-        return;
-
-    animstate_.action_time += action_anim_playback_speed_ * (1.0f / 25.0f);
-    
-    if (action_anim_playback_speed_ > 0.0f)
-    {
-        if (animstate_.action_time >= action_anim_end_)
-        {
-            animstate_.action_time = action_anim_end_;
-            action_anim_done_ = true;
-        }
-    }
-    else
-    {
-        if (animstate_.action_time <= 0.0f)
-        {
-            animstate_.action_time = 0.0f;
-            action_anim_done_ = true;
-        }
-    }
-}
-
-void game::Character::UpdatePose()
-{
-    if (pose_valid_)
-        return;
-
-    animstate_.ApplyToSkeleton(sk_);
-    sk_.UpdateBoneMatrices();
-
-    pose_valid_ = true;
-}
-
 game::CharacterPhysicsController::CharacterPhysicsController(Character& character, btDynamicsWorld& bt_world, btCapsuleShapeZ& bt_shape)
     : character_(character), bt_world_(bt_world), bt_character_(&bt_ghost_, &bt_shape, 0.3f, btVector3(0, 0, 1))
 {
@@ -753,7 +299,7 @@ game::CharacterPhysicsController::CharacterPhysicsController(Character& characte
     bt_ghost_.setCollisionShape(&bt_shape);
     bt_ghost_.setCollisionFlags(btCollisionObject::CF_CHARACTER_OBJECT);
 
-    collision::SetObjectInfo(&bt_ghost_, collision::OT_ENTITY, collision::OF_CRASH_DAMAGE, &character);
+    collision::SetObjectInfo(&bt_ghost_, collision::OT_ENTITY, 0, &character);
 
     bt_world_.addCollisionObject(&bt_ghost_, btBroadphaseProxy::CharacterFilter,
                                  btBroadphaseProxy::StaticFilter | btBroadphaseProxy::DefaultFilter);

src/game/character.hpp

@@ -45,19 +45,6 @@ private:
     btKinematicCharacterController bt_character_;
 };
 
-enum CharacterMovementType
-{
-    CMT_DISABLED,
-    CMT_TURN,
-    CMT_DIRECTIONAL,
-};
-
-struct CharacterHitBoneInstance
-{
-    btCollisionObject col_obj;
-    TransformNode node;
-};
-
 class Character : public Entity
 {
 public:
@@ -67,8 +54,6 @@ public:
 
     virtual void Update() override;
     virtual void SendInitData(Player& player, net::OutMessage& msg) const override;
-    
-    virtual void ReceiveDamage(const DamageInfo& damage) override;
 
     virtual void Attach(net::EntNum parentnum) override;
 
@@ -79,83 +64,36 @@ public:
 
     void SetInput(CharacterInputType type, bool enable);
     void SetInputs(CharacterInputFlags inputs) { in_ = inputs; }
-    CharacterInputFlags GetInputs() const { return in_; }
-
-    void SetMovementType(CharacterMovementType type);
-
-    void SetViewAngles(float yaw, float pitch);
-    float GetViewYaw() const { return view_yaw_; }
-    float GetViewPitch() const { return view_pitch_; }
-
-    const glm::vec3& GetEyePosition() const { return eye_pos_; }
-    const glm::vec3& GetAimDirection() const { return aim_dir_; }
 
+    void SetForwardYaw(float yaw) { forward_yaw_ = yaw; }
+    float GetForwardYaw() const { return forward_yaw_; }
     void SetYaw(float yaw) { yaw_ = yaw; }
 
     void SetPosition(const glm::vec3& position);
 
-    void SetWeightSpeedMult(float mult) { weight_speed_mult_ = mult; }
+    
-
+    ~Character() override = default;
-    virtual void ActivateHitBones() override;
-    virtual void FinalizeFrame() override;
-
-    float GetHealth() const { return health_; }
-    bool IsAlive() const { return death_time_ < 0; }
-    int64_t GetDeathTime() const;
-
-    void SetOnDeath(std::function<void()> cb) { on_death_ = std::move(cb); }
-
-    ~Character() override;
     
 protected:
-    void SetCanSprint(bool can_sprint) { can_sprint_ = can_sprint; }
     void SetIdleAnim(const std::string& anim_name);
     void SetWalkAnim(const std::string& anim_name);
     void SetRunAnim(const std::string& anim_name);
-    void PlayActionAnim(assets::AnimIdx anim_idx, float speed);
-    void PlayActionAnim(const std::string& anim_name, float speed = 1.0f);
-    void ClearActionAnim();
-    bool IsActionAnimDone() { return action_anim_done_; }
-    void SetAiming(bool aiming) { aiming_ = aiming; }
-    bool GetAiming() const { return aiming_; }
-    void SetAimTarget(const glm::vec3& target);
-    void SetViewItem(const std::string& item_name);
-    void SendFire();
-    void ApplyPain();
-
-    virtual float GetHitBoneDamageMultiplier(const std::string_view hitbone);
 
 private:
     void SyncControllerTransform();
     void SyncTransformFromController();
 
     void UpdateMovement();
-    void UpdateAiming();
-    void UpdateAimDirection();
-    void UpdatePain();
-    void UpdateAnimAngles();
     void UpdateSyncState();
     void SendUpdateMsg();
     CharacterSyncFieldFlags WriteState(net::OutMessage& msg, const CharacterSyncState& base) const;
 
     assets::AnimIdx GetAnim(const std::string& name) const;
 
-    void SetupHitBones();
-    void EnableHitBones(bool enable);
-    void UpdateHitBones();
-    void UpdateHitBoneTransforms();
-    void DeleteHitBones();
-
-    void UpdateActionAnim();
-
-    void UpdatePose();
-
-
 protected:
     float turn_speed_ = 8.0f;
     float walk_speed_ = 2.0f;
     float run_speed_mult_ = 3.0f;
-    float weight_speed_mult_ = 1.0f;
 
 private:
     CharacterTuning tuning_;
@@ -164,55 +102,19 @@ private:
     // glm::vec3 velocity_ = glm::vec3(0.0f);
 
     CharacterInputFlags in_ = 0;
-    bool can_sprint_ = true;
 
     btCapsuleShapeZ bt_shape_;
     float z_offset_ = 0.0f; // offset of controller from root
     std::unique_ptr<CharacterPhysicsController> controller_;
 
     float yaw_ = 0.0f;
-    float view_yaw_ = 0.0f;
+    float forward_yaw_ = 0.0f;
-    float view_pitch_ = 0.0f;
-
-    float aim_yaw_ = 0.0f;
-    float aim_pitch_ = 0.0f;
-
-    float pain_yaw_ = 0.0f;
-    float pain_pitch_ = 0.0f;
 
     SkeletonInstance sk_;
     CharacterAnimState animstate_;
 
     CharacterSyncState sync_[2];
     size_t sync_current_ = 0;
-
-    CharacterMovementType movement_ = CMT_DISABLED;
-
-    float action_anim_playback_speed_ = 0.0f;
-    float action_anim_end_ = 0.0f;
-    bool action_anim_done_ = true;
-
-    bool aiming_ = false;
-    glm::vec3 aim_target_ = glm::vec3(0.0f);
-    float aim_z_offset_ = 1.6f;
-    glm::vec3 eye_pos_ = glm::vec3(0.0f);
-    glm::vec3 aim_dir_ = glm::vec3(0.0f);
-
-    std::string item_;
-
-    bool pose_valid_ = false;
-
-    std::vector<CharacterHitBoneInstance> hitbones_;
-    btCollisionObject hitbone_proxy_;
-    bool hitbones_active_ = false;
-    size_t hitbones_timer_ = 0;
-    bool hitbones_valid_ = false;
-    std::map<const btCollisionObject*, std::string_view> hitbone_names_;
-
-    float health_ = 100.0f;
-    int64_t death_time_ = -1;
-
-    std::function<void()> on_death_;
 };
 
 } // namespace game

src/game/character_anim_state.cpp

@@ -26,6 +26,7 @@ void game::CharacterAnimState::ApplyToSkeleton(SkeletonInstance& sk) const
         sk.ApplySkelAnim(*idle_anim, loco_phase, 1.0f);
         sk.ApplySkelAnim(*walk_anim, loco_phase, UnMix(0.0f, 0.5f, loco_blend));
     }
+
     else if (loco_blend == 0.5f) // walk
     {
         sk.ApplySkelAnim(*walk_anim, loco_phase, 1.0f);
@@ -40,16 +41,4 @@ void game::CharacterAnimState::ApplyToSkeleton(SkeletonInstance& sk) const
         sk.ApplySkelAnim(*run_anim, loco_phase, 1.0f);
     }
 
-    // action
-    auto action_anim = skeleton->GetAnimation(action_anim_idx);
-    if (action_anim)
-    {
-        sk.ApplySkelAnim(*action_anim, action_time, 1.0f);
-    }
-
-    if (glm::abs(yaw) > 0.01f || glm::abs(pitch) > 0.01f)
-    {
-        sk.ApplyAim(yaw, pitch);
-    }
-
 }

src/game/character_anim_state.hpp

@@ -8,18 +8,12 @@ namespace game
 struct CharacterAnimState
 {
     assets::AnimIdx idle_anim_idx = assets::NO_ANIM;
-
     assets::AnimIdx walk_anim_idx = assets::NO_ANIM;
     assets::AnimIdx run_anim_idx = assets::NO_ANIM;
+
     float loco_blend = 0.0f;
     float loco_phase = 0.0f;
 
-    assets::AnimIdx action_anim_idx = assets::NO_ANIM;
-    float action_time = 0.0f;
-
-    float yaw = 0.0f;
-    float pitch = 0.0f;
-
     void ApplyToSkeleton(SkeletonInstance& sk) const;
 
 

src/game/character_sync.hpp

@@ -21,31 +21,21 @@ struct CharacterSyncState
     assets::AnimIdx walk_anim = assets::NO_ANIM;
     assets::AnimIdx run_anim = assets::NO_ANIM;
     net::AnimBlendQ loco_blend;
-    net::AnimPhaseQ loco_phase;
+    net::AnimTimeQ loco_phase;
-
-    // action anim
-    assets::AnimIdx action_anim = assets::NO_ANIM;
-    net::AnimTimeQ action_time;
-
-    // aim
-    net::AnimAimAngleQ aim_yaw;
-    net::AnimAimAngleQ aim_pitch;
-
     //assets::AnimIdx strafe_left_anim = assets::NO_ANIM;
     //assets::AnimIdx strafe_right_anim = assets::NO_ANIM;
+
+    // TODO: action
 };
 
 using CharacterSyncFieldFlags = uint8_t;
 
 enum CharacterSyncFieldFlag
 {
-    CSF_TRANSFORM = 1,
+    CSF_TRANSFORM = 0x01,
-    CSF_IDLE_ANIM = 2,
+    CSF_IDLE_ANIM = 0x02,
-    CSF_LOCO_ANIMS = 4,
+    CSF_LOCO_ANIMS = 0x04,
-    CSF_LOCO_VALS = 8,
+    CSF_LOCO_VALS = 0x08,
-    CSF_ACTION_ANIM = 16,
-    CSF_ACTION_TIME = 32,
-    CSF_AIM = 64,
 };
 
 } // namespace game

src/game/cow.cpp

@@ -22,6 +22,7 @@ game::Cow::Cow(World& world, const glm::vec3& position, float yaw) : Animal(worl
     SetIdleAnim("idle");
     SetWalkAnim("walk");
 
+    ScheduleRandomMoo();
 }
 
 void game::Cow::OnPassengerChanged(size_t seat_idx, HumanCharacter* passenger)
@@ -34,14 +35,12 @@ void game::Cow::OnPassengerChanged(size_t seat_idx, HumanCharacter* passenger)
     }
 }
 
-void game::Cow::MakeSound()
+void game::Cow::ScheduleRandomMoo()
 {
-    PlayRandomMoo();
+    Schedule(rand() % 15000 + 5000, [this]() {
-}
+        PlayRandomMoo();
-
+        ScheduleRandomMoo();
-void game::Cow::MakeHurtSound()
+    });
-{
-    PlayUseSound();
 }
 
 void game::Cow::PlayRandomMoo()

src/game/cow.hpp

@@ -15,10 +15,8 @@ public:
 protected:
     virtual void OnPassengerChanged(size_t seat_idx, HumanCharacter* passenger) override;
 
-    virtual void MakeSound() override;
-    virtual void MakeHurtSound() override;
-
 private:
+    void ScheduleRandomMoo();
     void PlayRandomMoo();
     void PlayUseSound();
 

src/game/drivable_vehicle.cpp

@@ -3,7 +3,7 @@
 #include "utils/random.hpp"
 #include "input_mapping.hpp"
 
-game::DrivableVehicle::DrivableVehicle(World& world, const VehicleSpawnInfo& info) : Vehicle(world, info), Usable(GetRoot().matrix), Rideable(*this, RIDEABLE_VEHICLE)
+game::DrivableVehicle::DrivableVehicle(World& world, const VehicleTuning& tuning) : Vehicle(world, tuning), Usable(GetRoot().matrix), Rideable(*this, RIDEABLE_VEHICLE)
 {
     InitSeats();
     OnPhysicsChanged();
@@ -18,11 +18,6 @@ void game::DrivableVehicle::Update()
 
 }
 
-game::HumanCharacter* game::DrivableVehicle::GetResponsibleCharacter()
-{
-    return GetPassenger(0);
-}
-
 void game::DrivableVehicle::SetTuning(const VehicleTuning& tuning)
 {
     Super::SetTuning(tuning);
@@ -58,11 +53,6 @@ void game::DrivableVehicle::Use(PlayerCharacter& character, uint32_t target_id)
     PlaySound("cardoor", 1.0f, RandomFloat(0.9f, 1.1f));
 }
 
-void game::DrivableVehicle::ReceiveDamage(const DamageInfo& damage)
-{
-    Super::ReceiveDamage(damage);
-    OnRideableDamaged(damage);
-}
 
 void game::DrivableVehicle::SetRideableInput(PlayerInputFlags in)
 {
@@ -74,7 +64,6 @@ void game::DrivableVehicle::OnPassengerChanged(size_t seat_idx, HumanCharacter*
     if (seat_idx == 0 && !passenger)
     {
         // driver left
-        SetSteering(false, 0.0f);
         SetInputs(0);
     }
 }

src/game/drivable_vehicle.hpp

@@ -13,12 +13,10 @@ class DrivableVehicle : public Vehicle, public Usable, public Rideable
 public:
     using Super = Vehicle;
 
-    DrivableVehicle(World& world, const VehicleSpawnInfo& info);
+    DrivableVehicle(World& world, const VehicleTuning& tuning);
 
     virtual void Update() override;
 
-    virtual HumanCharacter* GetResponsibleCharacter() override;
-
     virtual void SetTuning(const VehicleTuning& tuning) override;
 
     virtual void OnPhysicsChanged() override;
@@ -26,8 +24,6 @@ public:
     virtual bool QueryUseTarget(PlayerCharacter& character, uint32_t target_id, UseTargetQueryResult& res) override;
     virtual void Use(PlayerCharacter& character, uint32_t target_id) override;
 
-    virtual void ReceiveDamage(const DamageInfo& damage) override;
-
     virtual void SetRideableInput(PlayerInputFlags in) override;
 
 protected:

src/game/enterable_world.cpp

@@ -18,20 +18,6 @@ void game::EnterableWorld::PlayerInput(Player& player, PlayerInputType type, boo
 
     auto character = it->second;
 
-    // check respawn
-    if (type == IN_ATTACK_PRIMARY && enabled)
-    {
-        auto current_character = GetPlayerCharacter(player);
-
-        if (current_character->IsDead() && current_character->GetDeathTime() >= 3000)
-        {
-            auto& tuning = current_character->GetHumanTuning();
-            CreatePlayerCharacter(player, tuning, spawnpoint_, 0.0f);
-        }
-
-        return;
-    }
-
     switch (type)
     {
     // case IN_DEBUG1:
@@ -59,7 +45,7 @@ void game::EnterableWorld::PlayerViewAnglesChanged(Player& player, float yaw, fl
 
     auto character = it->second;
 
-    character->SetViewAngles(yaw, pitch);
+    character->SetForwardYaw(yaw);
 }
 
 void game::EnterableWorld::RemovePlayer(Player& player)

src/game/enterable_world.hpp

@@ -27,16 +27,13 @@ public:
 
     PlayerCharacter* GetPlayerCharacter(Player& player);
 
-    void SetSpawnPoint(const glm::vec3& pos) { spawnpoint_ = pos; }
-    const glm::vec3& GetSpawnPoint() const { return spawnpoint_; }
-
 private:
     PlayerCharacter& CreatePlayerCharacter(Player& player, const HumanCharacterTuning& tuning, const glm::vec3& position, float yaw);
     void RemovePlayerCharacter(Player& player);
 
 private:
     std::map<Player*, PlayerCharacter*> player_characters_;
-    glm::vec3 spawnpoint_{};
+
 
 };
 

src/game/entity.hpp

@@ -34,7 +34,7 @@ public:
  
     std::span<const char> GetUpdateMsg() const { return update_msg_buf_; }
 
-    virtual void FinalizeFrame();
+    void FinalizeFrame();
 
     void SetNametag(const std::string& nametag);
      

src/game/game.cpp

@@ -4,6 +4,9 @@
 #include "player.hpp"
 #include "player_character.hpp"
 
+static constexpr glm::vec3 openworld_spawn(100.0f, 100.0f, 1.0f);
+static constexpr glm::vec3 test_spawn(0.0f, 0.0f, 0.1f);
+
 static uint32_t GetRandomColor24()
 {
     uint8_t r, g, b;
@@ -53,7 +56,7 @@ void game::Game::PlayerJoined(Player& player)
     tuning.clothes.push_back({"tshirt", GetRandomColor24()});
     tuning.clothes.push_back({"shorts", GetRandomColor24()});
 
-    openworld_->InsertPlayer(player, tuning, openworld_->GetSpawnPoint(), 0.0f);
+    openworld_->InsertPlayer(player, tuning, openworld_spawn, 0.0f);
 }
 
 void game::Game::PlayerViewAnglesChanged(Player& player, float yaw, float pitch)
@@ -140,12 +143,10 @@ game::PlayerCharacter& game::Game::MovePlayerToWorld(PlayerGameInfo& player_info
 
     auto old_character = old_world.GetPlayerCharacter(player); 
     auto& tuning = old_character->GetHumanTuning();
-    auto inventory = old_character->TakeInventory();
     old_world.RemovePlayer(player);
 
     player.SetWorld(&new_world);
     auto& new_character = new_world.InsertPlayer(player, tuning, pos, yaw);
-    new_character.SetInventory(std::move(inventory));
 
     player_info.world = &new_world;
 
@@ -155,19 +156,18 @@ game::PlayerCharacter& game::Game::MovePlayerToWorld(PlayerGameInfo& player_info
 void game::Game::MoveVehicleToWorld(DrivableVehicle& vehicle, EnterableWorld& new_world, const glm::vec3& pos,
                                     float yaw)
 {
-    VehicleSpawnInfo vehicle_info{};
+    auto& tuning = vehicle.GetTuning();
-    vehicle_info.tuning = vehicle.GetTuning();
+    auto& new_vehicle = new_world.Spawn<DrivableVehicle>(tuning);
-    vehicle_info.position = pos;
+    new_vehicle.SetPosition(pos);
-    vehicle_info.yaw = yaw;
+    // TODO: yaw
-    auto& new_vehicle = new_world.Spawn<DrivableVehicle>(vehicle_info);
+
-    
     // move passengers
     size_t num_seats = vehicle.GetNumSeats();
     for (size_t i = 0; i < num_seats; ++i)
     {
         auto passenger = vehicle.GetPassenger(i);
-        if (!passenger || !passenger->IsAlive())
+        if (!passenger)
-            continue; // empty seat or ded
+            continue; // empty seat
 
         auto player_passenger = dynamic_cast<PlayerCharacter*>(passenger);
         if (!player_passenger)

src/game/human_character.cpp

@@ -1,6 +1,5 @@
 #include "human_character.hpp"
 #include "drivable_vehicle.hpp"
-#include "utils/random.hpp"
 
 static game::CharacterTuning GetCharacterTuning(const game::HumanCharacterTuning& tuning)
 {
@@ -18,41 +17,33 @@ game::HumanCharacter::HumanCharacter(World& world, const HumanCharacterTuning& t
     SetWalkAnim("walk");
 }
 
-void game::HumanCharacter::Update()
-{
-    UpdateState();
-    UpdateActionState();
-    UpdateDispersion();
-    Super::Update();
-}
-
-void game::HumanCharacter::ReceiveDamage(const DamageInfo& damage)
-{
-    if (!IsAlive())
-        return;
-
-    Super::ReceiveDamage(damage);
-
-    if (damage.inflictor && damage.inflictor != this)
-    {
-        damage.inflictor->OnDamageDealt(!IsAlive());
-    }
-}
-
 void game::HumanCharacter::SetRideable(Rideable* rideable, size_t seat_idx)
 {
     if (rideable == rideable_ && seat_idx == seat_idx_)
         return;
-    
+        
-    if (rideable_)
+    if (rideable)
     {
+        SetPosition(rideable->GetSeatOffset(seat_idx));
+        EnablePhysics(false);
+
+        Attach(rideable->GetEntity().GetEntNum());
+        SetIdleAnim((rideable->GetRideableType() == RIDEABLE_VEHICLE && seat_idx == 0) ? "vehicle_drive" : "vehicle_passenger");
+        SetYaw(0.0f);
+    }
+    else
+    {
+        EnablePhysics(true);
+
         glm::vec3 seat_loc = rideable_->GetSeatOffset(seat_idx_);
         seat_loc.x += glm::sign(seat_loc.x) * 0.5f; // to the side
 
         glm::vec3 pos = rideable_->GetEntity().GetRoot().matrix * glm::vec4(seat_loc, 1.0f);
         pos.z += 0.5f;
+        SetPosition(pos);
 
-        rideable_exit_pos_ = pos;
+        Attach(0);
+        SetIdleAnim("idle");
     }
 
     rideable_ = rideable;
@@ -60,8 +51,8 @@ void game::HumanCharacter::SetRideable(Rideable* rideable, size_t seat_idx)
     seat_idx_ = seat_idx;
     is_driver_ = rideable && seat_idx_ == 0;
 
-    SetSignal(HSS_RIDEABLE_CHANGED);
     OnRideableChanged();
+
 }
 
 void game::HumanCharacter::Ride(Rideable* rideable, size_t seat_idx)
@@ -77,577 +68,7 @@ void game::HumanCharacter::Ride(Rideable* rideable, size_t seat_idx)
     }
 }
 
-void game::HumanCharacter::Equip(std::shared_ptr<ItemInstance> item)
-{
-    if (!IsAlive() && item)
-        return;
-
-    pending_item_ = std::move(item);
-}
-
-bool game::HumanCharacter::IsDead() const
-{
-    return actionstate_ == ACTION_DEAD;
-}
-
 game::HumanCharacter::~HumanCharacter()
 {
     Ride(nullptr, 0); // exit rideable
 }
-
-bool game::HumanCharacter::HaveAmmo(const std::string& ammo_name)
-{
-    return true;
-}
-
-size_t game::HumanCharacter::GetAmmo(size_t required, const std::string& ammo_name)
-{
-    return required; // unlimited by default
-}
-
-bool game::HumanCharacter::IsOnFoot() const
-{
-    return state_ == HS_ON_FOOT;
-}
-
-int64_t game::HumanCharacter::GetTime() const
-{
-    return GetWorld().GetTime();
-}
-
-bool game::HumanCharacter::CanAim()
-{
-    return !NeedReload() && !PendingItemSwitch() && !(GetVehicle() && IsDriver() && !item_);
-}
-
-void game::HumanCharacter::SetAiming(bool aiming)
-{
-    if (aiming == GetAiming())
-        return;
-
-    Super::SetAiming(aiming);
-    OnAimingChanged();
-}
-
-bool game::HumanCharacter::CanFire()
-{
-    return item_ && item_->ammo > 0 && ((GetTime() - last_fire_time_ + 40) >= item_->def->fire_delay);
-}
-
-void game::HumanCharacter::Fire()
-{
-    if (!item_)
-        return; // fire wat?
-
-    // PlaySound("airrifle_fire");
-    SendFire();
-
-    float range = 500.0f;
-    // float dispersion = 5.0f; // m/100m
-    
-    game::BulletInfo bullet{};
-    bullet.start = GetEyePosition();
-    bullet.end = bullet.start + ApplyRandomDispersion(GetAimDirection(), dispersion_) * range;
-    bullet.damage = item_->def->damage;
-    bullet.shooter = this;
-    GetWorld().FireBullet(bullet);
-
-    last_fire_time_ = GetTime();
-    dispersion_ = glm::min(dispersion_ + item_->def->dispersion_shot, item_->def->dispersion_max);
-
-    // it should always be >0 but if it has been faked this far
-    // nothing else can be done than to pretend that
-    // the bullet was there
-    if (item_->ammo > 0)
-    { 
-        --item_->ammo;
-    }
-}
-
-bool game::HumanCharacter::NeedReload()
-{
-    return item_ && CanReload() && (item_->ammo == 0 || reloadheld_);
-}
-
-bool game::HumanCharacter::CanReload()
-{
-    return item_ && HaveAmmo(item_->def->ammo_type) && item_->ammo < item_->def->clip_size;
-}
-
-void game::HumanCharacter::Reload()
-{
-    if (!item_)
-        return;
-
-    item_->ammo += GetAmmo(item_->def->clip_size - item_->ammo, item_->def->ammo_type);
-}
-
-bool game::HumanCharacter::PendingItemSwitch()
-{
-    return pending_item_ != item_;
-}
-
-void game::HumanCharacter::SwitchItem()
-{
-    if (item_ == pending_item_)
-        return;
-
-    item_ = pending_item_;
-    UpdateItemStuff();
-    OnHeldItemChanged();
-}
-
-void game::HumanCharacter::UpdateItemStuff()
-{
-    // update legs anim
-    if (state_ == HS_ON_FOOT)
-    {
-        if (item_ && !item_->def->legs_anim.empty())
-            SetIdleAnim(item_->def->legs_anim);
-        else
-            SetIdleAnim("idle");
-
-        // SetIdleAnim("idle_relaxed");
-    }
-
-    // update view item
-    if (item_)
-    {
-        SetViewItem(item_->def->name);
-        SetWeightSpeedMult(item_->def->walk_speed_mult);
-    }
-    else
-    {
-        SetViewItem("");
-        SetWeightSpeedMult(1.0f);
-    }
-}
-
-void game::HumanCharacter::ClearItem()
-{
-    auto item = item_;
-    Equip(nullptr);
-    SwitchItem();
-}
-
-void game::HumanCharacter::PlayItemActionAnim(const std::string assets::Item::*anim, float speed)
-{
-    if (!item_)
-    {
-        ClearActionAnim();
-        return;
-    }
-
-    PlayActionAnim(item_->def.get()->*anim, speed);
-}
-
-void game::HumanCharacter::PlayDeathAnim()
-{
-    if (state_ == HS_ON_FOOT)
-    {
-        PlayActionAnim("die", 1.5f);
-    }
-    else if (state_ == HS_RIDING)
-    {
-        if (GetVehicle())
-        {
-            PlayActionAnim(IsDriver() ? "vehicle_drive_die" : "vehicle_passenger_die", 1.0f);
-        }
-        else
-        {
-            PlayActionAnim("vehicle_passenger_die_animal", 1.0f);
-        }
-    }
-}
-
-void game::HumanCharacter::TrySpawnLoot()
-{
-    if (loot_spawned_)
-        return;
-    
-    loot_spawned_ = true;
-    SpawnLoot();
-}
-
-void game::HumanCharacter::UpdateState()
-{
-    struct HumanCharacterStateTableEntry
-    {
-        void (HumanCharacter::*enter)();
-        HumanCharacterState (HumanCharacter::*update)();
-        void (HumanCharacter::*exit)();
-    };
-
-    static const HumanCharacterStateTableEntry state_table[] =
-    {
-        // HS_INIT
-        {
-            nullptr,
-            &HumanCharacter::StateInitUpdate,
-            nullptr,
-        },
-
-        // HS_ON_FOOT
-        {
-            &HumanCharacter::StateOnFootEnter,
-            &HumanCharacter::StateOnFootUpdate,
-            nullptr,
-        },
-
-        // HS_RIDING
-        {
-            &HumanCharacter::StateRidingEnter,
-            &HumanCharacter::StateRidingUpdate,
-            &HumanCharacter::StateRidingExit,
-        },
-
-        // HS_KNOCKED_DOWN
-        {
-            nullptr,
-            &HumanCharacter::StateKnockedDownUpdate,
-            nullptr,
-        },
-    };
-
-	while (true)
-	{
-		auto new_state = (this->*state_table[state_].update)();
-
-        if (new_state == state_)
-            break;
-
-        if (auto exit_fun = state_table[state_].exit)
-            (this->*exit_fun)();
-
-        state_ = new_state;
-
-        if (auto enter_fun = state_table[state_].enter)
-            (this->*enter_fun)();
-	}
-
-    signals_ = 0;
-}
-
-void game::HumanCharacter::SetSignal(HumanCharacterStateSignal signal)
-{
-    signals_ |= signal;
-}
-
-bool game::HumanCharacter::PopSignal(HumanCharacterStateSignal signal)
-{
-    if (signals_ & signal)
-    {
-        signals_ &= ~signal;
-        return true;
-    }
-
-    return false;
-}
-
-game::HumanCharacterState game::HumanCharacter::StateInitUpdate()
-{
-    if (GetRideable())
-        return HS_RIDING;
-
-    return HS_ON_FOOT;
-}
-
-void game::HumanCharacter::StateOnFootEnter()
-{
-    SetIdleAnim("idle");
-    SetWalkAnim("walk");
-    SetMovementType(CMT_TURN);
-    EnablePhysics(true);
-
-    ResetActionState();
-}
-
-game::HumanCharacterState game::HumanCharacter::StateOnFootUpdate()
-{
-    if (PopSignal(HSS_RIDEABLE_CHANGED))
-        return HS_INIT;
-
-    if (PopSignal(HSS_KNOCK_DOWN))
-        return HS_KNOCKED_DOWN;
-
-    SetMovementType(IsAlive() ? (aimheld_ ? CMT_DIRECTIONAL : CMT_TURN) : CMT_DISABLED);
-
-    return HS_ON_FOOT;
-}
-
-void game::HumanCharacter::StateRidingEnter()
-{
-    auto rideable = GetRideable();
-    SetPosition(rideable->GetSeatOffset(seat_idx_));
-    EnablePhysics(false);
-
-    Attach(rideable->GetEntity().GetEntNum());
-    SetIdleAnim((rideable->GetRideableType() == RIDEABLE_VEHICLE && seat_idx_ == 0) ? "vehicle_drive" : "vehicle_passenger");
-    SetYaw(0.0f);
-    SetMovementType(CMT_DISABLED);
-
-    ResetActionState();
-}
-
-game::HumanCharacterState game::HumanCharacter::StateRidingUpdate()
-{
-    if (!GetRideable())
-        return HS_INIT;
-
-    if (PopSignal(HSS_RIDEABLE_CHANGED))
-        return HS_INIT;
-
-    return HS_RIDING;
-}
-
-void game::HumanCharacter::StateRidingExit()
-{
-    EnablePhysics(true);
-    SetPosition(rideable_exit_pos_);
-    Attach(0);
-}
-
-game::HumanCharacterState game::HumanCharacter::StateKnockedDownUpdate()
-{
-    return HS_INIT;
-}
-
-void game::HumanCharacter::ResetActionState()
-{
-    item_.reset();
-    EnterActionState(ACTION_IDLE);
-    UpdateItemStuff();
-}
-
-void game::HumanCharacter::UpdateActionState()
-{
-    while (true)
-    {
-        auto new_state = CheckActionStateTransition();
-
-        if (new_state == actionstate_)
-            break;
-
-        EnterActionState(new_state);
-    }
-}
-
-void game::HumanCharacter::EnterActionState(ActionState state)
-{
-    actionstate_ = state;
-    actionstate_start_ = GetWorld().GetTime();
-
-    switch (state)
-    {
-    case ACTION_IDLE:
-        SetAiming(false);
-        SetCanSprint(true);
-        PlayItemActionAnim(&assets::Item::idle_anim);
-        break;
-
-    case ACTION_RAISE:
-        SwitchItem();
-        SetAiming(false);
-        SetCanSprint(true);
-        PlayItemActionAnim(&assets::Item::raise_anim, 3.0f);
-        break;
-
-    case ACTION_AIM:
-        SetAiming(true);
-        SetCanSprint(false);
-        PlayItemActionAnim(&assets::Item::aim_anim, 3.0f);
-        break;
-
-    case ACTION_AIMING:
-        SetAiming(true);
-        SetCanSprint(false);
-        PlayItemActionAnim(&assets::Item::aiming_anim);
-        break;
-
-    case ACTION_FIRE:
-        SetAiming(true);
-        SetCanSprint(false);
-        PlayItemActionAnim(&assets::Item::use_anim);
-        Fire();
-        break;
-
-    case ACTION_FIRE_REPEAT:
-        PlayItemActionAnim(&assets::Item::use_anim, -5.0f);
-        break;
-
-    case ACTION_RELOAD:
-        // SetAiming(true);
-        // SetCanSprint(true);
-        PlayItemActionAnim(&assets::Item::reload_anim);
-        break;
-
-    case ACTION_UNAIM:
-        SetAiming(false);
-        SetCanSprint(false);
-        PlayItemActionAnim(&assets::Item::aim_anim, -3.0f);
-        break;
-
-    case ACTION_PUTAWAY:
-        SetAiming(false);
-        SetCanSprint(true);
-        PlayItemActionAnim(&assets::Item::raise_anim, -3.0f);
-        break;
-    
-    case ACTION_DIE:
-        SetAiming(false);
-        SetCanSprint(false);
-        PlayDeathAnim();
-        break;
-
-    case ACTION_DEAD:
-        EnablePhysics(false);
-        ClearItem();
-        TrySpawnLoot();
-        break;
-
-    default:
-        break;
-    }
-}
-
-int64_t game::HumanCharacter::GetActionStateTime() const
-{
-    return GetWorld().GetTime() - actionstate_start_;
-}
-
-game::ActionState game::HumanCharacter::CheckActionStateTransition()
-{
-    switch (actionstate_)
-    {
-    case ACTION_IDLE:
-        if (!IsAlive())
-            return ACTION_DIE;
-
-        if (PendingItemSwitch())
-            return ACTION_PUTAWAY;
-
-        if (NeedReload())
-            return ACTION_RELOAD;
-
-        if (aimheld_ && CanAim()) // want aim
-            return ACTION_AIM;
-
-        return ACTION_IDLE;
-
-    case ACTION_RAISE:
-        if (!IsAlive())
-            return ACTION_DIE;
-
-        if (PendingItemSwitch())
-            return ACTION_PUTAWAY;
-
-        if (IsActionAnimDone())
-            return ACTION_IDLE;
-
-        return ACTION_RAISE;
-
-    case ACTION_AIM:
-        if (!IsAlive())
-            return ACTION_DIE;
-
-        if (!aimheld_ || !CanAim())
-            return ACTION_UNAIM;
-
-        if (IsActionAnimDone())
-            return ACTION_AIMING;
-
-        return ACTION_AIM;
-
-    case ACTION_AIMING:
-        if (!IsAlive())
-            return ACTION_DIE;
-
-        if (!aimheld_ || !CanAim())
-            return ACTION_UNAIM;
-
-        if (fireheld_ && CanFire())
-            return ACTION_FIRE;
-
-        return ACTION_AIMING;
-
-    case ACTION_FIRE:
-        if (!IsAlive())
-            return ACTION_DIE;
-
-        if (IsActionAnimDone())
-            return ACTION_AIMING;
-
-        if (CanAim() && fireheld_ && CanFire())
-            return ACTION_FIRE_REPEAT;
-
-        return ACTION_FIRE;
-
-    case ACTION_FIRE_REPEAT:
-        // proxy to enter fire state again and reset anims and stuff
-        if (GetActionStateTime() > 0)
-            return ACTION_FIRE;
-
-        return ACTION_FIRE_REPEAT; 
-
-    case ACTION_RELOAD:
-        if (!IsAlive())
-            return ACTION_DIE;
-
-        // SetAiming(aimheld_); // optional here
-        if (IsActionAnimDone())
-        {
-            Reload();
-            return ACTION_IDLE;
-        }
-
-        return ACTION_RELOAD;
-
-    case ACTION_UNAIM:
-        if (!IsAlive())
-            return ACTION_DIE;
-
-        if (aimheld_ && CanAim()) // start aiming again
-            return ACTION_AIM;
-        
-        if (IsActionAnimDone())
-            return ACTION_IDLE;
-
-        return ACTION_UNAIM;
-
-    case ACTION_PUTAWAY:
-        if (!IsAlive())
-            return ACTION_DIE;
-
-        if (IsActionAnimDone())
-            return ACTION_RAISE;
-
-        if (!PendingItemSwitch()) // possibly player wants that item again
-            return ACTION_RAISE;
-
-        return ACTION_PUTAWAY;
-
-    case ACTION_DIE:
-        if (IsActionAnimDone())
-            return ACTION_DEAD;
-        
-        return ACTION_DIE;
-    
-    case ACTION_DEAD: 
-        return ACTION_DEAD; // no way back :(
-
-    default:
-        return actionstate_;
-    }
-}
-
-void game::HumanCharacter::UpdateDispersion()
-{
-    if (!item_)
-    {
-        dispersion_ = 0.0f;
-        return;
-    }
-
-    dispersion_ = glm::clamp(dispersion_ - (item_->def->dispersion_decay / 25.0f), item_->def->dispersion_min,
-                             item_->def->dispersion_max);
-}

src/game/human_character.hpp

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "character.hpp"
-#include "item_instance.hpp"
 
 namespace game
 {
@@ -14,37 +13,6 @@ struct HumanCharacterTuning
 class Rideable;
 class DrivableVehicle;
 
-using HumanCharacterStateSignals = uint32_t;
-
-enum HumanCharacterStateSignal : HumanCharacterStateSignals
-{
-    HSS_KNOCK_DOWN = 1,
-    HSS_RIDEABLE_CHANGED = 2,
-};
-
-enum HumanCharacterState
-{
-    HS_INIT,
-    HS_ON_FOOT,
-    HS_RIDING,
-    HS_KNOCKED_DOWN,
-};
-
-enum ActionState
-{
-    ACTION_IDLE,
-    ACTION_RAISE,
-    ACTION_AIM,
-    ACTION_AIMING,
-    ACTION_FIRE,
-    ACTION_FIRE_REPEAT,
-    ACTION_RELOAD,
-    ACTION_UNAIM,
-    ACTION_PUTAWAY,
-    ACTION_DIE,
-    ACTION_DEAD,
-};
-
 class HumanCharacter : public Character
 {
 public:
@@ -52,9 +20,6 @@ public:
     
     HumanCharacter(World& world, const HumanCharacterTuning& tuning);
     
-    virtual void Update() override;
-    virtual void ReceiveDamage(const DamageInfo& damage) override;
-
     const HumanCharacterTuning& GetHumanTuning() const { return human_tuning_; }
 
     void SetRideable(Rideable* rideable, size_t seat_idx); // called by Rideable!!
@@ -66,75 +31,10 @@ public:
     size_t GeatSeatIdx() const { return seat_idx_; }
     bool IsDriver() const { return is_driver_; }
     
-    void SetAimHeld(bool aimheld) { aimheld_ = aimheld; }
-    void SetFireHeld(bool fireheld) { fireheld_ = fireheld; }
-    void SetReloadHeld(bool reloadheld) { reloadheld_ = reloadheld; }
-
-    void Equip(std::shared_ptr<ItemInstance> item);
-    const std::shared_ptr<ItemInstance>& GetHeldItem() const { return item_; }
-
-    virtual void OnRideableDamaged(const DamageInfo& damage) {}
-
-    virtual void OnDamageDealt(bool was_kill) {}
-
-    bool IsDead() const;
-
     virtual ~HumanCharacter() override;
 
 protected:
     virtual void OnRideableChanged() {}
-    virtual void OnAimingChanged() {}
-    virtual void OnHeldItemChanged() {}
-    virtual bool HaveAmmo(const std::string& ammo_name);
-    virtual size_t GetAmmo(size_t required, const std::string& ammo_name);
-    virtual void SpawnLoot() {}
-
-    bool IsOnFoot() const;
-
-protected:
-    int64_t GetTime() const;
-    bool CanAim();
-    void SetAiming(bool aiming);
-    bool CanFire();
-    void Fire();
-    bool NeedReload();
-    bool CanReload();
-    void Reload();
-    bool PendingItemSwitch();
-    void SwitchItem();
-    void UpdateItemStuff();
-    void ClearItem();
-    void PlayItemActionAnim(const std::string assets::Item::*anim, float speed = 1.0f);
-    void PlayDeathAnim();
-    void TrySpawnLoot();
-
-    void UpdateState();
-    void SetSignal(HumanCharacterStateSignal signal);
-    bool PopSignal(HumanCharacterStateSignal signal);
-
-    //void StateInitEnter();
-    HumanCharacterState StateInitUpdate();
-    //void StateInitExit(); 
-
-    void StateOnFootEnter();
-    HumanCharacterState StateOnFootUpdate();
-    //void StateOnFootExit();
-
-    void StateRidingEnter();
-    HumanCharacterState StateRidingUpdate();
-    void StateRidingExit();
-
-    // void StateKnockedDownEnter();
-    HumanCharacterState StateKnockedDownUpdate();
-    // void StateKnockedDownExit();
-
-    void ResetActionState();
-    void UpdateActionState();
-    void EnterActionState(ActionState state);
-    int64_t GetActionStateTime() const;
-    ActionState CheckActionStateTransition();
-
-    void UpdateDispersion();
 
 private:
     HumanCharacterTuning human_tuning_;
@@ -143,26 +43,6 @@ private:
     DrivableVehicle* vehicle_ = nullptr;
     size_t seat_idx_ = 0;
     bool is_driver_ = false;
-
-    HumanCharacterState state_ = HS_INIT;
-    HumanCharacterStateSignals signals_ = 0;
-
-    glm::vec3 rideable_exit_pos_ = glm::vec3(0.0f);
-
-    bool aimheld_ = false;
-    bool fireheld_ = false;
-    bool reloadheld_ = false;
-
-    ActionState actionstate_ = ACTION_IDLE;
-    int64_t actionstate_start_ = 0;
-
-    std::shared_ptr<ItemInstance> item_;
-    std::shared_ptr<ItemInstance> pending_item_;
-    
-    int64_t last_fire_time_ = 0;
-    float dispersion_ = 0.0f;
-
-    bool loot_spawned_ = false;
 };
 }
 

src/game/inventory.hpp

@@ -1,16 +0,0 @@
-#pragma once
-
-#include "item_instance.hpp"
-
-namespace game
-{
-
-struct Inventory
-{
-    std::shared_ptr<ItemInstance> slots[10];
-    size_t active_slot = 0;
-
-    std::map<std::string, size_t> ammo;
-};
-
-}

src/game/item_instance.cpp

@@ -1,12 +0,0 @@
-#include "item_instance.hpp"
-#include "assets/cache.hpp"
-
-game::ItemInstance::ItemInstance(std::shared_ptr<const assets::Item> def) : def(std::move(def))
-{
-    ammo = this->def->clip_size; // full clip by default
-}
-
-game::ItemInstance::ItemInstance(const std::string& name)
-    : ItemInstance(assets::CacheManager::GetItem("data/" + name + ".item"))
-{
-}

src/game/item_instance.hpp

@@ -1,17 +0,0 @@
-#pragma once
-
-#include "assets/item.hpp"
-
-namespace game
-{
-
-struct ItemInstance
-{
-    std::shared_ptr<const assets::Item> def;
-    size_t ammo = 0;
-    
-    ItemInstance(std::shared_ptr<const assets::Item> def);
-    ItemInstance(const std::string& name);
-};
-
-}

src/game/mapinstance.cpp

@@ -76,19 +76,11 @@ game::MapObjectCollision::MapObjectCollision(collision::DynamicsWorld& world,
         model_->GetParamFloat("destr_th", destr_th_);
     }
 
-    int col_mask = ~collision::OG_STATIC; 
-
     // prefer simple cshape which allow destruction
     if (cshape)
     {
         body_ = std::make_unique<btRigidBody>(
             btRigidBody::btRigidBodyConstructionInfo(mass, nullptr, cshape, local_inertia));
-
-        if (!model_->IsColShapeBulletTarget())
-        {
-            col_mask &= ~collision::OG_PROJECTILE;
-            no_projectile_collision_ = true;
-        }
     }
     else if (cmesh)
     {
@@ -104,7 +96,7 @@ game::MapObjectCollision::MapObjectCollision(collision::DynamicsWorld& world,
     collision::SetObjectInfo(body_.get(), collision::OT_MAP_OBJECT, oflags, this);
 
     // world_.GetBtWorld().addRigidBody(body_.get(), btBroadphaseProxy::StaticFilter, btBroadphaseProxy::AllFilter);
-    world_.GetBtWorld().addRigidBody(body_.get(), collision::OG_STATIC, col_mask);
+    world_.GetBtWorld().addRigidBody(body_.get());
 }
 
 void game::MapObjectCollision::Break()
@@ -129,12 +121,8 @@ void game::MapObjectCollision::Break()
     body_->setWorldTransform(trans);
     
     collision::SetObjectInfo(body_.get(), collision::OT_UNDEFINED, 0, this);
-    
-    int col_mask = collision::OG_ALL;
-    if (no_projectile_collision_)
-        col_mask &= ~collision::OG_PROJECTILE;
 
-    world_.GetBtWorld().addRigidBody(body_.get(), collision::OG_DEFAULT, col_mask);
+    world_.GetBtWorld().addRigidBody(body_.get());
 }
 
 void game::MapObjectCollision::GetModelTransform(Transform& trans) const

src/game/mapinstance.hpp

@@ -31,8 +31,6 @@ public:
     net::ObjNum GetNum() const { return num_; }
     float GetDestroyThreshold() const { return destr_th_; }
 
-    bool no_projectile_collision_ = false;
-    
     virtual ~MapObjectCollision() override;
 
 private:

src/game/marker.cpp

@@ -9,18 +9,18 @@ game::Marker::Marker(World& world, const MarkerInfo& info) : Super(world, net::E
 {
     root_.local.position = info_.position;
     root_.UpdateMatrix();
-
-    max_distance_ = 150.0f;
 }
 
 void game::Marker::SendInitData(Player& player, net::OutMessage& msg) const
 {
     Super::SendInitData(player, msg);
 
+    net::PositionQ pos_q;
+    net::EncodePosition(info_.position, pos_q);
+
     msg.Write(info_.type);
-    net::WritePosition(msg, info_.position);
+    net::WritePositionQ(msg, pos_q);
     net::WriteRGB(msg, info_.color);
-    msg.Write(net::ModelName(info_.model));
 }
 
 void game::Marker::Update()
@@ -31,9 +31,6 @@ void game::Marker::Update()
 
 bool game::Marker::QueryUseTarget(PlayerCharacter& character, uint32_t target_id, UseTargetQueryResult& res)
 {
-    if (!useable_)
-        return false;
-
     if (!query_cb_)
         return false;
 

src/game/marker.hpp

@@ -25,7 +25,6 @@ public:
     virtual void Use(PlayerCharacter& character, uint32_t target_id) override;
 
     void SetUseTarget(const std::string& name, MarkerQueryCallback query, MarkerUseCallback use);
-    void SetUseable(bool useable) { useable_ = useable; }
 
     virtual ~Marker() override;
 
@@ -36,8 +35,6 @@ private:
 
     MarkerQueryCallback query_cb_;
     MarkerUseCallback use_cb_;
-
-    bool useable_ = true;
 };
 
 

src/game/marker_info.hpp

@@ -11,7 +11,6 @@ enum MarkerType : uint8_t
 {
     MARKER_FOOT,
     MARKER_VEHICLE,
-    MARKER_PICKUP,
 };
 
 struct MarkerInfo
@@ -19,7 +18,7 @@ struct MarkerInfo
     glm::vec3 position;
     MarkerType type;
     uint32_t color;
-    std::string model;
+    std::string icon;
 };
 
 }

src/game/npc_character.cpp

@@ -1,275 +1,78 @@
 #include "npc_character.hpp"
 #include "openworld.hpp"
 #include "drivable_vehicle.hpp"
-#include "utils/random.hpp"
-#include "player_character.hpp"
 
 #include <array>
 #include <iostream>
 
-static constexpr size_t PATH_NEXT_WAYPOINTS = 16;
+game::NpcCharacter::NpcCharacter(World& world, const HumanCharacterTuning& tuning) : Super(world, tuning) {
-
+    UpdateVehicleState();
-game::NpcCharacter::NpcCharacter(World& world, const HumanCharacterTuning& tuning) : Super(world, tuning)
-{
-    roads_ = world_.GetMap().GetGraph("roads");
-
-    EnterThinkState(THINKSTATE_IDLE);
-    EnterDriverThinkState(DRIVERSTATE_NONE);
 }
 
 void game::NpcCharacter::Update()
 {
-    UpdateEnemy();
-    Think();
-    DriverThink();
     Super::Update();
-}
 
-void game::NpcCharacter::ReceiveDamage(const DamageInfo& damage)
+    if (GetVehicle() && IsDriver())
-{
+        VehicleThink();
-    Super::ReceiveDamage(damage);
-
-    if (IsAlive() && damage.inflictor)
-    {
-        MakeEnemy(damage.inflictor->GetEntNum());
-    }
-}
-
-void game::NpcCharacter::SetWeapon(std::shared_ptr<ItemInstance> weapon)
-{
-    weapon_ = std::move(weapon);
-}
-
-bool game::NpcCharacter::IsBored(int64_t time) const
-{
-    return (think_state_ == THINKSTATE_IDLE && GetCurrentThinkStateDuration() > time &&
-            driver_state_ == DRIVERSTATE_NONE && GetCurrentDriverThinkStateDuration() > time && !GetRideable());
-}
-
-void game::NpcCharacter::Die()
-{
-    DamageInfo damage{};
-    damage.type = DAMAGE_OTHER;
-    damage.damage = 100000.0f;
-    ReceiveDamage(damage);
 }
 
 void game::NpcCharacter::OnRideableChanged()
 {
-    EnterThinkState(THINKSTATE_IDLE);
+    UpdateVehicleState();
 }
 
-void game::NpcCharacter::OnRideableDamaged(const DamageInfo& damage)
+void game::NpcCharacter::UpdateVehicleState()
-{
-    if (damage.inflictor)
-    {
-        MakeEnemy(damage.inflictor->GetEntNum());
-    }
-}
-
-void game::NpcCharacter::SpawnLoot()
-{
-    if (weapon_)
-    {
-        size_t ammo = weapon_->def->clip_size * 5;
-        GetWorld().CreateItemPickup(root_.GetGlobalPosition(), std::move(weapon_), 60000, 0, ammo);
-    }
-}
-
-void game::NpcCharacter::MakeEnemy(net::EntNum enemy_num)
-{
-    // it must have been a mistake
-    if (Chance(0.1f))
-    {
-        return;
-    }
-
-    // cant switch enemies that fast
-    auto time = GetWorld().GetTime();
-    if (enemy_num != enemy_num_ && time - enemy_time_ < 5000)
-    {
-        return; 
-    }
-
-    // increase anger
-    if (Chance(0.7f))
-    {
-        follow_enemy_ = true;
-    }
-
-    // this mf is already my current enemy
-    if (enemy_num == enemy_num_)
-    {
-        return;
-    }
-
-    // already have another enemy, likely stay focused on him
-    if (enemy_num_ != 0 && Chance(0.7f))
-    {
-        return;
-    }
-
-    // he is npc and i am not his target, was SURELY a missclick
-    auto enemy_npc = dynamic_cast<NpcCharacter*>(GetWorld().GetEntity(enemy_num));
-    if (enemy_npc && enemy_npc->enemy_num_ != GetEntNum() && Chance(0.3f))
-    {
-        return;
-    }
-
-    // OK this one is now my enemy
-    enemy_num_ = enemy_num;
-    enemy_time_ = time;
-    follow_enemy_ = false;
-    UpdateEnemy();
-}
-
-void game::NpcCharacter::UpdateEnemy()
-{
-    if (enemy_num_ == 0)
-    {
-        enemy_ = nullptr;
-        return;
-    }
-
-    enemy_ = dynamic_cast<HumanCharacter*>(GetWorld().GetEntity(enemy_num_));
-
-    if (!enemy_ || CheckEnemyLost())
-    {
-        ClearEnemy();
-        return;
-    }
-
-    if (GetAiming())
-    {
-        SetAimTarget(enemy_->GetRoot().matrix * glm::vec4(0.0f, 0.0f, 1.7f, 1.0f));
-    }
-
-    // in vehicle with me?????
-    if (GetRideable() && enemy_->GetRideable() == GetRideable())
-    {
-        Ride(nullptr, 0);
-    }
-}
-
-bool game::NpcCharacter::CheckEnemyLost()
-{
-    if (!enemy_->IsAlive())
-    {
-        return true; // may he rest in peace
-    }
-
-    const float max_dist = 150.0f;
-    auto dist2 = glm::distance2(root_.GetGlobalPosition(), enemy_->GetRoot().GetGlobalPosition());
-    if (dist2 > (max_dist * max_dist))
-        return true; // lost
-
-    return false;
-}
-
-bool game::NpcCharacter::HasEnemy() const
-{
-    return enemy_;
-}
-
-void game::NpcCharacter::ClearEnemy()
-{
-    enemy_num_ = 0;
-    enemy_ = nullptr;
-    enemy_time_ = 0;
-    follow_enemy_ = false;
-}
-
-bool game::NpcCharacter::WantsToFollowEnemy()
-{
-    return HasEnemy() && follow_enemy_ && IsArmed();
-}
-
-bool game::NpcCharacter::IsArmed() const
-{
-    return weapon_.get() != nullptr;
-}
-
-bool game::NpcCharacter::IsVehicleDriver() const
-{
-    return GetVehicle() && IsDriver() && IsAlive();
-}
-
-void game::NpcCharacter::ResetVehiclePath()
 {
+    roads_ = nullptr;
     path_.clear();
-    last_waypoint_idx_= 0;
+    gas_ = false;
-}
+    stuck_counter_ = 0;
+    vehicle_state_ = NVT_NORMAL;
+    speed_limit_ = 0.0f;
 
-void game::NpcCharacter::FindVehiclePath(const glm::vec3& position)
+    if (GetVehicle() && IsDriver())
-{
-    if (path_.empty())
     {
-        // path_.clear(); // make sure there is not 1 left
+        roads_ = world_.GetMap().GetGraph("roads");
-        // path_.push_back(position); // take current pos as first waypoint
+
+        seg_start_ = GetVehicle()->GetRootTransform().position;
+        
+        size_t start_node = 0;
+        float min_dist = std::numeric_limits<float>().infinity();
 
-        // find closest waypoint as first
-        size_t closest = 0;
-        float closest_dist2 = 10000000000.0f;
         for (size_t i = 0; i < roads_->nodes.size(); ++i)
         {
-            auto d = position - roads_->nodes[i].position;
+            auto& node = roads_->nodes[i];
-            auto dist2 = glm::dot(d, d);
+            float dist = glm::distance(node.position, seg_start_);
-            if (dist2 < closest_dist2)
+            if (dist < min_dist)
             {
-                closest_dist2 = dist2;
+                min_dist = dist;
-                closest = i;
+                start_node = i;
             }
         }
 
-        path_.push_back(roads_->nodes[closest].position);
+        path_.push_back(start_node);
-        last_waypoint_idx_ = closest;
-    }
 
-    while (path_.size() < PATH_NEXT_WAYPOINTS)
-    {
-        const auto& last = roads_->nodes[last_waypoint_idx_];
-        if (last.num_nbs == 0)
-        {
-            throw std::runtime_error("dead end from waypoint: " + last_waypoint_idx_);
-        }
-        
-        size_t random_next_idx = rand() % last.num_nbs;
-        size_t nb_idx = roads_->nbs[last.nbs + random_next_idx];
-        path_.push_back(roads_->nodes[nb_idx].position);
-        last_waypoint_idx_ = nb_idx;
     }
 }
 
-static float FindClosestPointOnSegment(const glm::vec3& p0, const glm::vec3& p1, const glm::vec3& pos)
+void game::NpcCharacter::SelectNextNode()
 {
-    glm::vec3 seg_dir = p1 - p0;
+    size_t node = path_.back();
-    float seg_len2 = glm::dot(seg_dir, seg_dir);
+    size_t num_nbs = roads_->nodes[node].num_nbs;
-    if (seg_len2 < 0.0001f)
-        return 0.0f; // segment is too short
 
-    float t = glm::dot(pos - p0, seg_dir) / seg_len2;
+    if (num_nbs < 1)
-    // t = glm::clamp(t, 0.0f, 1.0f);
-    return t;
-}
-
-static glm::vec3 LookAhead(std::span<glm::vec3> path, float distance)
-{
-    for (size_t i = 0; i < path.size() - 1; ++i)
     {
-        const auto& p0 = path[i];
+        const auto& pos = roads_->nodes[node].position;
-        const auto& p1 = path[i + 1];
+        std::cout << "node " << node << " has no neighbors!!!1 position: " << pos.x << " " << pos.y << " " << pos.z
-        auto seg_dist = glm::distance(p0, p1);
+                    << std::endl;
-        if (distance < seg_dist)
+        throw std::runtime_error("no neighbors");
-        {
-            return glm::mix(p0, p1, distance / seg_dist);
-        }
-
-        distance -= seg_dist;
     }
 
-    return path.back();
+    path_.push_back(roads_->nbs[roads_->nodes[node].nbs + (rand() % num_nbs)]);
 }
 
+
 static float GetTurnAngle2D(const glm::vec2& forward, const glm::vec2& to_target)
 {
     glm::vec2 forward_xy = glm::normalize(forward);
@@ -293,514 +96,191 @@ static float GetTurnAngle(const glm::vec3& pos, const glm::quat& rot, const glm:
     return GetTurnAngle2D(forward_xy, to_target_xy);
 }
 
-float CalculateNPCTargetSpeed(std::span<const glm::vec3> waypoints, const glm::quat& vehicleOrientation)
+void game::NpcCharacter::VehicleThink()
 {
-    // Configuration parameters (Tweak these to match your game's driving feel)
+    if (!roads_)
-    const float MAX_SPEED_KMH = 100.0f;      // Speed on a straight road
+        return;
-    const float MIN_SPEED_KMH = 20.0f;       // Speed in a very sharp turn
-    const float LOOK_AHEAD_DISTANCE = 200.0f; // How far ahead (in meters) the NPC cares about
 
-    // Safety check: We need at least the current position (0) and the next waypoint (1)
-    // to calculate a heading. More waypoints improve the curve estimation.
-    if (waypoints.size() < 2)
-    {
-        return MIN_SPEED_KMH;
-    }
-
-    // Initialize vehicle forward vector from orientation
-    glm::vec3 vehicleForward = vehicleOrientation * glm::vec3(0.0f, 1.0f, 0.0f);
-
-    float accumulatedSharpness = 0.0f;
-    float distanceEvaluated = 0.0f;
-
-    // We start by checking the angle between the vehicle's current heading and the first segment
-    glm::vec3 currentDir = vehicleForward;
-
-    for (size_t i = 0; i < waypoints.size() - 1; ++i)
-    {
-        glm::vec3 segment = waypoints[i + 1] - waypoints[i];
-        float segmentLength = glm::length(segment);
-
-        if (segmentLength < 0.1f)
-            continue; // Skip duplicate waypoints
-
-        // Accumulate distance. Stop looking ahead if it's too far down the road.
-        distanceEvaluated += segmentLength;
-        if (distanceEvaluated > LOOK_AHEAD_DISTANCE)
-            break;
-
-        glm::vec3 nextDir = segment / segmentLength; // Normalized direction
-
-        // Dot product gives the cosine of the angle between segments (range: -1 to 1)
-        // 1.0 means perfectly straight, 0.0 means 90-degree turn, -1.0 is a hairpin U-turn.
-        float dot = glm::dot(currentDir, nextDir);
-
-        // Clamp to avoid float precision issues with acos/sqrt logic
-        dot = glm::clamp(dot, -1.0f, 1.0f);
-
-        // Turn sharpness: 0.0 (straight) to 2.0 (180-degree turn)
-        float sharpness = 1.0f - dot;
-
-        // Distance weighting: turns further away matter less
-        float distanceWeight = 1.0f - (distanceEvaluated / LOOK_AHEAD_DISTANCE);
-        distanceWeight = glm::max(distanceWeight, 0.0f);
-
-        // Accumulate weighted sharpness
-        accumulatedSharpness += sharpness * distanceWeight;
-
-        // Move to the next segment
-        currentDir = nextDir;
-    }
-
-    // Map the sharpness to a speed limit.
-    // If accumulatedSharpness is 0, t = 0 -> MAX_SPEED.
-    // We cap sharpness sensitivity at 1.0 (roughly a sharp 90-degree turn nearby).
-    float t = glm::clamp(accumulatedSharpness, 0.0f, 1.0f);
-
-    // Linear interpolation between max and min speed based on sharpness
-    float targetSpeedKMH = glm::mix(MAX_SPEED_KMH, MIN_SPEED_KMH, t);
-
-    return targetSpeedKMH;
-}
-
-void game::NpcCharacter::UpdateVehicleInput(std::span<glm::vec3> actual_path)
-{
     auto vehicle = GetVehicle();
-    auto vehicle_pos = vehicle->GetRoot().GetGlobalPosition();
-    const auto& vehicle_rot = vehicle->GetRoot().local.rotation;
 
-    auto target_pos = LookAhead(actual_path, glm::max(2.0f, vehicle->GetSpeed() * 0.2f));
+    if (vehicle_state_ == NVT_REVERSING)
-    // auto target_speed = 10.0f;
-    std::span<glm::vec3> speed_path = actual_path;
-    if (glm::distance2(actual_path[0], actual_path[1]) < 4.0f)
     {
-        speed_path = { actual_path.begin() + 1, actual_path.end() };
+        if (reversing_frames_ > 0)
+        {
+            --reversing_frames_;
+        }
+        else
+        {
+            vehicle_state_ = NVT_NORMAL;
+            stuck_counter_ = 0;
+            vehicle->SetInput(game::VIN_BACKWARD, false);
+        }
+        return;
     }
 
-    auto target_speed = CalculateNPCTargetSpeed(speed_path, vehicle_rot);
 
-    if (in_hurry_)
+    const auto& vehicle_trans = vehicle->GetRootTransform();
+
+    const glm::vec3& pos = vehicle_trans.position;
+    const glm::quat& rot = vehicle_trans.rotation;
+    glm::vec3 forward = rot * glm::vec3{0.0f, 1.0f, 0.0f};
+
+    // glm::vec3 target = s->roads.nodes[s->node].position;
+
+    //
+    std::array<glm::vec3, 8> waypoints;
+
+    while (path_.size() < waypoints.size() - 1)
     {
-        target_speed *= 4.0f;
+        SelectNextNode();
     }
 
-    // set steering
+    glm::vec3 node_pos = roads_->nodes[path_.front()].position;
-    vehicle_steer_ = GetTurnAngle(vehicle_pos, vehicle_rot, target_pos);
+    if (glm::distance(glm::vec2(pos), glm::vec2(node_pos)) < 6.0f && path_.size() > 1)
+    {
+        seg_start_ = node_pos;
+        path_.pop_front();
+        SelectNextNode();
+    }
+
+    glm::vec3 target_node_pos = roads_->nodes[path_.front()].position;
+
+    waypoints[0] = pos - glm::normalize(forward) * 3.0f;
+    waypoints[1] = pos;
+
+    // find closest point on segment [seg_start -> target_node_pos]
+    glm::vec3 seg_end = target_node_pos;
+    glm::vec3 seg_dir = seg_end - seg_start_;
+    float seg_len = glm::length(seg_dir);
+    if (seg_len > 5.0f)
+    {
+        glm::vec3 seg_dir_norm = seg_dir / seg_len;
+        float t = glm::clamp(glm::dot(pos - seg_start_, seg_dir_norm) / seg_len, 0.0f, 1.0f);
+        waypoints[2] = seg_start_ + t * seg_dir;
+        if (glm::distance(waypoints[1], target_node_pos) > 10.0f)
+        {
+            waypoints[2] += seg_dir_norm * 10.0f; // look a bit ahead on segment
+        }
+        else
+        {
+            waypoints[2] = target_node_pos;
+        }
+    }
+    else
+    {
+        waypoints[2] = target_node_pos;
+    }
+
+    for (size_t i = 3; i < waypoints.size(); ++i)
+    {
+        size_t path_idx = glm::min(i - 3, path_.size() - 1);
+        waypoints[i] = roads_->nodes[path_[path_idx]].position;
+    }
+
+    // decrease speed based on curvature
+    const float base_speed = 100.0f;
+    float target_speed = base_speed;
+    float dist_accum = 0.0f;
+    for (size_t i = 1; i < waypoints.size() - 1; ++i)
+    {
+        glm::vec3 dir1 = waypoints[i] - waypoints[i - 1];
+        glm::vec3 dir2 = waypoints[i + 1] - waypoints[i];
+        float dist = glm::length(dir1);
+        dist_accum += dist;
+
+        glm::vec2 dir1_xy = glm::vec2{dir1.x, dir1.y};
+        glm::vec2 dir2_xy = glm::vec2{dir2.x, dir2.y};
+
+        const float min_dir_length = 0.001f;
+        float angle = glm::length(dir1_xy) > min_dir_length && glm::length(dir2_xy) > min_dir_length
+                            ? GetTurnAngle2D(dir1_xy, dir2_xy)
+                            : 0.0f;
+        // std::cout << "angle: " << angle << "\n";
+        float abs_angle = fabsf(angle);
+        if (abs_angle > glm::radians(7.0f))
+        {
+            // float speed_limit = 50.0f / abs_angle; // sharper turn -> lower speed
+            // speed_limit *= dist_accum / 20.0f; // more distance to turn -> higher speed
+            // speed_limit = glm::max(speed_limit, 20.0f);
+            // max_speed = glm::min(max_speed, speed_limit);
+            target_speed -=
+                abs_angle * (base_speed / glm::pi<float>() / 2.0f) * 50.0f / glm::max(dist_accum - 1.0f, 1.0f);
+        }
+
+        if (dist_accum > 200.0f)
+            break;
+    }
+
+    target_speed = glm::clamp(target_speed, 25.0f, 100.0f);
+    speed_limit_ = target_speed;
+
+    // std::cout << "target speed: " << target_speed << "\n";
+
+    float angle = GetTurnAngle(pos, rot, waypoints[2]);
+
+    if (glm::distance(pos, last_pos_) < 2.0f)
+    {
+        stuck_counter_++;
+        if (stuck_counter_ > 100)
+        {
+            //s->state_str = "stuck (reverse)";
+            //s->stuck_counter = 0;
+            //s->vehicle.SetSteering(true, -angle); // try turn away
+
+            //s->vehicle.SetInputs(0); // stop
+            //// stuck, go reverse for a while
+            //s->vehicle.SetInput(game::VIN_BACKWARD, true);
+            //s->vehicle.Schedule(2000, [s]() {
+            //    s->vehicle.SetInput(game::VIN_BACKWARD, false);
+            //    BotThink(s);
+            //});
+
+            vehicle->SetSteering(true, -angle); // try turn away while reversing
+            vehicle->SetInputs(0); // stop
+            vehicle->SetInput(game::VIN_BACKWARD, true);
+            vehicle_state_ = NVT_REVERSING;
+            reversing_frames_ = 50; // reverse for 50 frames
+
+            // GetVehicleOld()->SetInputs(0); // stop
+            // is_driver_ = false; // TODO: fix 
+            return;
+        }
+    }
+    else
+    {
+        stuck_counter_ = 0;
+        last_pos_ = pos;
+    }
+
+    vehicle->SetSteering(true, angle);
+
+    game::VehicleInputFlags vin = 0;
 
-    // set input
     float speed = vehicle->GetSpeed();
 
-    if (speed < target_speed * 0.9f && ((vehicle_in_ & (1<<VIN_FORWARD)) == 0))
+    // if (glm::distance(pos, target) < 10.0f)
+    // {
+    //     target_speed = 20.0f;
+    // }
+
+    if (speed < target_speed * 0.9f && !gas_)
     {
-        // gas
+        gas_ = true;
-        vehicle_in_ |= (1<<VIN_FORWARD);
     }
-    else if (speed > target_speed * 1.1f && ((vehicle_in_ & (1<<VIN_FORWARD)) > 0))
+    else if (speed > target_speed * 1.1f && gas_)
     {
-        // no gas
+        gas_ = false;
-        vehicle_in_ &= ~(1<<VIN_FORWARD);
+    }
+
+    if (gas_)
+    {
+        vin |= 1 << game::VIN_FORWARD;
     }
 
     if (speed > target_speed * 1.4f)
     {
-        // brake
+        vin |= 1 << game::VIN_BACKWARD;
-        vehicle_in_ |= (1<<VIN_BACKWARD);
-    }
-    else
-    {
-        // dont brake
-        vehicle_in_ &= ~(1<<VIN_BACKWARD);
     }
 
-
+    vehicle->SetInputs(vin);
-    // debug draw path
-    // float beam_dist = 30.0f;
-    // for (size_t i = 0; i < actual_path.size() - 1; ++i)
-    // {
-    //     const auto& p0 = actual_path[i];
-    //     auto p1 = actual_path[i + 1];
-
-    //     auto dist = glm::distance(p0, p1);
-    //     if (beam_dist < dist)
-    //     {
-    //         p1 = glm::mix(p0, p1, beam_dist / dist);
-    //     }
-
-    //     GetWorld().Beam(p0, p1, i % 2 == 0 ? 0xFF0000FF : 0xFF0077FF, 1.5f / 25.0f);
-    
-    //     beam_dist -= dist;
-    //     if (beam_dist <= 0.0f)
-    //         break;
-    // }
-    // GetWorld().Beam(vehicle_pos, target_pos, 0xFFFF00FF, 1.5f / 25.0f);
-    // GetWorld().BeamBox(target_pos - 0.05f, target_pos + 0.05f, 0xFFFF00FF, 1.5f / 25.0f);
-}
-
-void game::NpcCharacter::UpdateVehicleInputToFollowPath() 
-{
-    auto vehicle = GetVehicle();
-    if (!vehicle)
-        return;
-
-    auto vehicle_pos = vehicle->GetRoot().GetGlobalPosition();
-    
-    FindVehiclePath(vehicle_pos);
-
-    float seg_t;
-
-    // check if we reached next waypoint
-    while (true)
-    {
-        auto seg_dir = path_[1] - path_[0];
-        auto seg_len2 = glm::dot(seg_dir, seg_dir);
-        auto seg_len = glm::sqrt(seg_len2);
-        if (seg_len > 0.1f)
-        {
-            seg_t = glm::dot(vehicle_pos - path_[0], seg_dir) / seg_len2;
-            if (seg_t < (1.0f - 3.0f / seg_len))
-            {
-                break;
-            }
-        }
-
-        path_.pop_front();
-        FindVehiclePath(vehicle_pos);
-        
-    }
-
-    seg_t = glm::clamp(seg_t, 0.0f, 1.0f);
-
-    const auto& p0 = path_[0];
-    const auto& p1 = path_[1];
-    auto on_segment = glm::mix(p0, p1, seg_t);
-
-    std::array<glm::vec3, PATH_NEXT_WAYPOINTS + 1> actual_path; // pos,on_segment,path[1],path[2]...
-    actual_path[0] = vehicle_pos;
-    actual_path[1] = on_segment;
-    for (size_t i = 1; i < PATH_NEXT_WAYPOINTS; ++i)
-    {
-        actual_path[i + 2 - 1] = path_[i];
-    }
-
-    UpdateVehicleInput(actual_path);
-}
-
-void game::NpcCharacter::UpdateVehicleInputToFollowEnemy()
-{
-    if (!enemy_)
-    {
-        vehicle_in_ = 0;
-        vehicle_steer_ = 0.0f;
-        return;   
-    }
-
-    auto vehicle = GetVehicle();
-    if (!vehicle)
-        return;
-
-    std::array<glm::vec3, 2> actual_path;
-    actual_path[0] = vehicle->GetRoot().GetGlobalPosition();;
-    actual_path[1] = enemy_->GetRoot().GetGlobalPosition();;
-
-    UpdateVehicleInput(actual_path);
-}
-
-bool game::NpcCharacter::CheckStuck()
-{
-    auto pos = root_.GetGlobalPosition();
-    auto dist2 = glm::distance2(pos, last_pos_);
-
-    // far, not stuck
-    if (dist2 > 4.0f)
-    {
-        last_pos_ = pos;
-        stuck_counter_ = 0;
-        return false;
-    }
-
-    ++stuck_counter_;
-
-    // close but only short time yet
-    if (stuck_counter_ < 100)
-        return false;
-
-    // stuck
-    last_pos_ = pos;
-    stuck_counter_ = 0;
-    return true;
-}
-
-static game::CharacterInputFlags GetRandomStrafeDir(float strafe_chance)
-{
-    auto dir_choice = RandomFloat(0.0f, 1.0f);
-
-    if (dir_choice > strafe_chance)
-        return 0;
-
-    return (dir_choice < strafe_chance * 0.5f) ? (1 << game::CIN_RIGHT) : (1 << game::CIN_LEFT);
-}
-
-void game::NpcCharacter::Think()
-{
-    while (true)
-    {
-        auto new_state = CheckThinkStateTransition();
-        if (new_state == think_state_)
-            break;
-
-        EnterThinkState(new_state);
-    }
-}
-
-void game::NpcCharacter::EnterThinkState(ThinkState state)
-{
-    think_state_ = state;
-    think_state_time_ = GetWorld().GetTime();
-
-    switch (state)
-    {
-    case THINKSTATE_IDLE:
-        SetAimHeld(false);
-        SetFireHeld(false);
-        Equip(nullptr);
-        SetInputs(0);
-        in_hurry_ = false;
-        break;
-
-    case THINKSTATE_MAD_IDLE:
-        SetAimHeld(false);
-        SetFireHeld(false);
-        Equip(weapon_);
-        SetInputs(0);
-        SetTargetThinkStateDuration(100, 300);
-        break;
-
-    case THINKSTATE_MAD_AIM:
-        SetAimHeld(true);
-        SetFireHeld(false);
-        Equip(weapon_);
-        SetInputs(GetRandomStrafeDir(0.8f));
-        SetTargetThinkStateDuration(200, 800);
-        break;
-
-    case THINKSTATE_MAD_FIRE:
-        SetAimHeld(true);
-        SetFireHeld(true);
-        Equip(weapon_);
-        SetInputs(GetRandomStrafeDir(0.4f));
-        SetTargetThinkStateDuration(200, 1200);
-        break;
-
-    case THINKSTATE_SCARED:
-        SetAimHeld(false);
-        SetFireHeld(false);
-        Equip(nullptr);
-        SetInputs(0);
-        in_hurry_ = true;
-        SetTargetThinkStateDuration(5000, 10000);
-        break;
-
-    case THINKSTATE_BRAINDEAD:
-        SetAimHeld(true);
-        SetFireHeld(true);
-        SetInputs(0);
-        in_hurry_ = false;
-        break;
-    }
-
-}
-
-game::ThinkState game::NpcCharacter::CheckThinkStateTransition()
-{
-    if (!IsAlive())
-        return THINKSTATE_BRAINDEAD;
-
-    switch (think_state_)
-    {
-    case THINKSTATE_IDLE:
-        if (HasEnemy())
-            return IsArmed() ? THINKSTATE_MAD_IDLE : THINKSTATE_SCARED;
-
-        return THINKSTATE_IDLE;
-
-    case THINKSTATE_MAD_IDLE:
-        if (!HasEnemy() || !IsArmed())
-            return THINKSTATE_IDLE;
-
-        if (HasThinkStateDurationElapsed() && CanAim())
-            return THINKSTATE_MAD_AIM;
-
-        return THINKSTATE_MAD_IDLE;
-
-    case THINKSTATE_MAD_AIM:
-        if (!HasEnemy() || !IsArmed())
-            return THINKSTATE_IDLE;
-
-        if (GetCurrentThinkStateDuration() > 0 && !GetAiming()) // reload or sth
-            return THINKSTATE_MAD_IDLE;
-
-        if (HasThinkStateDurationElapsed())
-            return THINKSTATE_MAD_FIRE;
-
-        return THINKSTATE_MAD_AIM;
-
-    case THINKSTATE_MAD_FIRE:
-        if (HasThinkStateDurationElapsed())
-            return THINKSTATE_MAD_AIM;
-
-        return THINKSTATE_MAD_FIRE;
-    
-    case THINKSTATE_SCARED:
-        if (HasThinkStateDurationElapsed())
-            return THINKSTATE_IDLE;
-
-        return THINKSTATE_SCARED;
-
-    default:
-        return THINKSTATE_IDLE;
-    }
-}
-
-int64_t game::NpcCharacter::GetCurrentThinkStateDuration() const
-{
-    return GetWorld().GetTime() - think_state_time_;
-}
-
-void game::NpcCharacter::SetTargetThinkStateDuration(int duration_min, int duration_max)
-{
-    if (duration_max == 0)
-    {
-        think_state_target_duration_ = duration_min;
-    }
-    else
-    {
-        think_state_target_duration_ = RandomInt(duration_min, duration_max);
-    }
-}
-
-bool game::NpcCharacter::HasThinkStateDurationElapsed() const
-{
-    return GetCurrentThinkStateDuration() >= think_state_target_duration_;
-}
-
-void game::NpcCharacter::DriverThink()
-{
-    while (true)
-    {
-        auto new_state = CheckDriverThinkStateTransition();
-        if (new_state == driver_state_)
-            break;
-
-        EnterDriverThinkState(new_state);
-    }
-
-    auto vehicle = GetVehicle();
-    if (vehicle && IsDriver())
-    {
-        vehicle->SetSteering(true, vehicle_steer_);
-        vehicle->SetInputs(vehicle_in_);
-    }
-}
-
-void game::NpcCharacter::EnterDriverThinkState(DriverThinkState state)
-{
-    prev_driver_state_ = driver_state_;
-    driver_state_ = state;
-    driver_state_time_ = GetWorld().GetTime();
-
-    stuck_counter_ = 0;
-
-    switch (state)
-    {
-    case DRIVERSTATE_NONE:
-        vehicle_in_ = 0;
-        vehicle_steer_ = 0.0f;
-        break;
-
-    case DRIVERSTATE_PATH_BEGIN:
-        vehicle_in_ = 0;
-        vehicle_steer_ = 0.0f;
-        ResetVehiclePath();
-        break;
-
-    case DRIVERSTATE_PATH:
-        break;
-
-    case DRIVERSTATE_REVERSE:
-        vehicle_in_ = 1<<VIN_BACKWARD; // go reverse
-        vehicle_steer_ = -vehicle_steer_; // try turn away
-        break;
-
-    case DRIVERSTATE_FOLLOW_ENEMY:
-        break;
-
-    default:
-        break;
-    }
-}
-
-game::DriverThinkState game::NpcCharacter::CheckDriverThinkStateTransition()
-{
-    switch (driver_state_)
-    {
-    case DRIVERSTATE_NONE:
-        if (IsVehicleDriver() && GetCurrentDriverThinkStateDuration() > 1000) // take some time to think
-        {
-            if (WantsToFollowEnemy())
-                return DRIVERSTATE_FOLLOW_ENEMY;
-
-            return DRIVERSTATE_PATH_BEGIN;
-        }
-
-        return DRIVERSTATE_NONE;
-
-    case DRIVERSTATE_PATH_BEGIN:
-        return DRIVERSTATE_PATH;
-    
-    case DRIVERSTATE_PATH:
-        if (!IsVehicleDriver())
-            return DRIVERSTATE_NONE;
-
-        if (WantsToFollowEnemy())
-            return DRIVERSTATE_NONE;
-
-        if (CheckStuck())
-            return DRIVERSTATE_REVERSE;
-
-        // update input
-        UpdateVehicleInputToFollowPath();
-
-        return DRIVERSTATE_PATH;
-
-    case DRIVERSTATE_FOLLOW_ENEMY:
-        if (!IsVehicleDriver())
-            return DRIVERSTATE_NONE;
-
-        if (!WantsToFollowEnemy())
-            return DRIVERSTATE_NONE;
-
-        if (CheckStuck())
-            return DRIVERSTATE_REVERSE;
-
-        UpdateVehicleInputToFollowEnemy();
-
-        return DRIVERSTATE_FOLLOW_ENEMY;
-
-    case DRIVERSTATE_REVERSE:
-        if (!IsVehicleDriver())
-            return DRIVERSTATE_NONE;
-
-        if (GetCurrentDriverThinkStateDuration() > 3000)
-            return prev_driver_state_;
-    
-        return DRIVERSTATE_REVERSE;
-
-    default:
-        return DRIVERSTATE_NONE;
-    }
-}
-
-int64_t game::NpcCharacter::GetCurrentDriverThinkStateDuration() const
-{
-    return GetWorld().GetTime() - driver_state_time_;
 }

src/game/npc_character.hpp

@@ -2,30 +2,16 @@
 
 #include "assets/map.hpp"
 #include "human_character.hpp"
-#include "vehicle.hpp"
 
 namespace game
 {
 
 class OpenWorld;
 
-enum ThinkState
+enum NpcVehicleThinkState
 {
-    THINKSTATE_IDLE,
+    NVT_NORMAL,
-    THINKSTATE_MAD_IDLE,
+    NVT_REVERSING,
-    THINKSTATE_MAD_AIM,
-    THINKSTATE_MAD_FIRE,
-    THINKSTATE_SCARED,
-    THINKSTATE_BRAINDEAD,
-};
-
-enum DriverThinkState
-{
-    DRIVERSTATE_NONE,
-    DRIVERSTATE_PATH_BEGIN,
-    DRIVERSTATE_PATH,
-    DRIVERSTATE_REVERSE,
-    DRIVERSTATE_FOLLOW_ENEMY,
 };
 
 class NpcCharacter : public HumanCharacter
@@ -37,84 +23,26 @@ public:
 
     virtual void Update() override;
 
-    virtual void ReceiveDamage(const DamageInfo& damage) override;
-
-    void SetWeapon(std::shared_ptr<ItemInstance> weapon);
-
-    bool IsBored(int64_t time) const;
-    void Die();
-
-    // net::EntNum GetEnemyNum() const { return enemy_num_; }
-
 protected:
     virtual void OnRideableChanged() override;
-    virtual void OnRideableDamaged(const DamageInfo& damage) override;
-    virtual void SpawnLoot() override;
 
 private:
-    void MakeEnemy(net::EntNum enemy_num);
+    void UpdateVehicleState();
-    void UpdateEnemy();
+    void SelectNextNode();
-    bool CheckEnemyLost();
+    void VehicleThink();
-    bool HasEnemy() const;
-    void ClearEnemy();
-    bool WantsToFollowEnemy();
-
-    bool IsArmed() const;
-
-    bool IsVehicleDriver() const;
-    void ResetVehiclePath();
-    void FindVehiclePath(const glm::vec3& position);
-    void UpdateVehicleInput(std::span<glm::vec3> path);
-    void UpdateVehicleInputToFollowPath();
-    void UpdateVehicleInputToFollowEnemy();
-    bool CheckStuck();
-
-    void Think();
-    void EnterThinkState(ThinkState state);
-    ThinkState CheckThinkStateTransition();
-    int64_t GetCurrentThinkStateDuration() const;
-    void SetTargetThinkStateDuration(int duration_min, int duration_max = 0);
-    bool HasThinkStateDurationElapsed() const;
-
-    void DriverThink();
-    void EnterDriverThinkState(DriverThinkState state);
-    DriverThinkState CheckDriverThinkStateTransition();
-    int64_t GetCurrentDriverThinkStateDuration() const;
-
-    // void UpdateVehicleState();
-    // void SelectNextNode();
-    // void VehicleThink();
 
 private:
-    const assets::MapGraph* roads_;
-
-    ThinkState think_state_ = THINKSTATE_IDLE;
-    int64_t think_state_time_ = 0;
-    int64_t think_state_target_duration_ = 0;
 
     // driver
-    DriverThinkState driver_state_ = DRIVERSTATE_NONE;
+    NpcVehicleThinkState vehicle_state_ = NVT_NORMAL;
-    int64_t driver_state_time_ = 0;
+    const assets::MapGraph* roads_;
-    DriverThinkState prev_driver_state_ = DRIVERSTATE_NONE;
+    glm::vec3 seg_start_;
-    
+    std::deque<size_t> path_;
-    std::deque<glm::vec3> path_;
+    bool gas_ = false;
-    size_t last_waypoint_idx_ = 0;
-    glm::vec3 last_pos_ = glm::vec3(0.0f);
     size_t stuck_counter_ = 0;
-    
+    size_t reversing_frames_ = 0;
-    VehicleInputFlags vehicle_in_ = 0;
+    glm::vec3 last_pos_ = glm::vec3(0.0f);
-    float vehicle_steer_ = 0.0f;
+    float speed_limit_ = 0.0f;
-
-    bool in_hurry_ = false;
-
-    // mad
-    std::shared_ptr<ItemInstance> weapon_;
-
-    net::EntNum enemy_num_ = 0;
-    HumanCharacter* enemy_ = nullptr;
-    int64_t enemy_time_ = 0;
-
-    bool follow_enemy_ = false;
 };
 
 }

src/game/openworld.cpp

@@ -2,7 +2,6 @@
 
 #include <iostream>
 
-#include "assets/cache.hpp"
 #include "player.hpp"
 #include "vehicle.hpp"
 #include "player_character.hpp"
@@ -13,16 +12,16 @@
 #include "tuning_world.hpp"
 #include "game.hpp"
 #include "cow.hpp"
-#include "utils/random.hpp"
 
 namespace game
 {
 
 } // namespace game
 
+
 static const char* GetRandomCarModel()
 {
-    const char* vehicles[] = {"pickup_hd", "passat", "twingo", "polskifiat", "avia"};
+    const char* vehicles[] = {"pickup_hd", "passat", "twingo", "polskifiat", "cow_static", "pig_static", "avia"};
     return vehicles[rand() % (sizeof(vehicles) / sizeof(vehicles[0]))];
 }
 
@@ -51,29 +50,34 @@ static uint32_t GetRandomColor24()
 
 game::OpenWorld::OpenWorld(Game& game) : EnterableWorld("openworld"), game_(game)
 {
-    SetSpawnPoint(glm::vec3(100.0f, 100.0f, 1.0f));
+    // spawn bots
+    for (size_t i = 0; i < 100; ++i)
+    {
+        SpawnBot();
+    }
 
     // initial twingo
-    VehicleSpawnInfo twingo_info{};
+    VehicleTuning twingo_tuning;
-    twingo_info.tuning.model = "twingo";
+    twingo_tuning.model = "twingo";
-    twingo_info.tuning.parts["primarycolor"] = "orange";
+    twingo_tuning.parts["primarycolor"] = "orange";
     // twingo_tuning.primary_color = 0x0077FF;
     // twingo_tuning.wheels_idx = 1; // enkei
     // twingo_tuning.wheel_color = 0x00FF00;
-    twingo_info.position = glm::vec3{110.0f, 100.0f, 5.0f};
 
-    auto& veh = Spawn<game::DrivableVehicle>(twingo_info);
+    auto& veh = Spawn<game::DrivableVehicle>(twingo_tuning);
+    veh.SetPosition({110.0f, 100.0f, 5.0f});
 
     constexpr size_t in_row = 20;
 
     for (size_t i = 0; i < 100; ++i)
     {
-        Schedule(i * 160, [this, i] {
+        Schedule(i * 40, [this, i] {
             size_t col = i % in_row;
             size_t row = i / in_row;
             glm::vec3 pos(62.0f + static_cast<float>(col) * 4.0f, 165.0f + static_cast<float>(row) * 7.0f, 7.0f);
 
-            SpawnRandomVehicle(pos, 0.0f);
+            auto& veh = SpawnRandomVehicle();
+            veh.SetPosition(pos);
         });
     }
 
@@ -84,25 +88,9 @@ game::OpenWorld::OpenWorld(Game& game) : EnterableWorld("openworld"), game_(game
         CreateTuningGarage(loc.transform.position, glm::eulerAngles(loc.transform.rotation).x);
     }
 
-    CreatePermaItemPickups("pickup_uzi", "uzi");
-    CreatePermaItemPickups("pickup_ak47", "ak47");
-    CreatePermaItemPickups("pickup_airsniper", "airsniper");
-
-    SpawnNpcs();
-
     // cow
     auto& cow = Spawn<Cow>(glm::vec3(0.0f, 0.0f, 2.0f), 0.0f);
     cow.SetNametag("no ty krávo");
-
-    // hit target npc
-    auto& npc = SpawnRandomNpc();
-    npc.SetPosition({90.0f, 100.0f, 5.0f});
-    npc.SetWeapon(std::make_shared<ItemInstance>("ak47"));
-
-    // hit target npc 2
-    auto& npc2 = SpawnRandomNpc();
-    npc2.SetPosition({80.0f, 100.0f, 5.0f});
-    npc2.SetWeapon(std::make_shared<ItemInstance>("airsniper"));
 }
 
 void game::OpenWorld::Update(int64_t delta_time)
@@ -125,47 +113,15 @@ void game::OpenWorld::PlayerInput(Player& player, PlayerInputType type, bool ena
     Super::PlayerInput(player, type, enabled);
 }
 
-void game::OpenWorld::SpawnNpcs()
+game::DrivableVehicle& game::OpenWorld::SpawnRandomVehicle()
 {
-    int64_t next_spawn_after = 10000;
+    game::VehicleTuning tuning;
-
+    tuning.model = GetRandomCarModel();
-    if (num_npcs_ < 120)
-    {
-        SpawnNpcVehicleWithPassengers();
-        next_spawn_after = RandomInt(100, 1000);
-    }
-
-    Schedule(next_spawn_after, [this]{
-        SpawnNpcs();
-    });
-}
-
-static void CheckVehicleAbandonment(game::DrivableVehicle& vehicle)
-{
-    if (vehicle.IsAbandoned(60000 * 5)) // 5 min
-    {
-        vehicle.Remove();
-    }
-    else
-    {
-        vehicle.Schedule(RandomInt(0, 1000) + 10000, [&vehicle]{
-            CheckVehicleAbandonment(vehicle);
-        });
-    }
-}
-
-game::DrivableVehicle& game::OpenWorld::SpawnRandomVehicle(const glm::vec3& pos, float yaw, bool auto_despawn)
-{
-    VehicleSpawnInfo vehicle_info;
-    vehicle_info.tuning.model = GetRandomCarModel();
-    vehicle_info.position = pos;
-    vehicle_info.yaw = yaw;
     // tuning.primary_color = GetRandomColor24();
 
-    auto& vehicle = Spawn<game::DrivableVehicle>(vehicle_info);
+    auto& vehicle = Spawn<game::DrivableVehicle>(tuning);
     // vehicle.SetNametag("bot (" + std::to_string(vehicle.GetEntNum()) + ")");
 
-    auto& tuning = vehicle_info.tuning;
     auto& tuning_list = vehicle.GetTuningList();
 
     // make random tuning 
@@ -200,103 +156,29 @@ game::DrivableVehicle& game::OpenWorld::SpawnRandomVehicle(const glm::vec3& pos,
 
     vehicle.SetTuning(tuning);
 
-    if (auto_despawn)
-    {
-        CheckVehicleAbandonment(vehicle);
-    }
-
     return vehicle;
 }
 
-static void CheckNpcBoredom(game::NpcCharacter& npc)
+void game::OpenWorld::SpawnBot()
-{
-    if (!npc.IsAlive())
-        return;
-
-    if (npc.IsBored(60000 * 5)) // 5 min doing nothing is insufferable
-    {
-        npc.Die();
-    }
-    else
-    {
-        npc.Schedule(RandomInt(0, 2000) + 10000, [&npc]{
-            CheckNpcBoredom(npc);
-        });
-    }
-}
-
-game::NpcCharacter& game::OpenWorld::SpawnRandomNpc()
-{
-    HumanCharacterTuning npc_tuning;
-    npc_tuning.clothes.push_back({ "tshirt", GetRandomColor24() });
-    npc_tuning.clothes.push_back({ "shorts", GetRandomColor24() });
-
-    auto& npc = Spawn<NpcCharacter>(npc_tuning);
-
-    npc.SetOnDeath([this, &npc] {
-        npc.Schedule(15000, [&npc]{
-            npc.Remove();
-        });
-
-        if (num_npcs_ > 0)
-        {
-            --num_npcs_;
-        }
-    });
-
-    npc.Schedule(1000, [&npc]{
-        CheckNpcBoredom(npc);
-    });
-
-    ++num_npcs_;
-
-    return npc;
-}
-
-static std::tuple<glm::vec3, float> GetRandomNodeAndRotation(const assets::MapGraph& graph)
-{
-    size_t node_idx = rand() % graph.nodes.size();
-    auto& node = graph.nodes[node_idx];
-
-    size_t nb_idx = graph.nbs[rand() % node.num_nbs];
-    auto& nb = graph.nodes[nb_idx];
-
-    auto dir = node.position - nb.position;
-    float yaw = glm::atan(-dir.x, dir.y);
-
-    return std::make_tuple(node.position, yaw);
-}
-
-void game::OpenWorld::SpawnNpcVehicleWithPassengers()
 {
     auto roads = GetMap().GetGraph("roads");
 
     if (!roads)
     {
-        throw std::runtime_error("SpawnNpcVehicleWithPassengers: no roads graph in map");
+        throw std::runtime_error("SpawnBot: no roads graph in map");
     }
 
-    auto [pos, yaw] = GetRandomNodeAndRotation(*roads);
+    size_t start_node = rand() % roads->nodes.size();
-    auto& vehicle = SpawnRandomVehicle(pos, yaw, true);
 
-    auto& driver = SpawnRandomNpc();
+    auto& vehicle = SpawnRandomVehicle();
+    vehicle.SetPosition(roads->nodes[start_node].position + glm::vec3{0.0f, 0.0f, 5.0f});
+
+    HumanCharacterTuning npc_tuning;
+    npc_tuning.clothes.push_back({ "tshirt", GetRandomColor24() });
+    npc_tuning.clothes.push_back({ "shorts", GetRandomColor24() });
+
+    auto& driver = Spawn<NpcCharacter>(npc_tuning);
     driver.Ride(&vehicle, 0);
-
-    if (Chance(0.5f))
-    {
-        driver.SetWeapon(std::make_shared<ItemInstance>("uzi"));
-    }
-
-    if (Chance(0.3f))
-    {
-        auto& passenger = SpawnRandomNpc();
-        passenger.Ride(&vehicle, 1);
-
-        if (Chance(0.5f))
-        {
-            passenger.SetWeapon(std::make_shared<ItemInstance>(Chance(0.4f) ? "ak47" : (Chance(0.5f) ? "uzi" : "airsniper")));
-        }
-    }
 }
 
 void game::OpenWorld::CreateTuningGarage(const glm::vec3& position, float yaw)
@@ -308,7 +190,7 @@ void game::OpenWorld::CreateTuningGarage(const glm::vec3& position, float yaw)
     marker_info.position = position;
     marker_info.type = MARKER_VEHICLE;
     marker_info.color = 0x884400;
-    marker_info.model = "marker_tuning";
+    marker_info.icon = "tuning";
 
     auto& marker = Spawn<Marker>(marker_info);
     marker.SetUseTarget("vject do tunírny", 
@@ -353,20 +235,6 @@ void game::OpenWorld::CreateTuningGarage(const glm::vec3& position, float yaw)
     });
 }
 
-void game::OpenWorld::CreatePermaItemPickups(const std::string& loc_name, const std::string& item_name)
-{
-    for (auto locs = GetMap().GetLocations(loc_name); const auto& loc : locs)
-    {
-        CreatePermaItemPickup(loc.transform.position, item_name);
-    }
-}
-
-void game::OpenWorld::CreatePermaItemPickup(const glm::vec3& position, const std::string& item_name)
-{
-    auto item_def = assets::CacheManager::GetItem("data/" + item_name + ".item");
-    CreateItemPickup(position, std::make_shared<ItemInstance>(item_def), 0, 5000, item_def->clip_size * 15);
-}
-
 void game::OpenWorld::RecoverPlayer(Player& player)
 {
     auto character = GetPlayerCharacter(player);

src/game/openworld.hpp

@@ -19,25 +19,18 @@ public:
     virtual void PlayerInput(Player& player, PlayerInputType type, bool enabled) override;
 
 private: 
-    void SpawnNpcs();
+    game::DrivableVehicle& SpawnRandomVehicle();
-    game::DrivableVehicle& SpawnRandomVehicle(const glm::vec3& pos, float yaw, bool auto_despawn = false);
+    void SpawnBot();
-    game::NpcCharacter& SpawnRandomNpc();
-    void SpawnNpcVehicleWithPassengers();
 
     void CreateTuningGarage(const glm::vec3& position, float yaw);
-    void CreatePermaItemPickups(const std::string& loc_name, const std::string& item_name);
-    void CreatePermaItemPickup(const glm::vec3& position, const std::string& item);
 
     void RecoverPlayer(Player& player);
     bool GetRecoveryPosition(const glm::vec3& current, glm::vec3& recovery);
 
 private:
     Game& game_;
+    std::vector<NpcCharacter*> npcs_;
     float daytime_offset_ = 0.0f;
-    
-    // std::vector<NpcCharacter*> npcs_;
-    size_t num_npcs_ = 0;
-
 };
 
 }

src/game/player.cpp

@@ -35,11 +35,6 @@ void game::Player::Update()
 {
     SyncWorld();
     SendMenuMsgs();
-    UpdateCamera();
-    SendDamageEvents();
-
-    // reset for next frame
-    in_new_ = 0;
 }
 
 void game::Player::SetWorld(World* world)
@@ -50,14 +45,12 @@ void game::Player::SetWorld(World* world)
     world_ = world;
 }
 
-void game::Player::SetCamera(const CameraInfo& camera_info)
+void game::Player::SetCamera(net::EntNum entnum)
 {
-    camera_info_ = camera_info;
+    cam_ent_ = entnum;
 
     auto msg = BeginMsg(net::MSG_CAM);
-    msg.Write(camera_info.character_entnum);
+    msg.Write(entnum);
-    msg.Write(camera_info.rideable_entnum);
-    msg.Write(camera_info.flags);
 }
 
 void game::Player::SendChat(const std::string& text)
@@ -104,92 +97,6 @@ void game::Player::CloseMenu(const RemoteMenu& menu)
     remote_menu_.reset();
 }
 
-void game::Player::SetHudData(const PlayerHudData& hud_data)
-{
-    PlayerHudFields fields = 0;
-
-    auto msg = BeginMsg(net::MSG_HUD);
-    auto fields_pos = msg.Reserve<PlayerHudFields>();
-
-    if (hud_data.health != hud_data_.health)
-    {
-        fields |= PHUD_HEALTH;
-        hud_data_.health = hud_data.health;
-        msg.Write(hud_data.health);
-    }
-
-    if (hud_data.weapon_slots != hud_data_.weapon_slots)
-    {
-        fields |= PHUD_WEAPON_SLOTS;
-        hud_data_.weapon_slots = hud_data.weapon_slots;
-        msg.Write(hud_data.weapon_slots);
-    }
-
-    if (hud_data.held_item != hud_data_.held_item)
-    {
-        fields |= PHUD_ITEM;
-        hud_data_.held_item = hud_data.held_item;
-        msg.Write(net::ModelName(hud_data.held_item));
-    }
-
-    if (hud_data.ammo_loaded != hud_data_.ammo_loaded)
-    {
-        fields |= PHUD_AMMO_LOADED;
-        hud_data_.ammo_loaded = hud_data.ammo_loaded;
-        msg.Write(hud_data.ammo_loaded);
-    }
-
-    if (hud_data.ammo_total != hud_data_.ammo_total)
-    {
-        fields |= PHUD_AMMO_TOTAL;
-        hud_data_.ammo_total = hud_data.ammo_total;
-        msg.Write(hud_data.ammo_total);
-    }
-
-    if (hud_data.dead != hud_data_.dead)
-    {
-        fields |= PHUD_DEATH;
-        hud_data_.dead = hud_data.dead;
-        msg.Write(hud_data.dead);
-    }
-
-    if (fields == 0)
-    {
-        DiscardMsg();
-        return;
-    }
-
-    msg.WriteAt(fields_pos, fields);
-}
-
-void game::Player::ResetHudData()
-{
-    SetHudData(PlayerHudData{});
-}
-
-void game::Player::DisplayDamageEvent(DamageEventType type)
-{
-    dmg_event_flags_ |= 1 << type;
-}
-
-bool game::Player::GetView(glm::vec3& eye, glm::vec3& forward)
-{
-    if (!world_)
-        return false;
-
-    auto character = world_->GetEntity(camera_info_.character_entnum);
-    camera_controller_.SetCharacterTransform(character ? &character->GetRoot().matrix : nullptr);
-    
-    auto rideable = world_->GetEntity(camera_info_.rideable_entnum);
-    camera_controller_.SetRideableTransform(rideable ? &rideable->GetRoot().matrix : nullptr);
-
-    camera_controller_.Recalculate(world_);
-
-    eye = camera_controller_.GetEye();
-    forward = camera_controller_.GetForward();
-    return true;
-}
-
 game::Player::~Player()
 {
     game_.PlayerLeft(*this);
@@ -208,26 +115,12 @@ void game::Player::SyncWorld()
 
     if (world_)
     {
-        UpdateCullPos();
         SendWorldUpdateMsg();
         SendEnv();
         SyncEntities();
     }
 }
 
-void game::Player::UpdateCullPos()
-{
-    auto cam_entnum = camera_info_.rideable_entnum ? camera_info_.rideable_entnum : camera_info_.character_entnum;
-    if (cam_entnum)
-    {
-        auto cam_ent = world_->GetEntity(cam_entnum);
-        if (cam_ent)
-        {
-            cull_pos_ = cam_ent->GetRoot().GetGlobalPosition();
-        }
-    }
-}
-
 void game::Player::SendWorldMsg()
 {
     MSGDEBUG(std::cout << "seding CHWORLD" << std::endl;)
@@ -244,29 +137,6 @@ void game::Player::SendWorldUpdateMsg()
 
     auto msg = BeginMsg(); // no CMD here, included in world payload
     msg.Write(world_->GetMsg());
-
-    // local msgs
-    world_->PickLocalMsgs(*this, cull_pos_);
-}
-
-void game::Player::SendDamageEvents()
-{
-    if (dmg_event_flags_ & (1 << DAMAGE_EVENT_RECEIVED))
-        SendDamageEvent(DAMAGE_EVENT_RECEIVED);
-
-    if (dmg_event_flags_ & (1 << DAMAGE_EVENT_DEALT))
-        SendDamageEvent(DAMAGE_EVENT_DEALT);
-
-    if (dmg_event_flags_ & (1 << DAMAGE_EVENT_DEALT_KILL))
-        SendDamageEvent(DAMAGE_EVENT_DEALT_KILL);
-
-    dmg_event_flags_ = 0;
-}
-
-void game::Player::SendDamageEvent(DamageEventType type)
-{
-    auto msg = BeginMsg(net::MSG_DAMAGE);
-    msg.Write(type);
 }
 
 void game::Player::SendEnv()
@@ -282,6 +152,16 @@ void game::Player::SendEnv()
 
 void game::Player::SyncEntities()
 {
+    // update cull pos
+    if (cam_ent_)
+    {
+        auto cam_ent = world_->GetEntity(cam_ent_);
+        if (cam_ent)
+        {
+            cull_pos_ = cam_ent->GetRoot().GetGlobalPosition();
+        }
+    }
+
     // list of entities to send update and messages of
     static std::vector<const Entity*> upd_ents;
     upd_ents.clear();
@@ -413,8 +293,10 @@ bool game::Player::ProcessViewAnglesMsg(net::InMessage& msg)
     if (!msg.Read(yaw_q.value) || !msg.Read(pitch_q.value))
         return false;
 
-    camera_controller_.SetViewAngles(yaw_q.Decode(),  pitch_q.Decode());
+    view_yaw_ = yaw_q.Decode();
-    game_.PlayerViewAnglesChanged(*this, camera_controller_.GetYaw(), camera_controller_.GetPitch());    
+    view_pitch_ = pitch_q.Decode();
+    
+    game_.PlayerViewAnglesChanged(*this, view_yaw_, view_pitch_);    
     return true;
 }
 
@@ -450,17 +332,10 @@ bool game::Player::ProcessMenuActionMsg(net::InMessage& msg)
 
 void game::Player::Input(PlayerInputType type, bool enabled)
 {
-    PlayerInputFlags flag = 1 << type;
-
     if (enabled)
-    {
+        in_ |= (1 << type);
-        in_ |= flag;
-        in_new_ |= flag;
-    }
     else
-    {
+        in_ &= ~(1 << type);
-        in_ &= ~flag;
-    }
 
     game_.PlayerInput(*this, type, enabled);
 }
@@ -482,9 +357,3 @@ void game::Player::SendMenuMsgs()
     remote_menu_->ResetMsg();
 
 }
-
-void game::Player::UpdateCamera()
-{
-    camera_controller_.SetAiming(camera_info_.flags & CAM_AIMING);
-    camera_controller_.Update(1.0f / 25.0f);
-}

src/game/player.hpp

@@ -9,11 +9,10 @@
 #include "net/inmessage.hpp"
 #include "net/msg_producer.hpp"
 #include "utils/defs.hpp"
+
 #include "player_input.hpp"
+
 #include "remote_menu.hpp"
-#include "camera_info.hpp"
-#include "camera_controller.hpp"
-#include "player_hud_data.hpp"
 
 namespace game
 {
@@ -33,7 +32,7 @@ public:
 
     void SetWorld(World* world);
 
-    void SetCamera(const CameraInfo& camera_info);
+    void SetCamera(net::EntNum entnum);
     void SendChat(const std::string& text);
     void SetUseTarget(const std::string& text, const std::string& error_text, float delay);
 
@@ -41,18 +40,11 @@ public:
     void CloseMenu(const RemoteMenu& menu);
     bool HasOpenMenu() const { return (bool)remote_menu_; }
 
-    void SetHudData(const PlayerHudData& hud_data);
-    void ResetHudData();
-
-    void DisplayDamageEvent(DamageEventType type);
-
     const std::string& GetName() const { return name_; }
 
     PlayerInputFlags GetInput() const { return in_; }
-    PlayerInputFlags GetNewInput() const { return in_new_; }
+    float GetViewYaw() const { return view_yaw_; }
-    float GetViewYaw() const { return camera_controller_.GetYaw(); }
+    float GetViewPitch() const { return view_pitch_; }
-    float GetViewPitch() const { return camera_controller_.GetPitch(); }
-    bool GetView(glm::vec3& eye, glm::vec3& forward);
 
     const glm::vec3 GetCullPos() const { return cull_pos_; }
 
@@ -61,11 +53,8 @@ public:
 private:
     // world sync
     void SyncWorld();
-    void UpdateCullPos();
     void SendWorldMsg();
     void SendWorldUpdateMsg();
-    void SendDamageEvents();
-    void SendDamageEvent(DamageEventType type);
     void SendEnv();
 
     // entities sync
@@ -85,8 +74,6 @@ private:
     // menu sync
     void SendMenuMsgs();
 
-    void UpdateCamera();
-
 private:
     Game& game_;
     std::string name_;
@@ -97,20 +84,15 @@ private:
     int64_t last_env_time_ = 0;
 
     PlayerInputFlags in_ = 0;
-    PlayerInputFlags in_new_ = 0;
+    float view_yaw_ = 0.0f, view_pitch_ = 0.0f;
 
-    CameraInfo camera_info_;
+    net::EntNum cam_ent_ = 0;
-    CameraController camera_controller_;
     glm::vec3 cull_pos_ = glm::vec3(0.0f);
 
     // menus
     // TODO: allow more menus
     net::MenuId menu_id_ = 0;
     std::unique_ptr<RemoteMenu> remote_menu_;
-
-    // hud
-    PlayerHudData hud_data_;
-    uint8_t dmg_event_flags_ = 0;
 };
 
 }

src/game/player_character.cpp

@@ -1,8 +1,6 @@
 #include "player_character.hpp"
-
 #include "world.hpp"
 #include "input_mapping.hpp"
-#include "utils/random.hpp"
 
 game::PlayerCharacter::PlayerCharacter(World& world, Player& player, const HumanCharacterTuning& tuning) : Super(world, tuning), player_(&player)
 {
@@ -10,59 +8,16 @@ game::PlayerCharacter::PlayerCharacter(World& world, Player& player, const Human
     UpdatePlayerCamera();
     SetNametag(player.GetName());
     SendUseTargetInfo();
-
-    // give some shit
-    GiveItem(std::make_shared<ItemInstance>("airsniper"), false);
-    GiveAmmo("pellet", 50);
-    // GiveItem(std::make_shared<ItemInstance>("ak47"), false);
-    // GiveItem(std::make_shared<ItemInstance>("uzi"), false);
 }
 
 void game::PlayerCharacter::Update()
 {
     UpdateUseTarget();
-    UpdateAimTarget();
-    CheckItemSwitch();
-    UpdateInputs();
     Super::Update();
-    
+
     if (GetRideable() && IsDriver())
     {
-        GetRideable()->SetRideableViewAngles(GetViewYaw(), GetViewPitch());
+        GetRideable()->SetRideableYaw(GetForwardYaw());
-    }
-
-    UpdateHudData();
-}
-
-void game::PlayerCharacter::ReceiveDamage(const DamageInfo& damage)
-{
-    if (!IsAlive())
-        return;
-
-    Super::ReceiveDamage(damage);
-
-    if (player_)
-    {
-        player_->DisplayDamageEvent(DAMAGE_EVENT_RECEIVED);
-    }
-
-    if (!IsAlive())
-    {
-        // just died
-        std::string_view killer_name;
-        auto killer_character = dynamic_cast<PlayerCharacter*>(damage.inflictor);
-        if (killer_character)
-        {
-            auto killer_player = killer_character->GetPlayer();
-            if (killer_player)
-            {
-                killer_name = killer_player->GetName();
-            }
-        }
-
-        SendDeathMessage(killer_name);
-        SetNametag(std::string{});
-
     }
 }
 
@@ -85,233 +40,50 @@ void game::PlayerCharacter::DetachFromPlayer()
     player_ = nullptr;
 }
 
-void game::PlayerCharacter::SetInventory(std::unique_ptr<Inventory> inventory)
-{
-    if (inventory_)
-    {
-        TakeInventory();
-    }
-
-    inventory_ = std::move(inventory);
-    UpdateHudSlots();
-
-    // if (inventory_->active_slot > 0)
-    // {
-    //     SetWeaponSlot(inventory_->active_slot);
-    // }
-}
-
-std::unique_ptr<game::Inventory> game::PlayerCharacter::TakeInventory()
-{
-    Equip(nullptr);
-    auto inv = std::move(inventory_);
-    UpdateHudSlots();
-    return inv;
-}
-
-void game::PlayerCharacter::GiveItem(std::shared_ptr<ItemInstance> item, bool can_equip)
-{
-    EnsureInventory();
-
-    size_t slot_idx = ((item->def->slot + 9) % 10);
-    auto& slot = inventory_->slots[slot_idx];
-
-    bool equip = can_equip && (!GetHeldItem() || GetHeldItem() == slot);
-
-    if (!slot || slot->def->name != item->def->name)
-    {
-        // current item in the slot is other item or none
-        slot = std::move(item);
-    }
-    else
-    {
-        // already have this, extract ammo
-        GiveAmmo(item->def->ammo_type, item->ammo);
-    }
-
-    UpdateHudSlots();
-    
-    if (equip)
-    {
-        SetWeaponSlot(slot_idx);
-    }
-}
-
-void game::PlayerCharacter::GiveAmmo(const std::string& ammo_name, size_t count)
-{
-    EnsureInventory();
-    inventory_->ammo[ammo_name] += count;
-}
-
-void game::PlayerCharacter::OnDamageDealt(bool was_kill)
-{
-    if (!player_)
-        return;
-
-    player_->DisplayDamageEvent(was_kill ? DAMAGE_EVENT_DEALT_KILL : DAMAGE_EVENT_DEALT);
-}
-
-float game::PlayerCharacter::GetHitBoneDamageMultiplier(const std::string_view hitbone)
-{
-    return 0.25f * Super::GetHitBoneDamageMultiplier(hitbone);
-}
-
 void game::PlayerCharacter::OnRideableChanged()
 {
     UpdatePlayerCamera();
     UpdateInputs();
 }
 
-void game::PlayerCharacter::OnAimingChanged()
-{
-    UpdatePlayerCamera();
-}
-
-void game::PlayerCharacter::OnHeldItemChanged()
-{
-    const auto& item = GetHeldItem();
-    hud_data_.held_item = item ? item->def->name : "";
-}
-
-bool game::PlayerCharacter::HaveAmmo(const std::string& ammo_name)
-{
-    if (!inventory_)
-        return false;
-    
-    auto it = inventory_->ammo.find(ammo_name);
-    if (it == inventory_->ammo.end())
-        return false;
-
-    return it->second > 0;
-}
-
-size_t game::PlayerCharacter::GetAmmo(size_t required, const std::string& ammo_name)
-{
-    if (!inventory_)
-        return 0;
-
-    auto it = inventory_->ammo.find(ammo_name);
-    if (it == inventory_->ammo.end())
-        return 0;
-
-    size_t give = glm::min(it->second, required);
-    it->second -= give;
-
-    return give;
-}
-
-void game::PlayerCharacter::SpawnLoot()
-{
-    if (!inventory_)
-        return;
-
-    for (auto& slot : inventory_->slots)
-    {
-        if (!slot)
-            continue;
-
-        size_t ammo = GetAmmo(slot->def->clip_size * 5, slot->def->ammo_type);
-        auto pos = root_.GetGlobalPosition() + glm::vec3(RandomFloat(-1.0f, 1.0f), RandomFloat(-1.0f, 1.0f), RandomFloat(-0.1f, 1.0f));
-        GetWorld().CreateItemPickup(pos, std::move(slot), RandomInt(59000, 61000), 0, ammo);
-    }
-
-    inventory_.reset();
-}
-
 void game::PlayerCharacter::UpdatePlayerCamera()
 {
     if (!player_)
         return;
 
-    CameraInfo camera_info{};
+    if (auto rideable = GetRideable(); rideable)
-    camera_info.character_entnum = GetEntNum();
+    {
-    camera_info.rideable_entnum = GetRideable() ? GetRideable()->GetEntity().GetEntNum() : 0;
+        player_->SetCamera(rideable->GetEntity().GetEntNum());
-
+    }
-    if (GetAiming())
+    else
-        camera_info.flags |= CAM_AIMING;
+    {
-
+        player_->SetCamera(GetEntNum());
-    player_->SetCamera(camera_info);
+    }
 }
 
 void game::PlayerCharacter::UpdateInputs()
 {
-    auto in = (player_ && IsAlive()) ? player_->GetInput() : 0;
+    auto in = player_ ? player_->GetInput() : 0;
-    
+
     if (auto rideable = GetRideable(); rideable)
     {
         SetInputs(0);
 
-        auto rideable_in = in;
-
         if (IsDriver())
         {
-            if (GetVehicle() && GetHeldItem() && GetHeldItem()->def->twohanded)
+            rideable->SetRideableInput(in);
-            {
-                rideable_in &= ~((1 << IN_RIGHT) | (1 << IN_LEFT));
-            }
-
-            rideable->SetRideableInput(rideable_in);
         }
     }
     else
     {
         SetInputs(MapPlayerInputToCharacterInput(in));
     }
-
-    SetAimHeld(in & (1 << IN_ATTACK_SECONDARY));
-    SetFireHeld(in & (1 << IN_ATTACK_PRIMARY));
-    SetReloadHeld(in & (1 << IN_RELOAD));
-}
-
-void game::PlayerCharacter::UpdateAimTarget()
-{
-    if (!player_ || !IsAlive())
-        return;
-
-    glm::vec3 eye, forward;
-    if (!player_->GetView(eye, forward))
-        return;
-
-    auto target = eye + forward * 1000.0f;
-
-    if (GetAiming()) // save perf if not aiming
-    {
-        GetWorld().TraceBullet(eye, target, this, target); // update target if hit
-    }
-
-    SetAimTarget(target);
-
-    // GetWorld().Beam(eye, target, 0xFFFF00, 1.0 / 25.0f);
-    // GetWorld().BeamBox(target - 0.05f, target + 0.05f, 0xFFFF00, 1.5f / 25.0f);
-}
-
-void game::PlayerCharacter::CheckItemSwitch()
-{
-    if (!player_ || !inventory_ || !IsAlive())
-        return;
-    
-    auto in = player_->GetNewInput();
-
-    if (in & (1 << IN_HOLSTER))
-    {
-        Equip(GetHeldItem() ? nullptr : inventory_->slots[inventory_->active_slot]);
-        return;
-    }
-
-    for (size_t i = 0; i < 10; ++i) 
-    {
-        if ((in & (1 << (IN_WEAPON_1 + i))) == 0)
-            continue;
-    
-        SetWeaponSlot(i);
-        break;
-    }
 }
 
 void game::PlayerCharacter::UpdateUseTarget()
 {
     UseTargetQueryResult res{};
-    auto new_use_target = IsAlive() ? world_.GetBestUseTarget(*this, res) : nullptr;
+    auto new_use_target = world_.GetBestUseTarget(*this, res);
 
     if (new_use_target != use_target_ || res.enabled != use_enabled_ || res.error_text != use_error_ || res.delay != use_delay_)
     {
@@ -340,9 +112,6 @@ void game::PlayerCharacter::UpdateUseTarget()
 
 void game::PlayerCharacter::UseChanged(bool enabled)
 {
-    if (!IsAlive())
-        return;
-
     if (!use_target_)
     {
         // exit rideable if not target
@@ -382,136 +151,3 @@ void game::PlayerCharacter::SendUseTargetInfo()
 
     player_->SetUseTarget(use_target_->desc, error_text, using_ ? use_delay_ - use_progress_ : 0.0f);
 }
-
-void game::PlayerCharacter::EnsureInventory()
-{
-    if (!inventory_)
-    {
-        inventory_ = std::make_unique<Inventory>();
-    }
-}
-
-void game::PlayerCharacter::SetWeaponSlot(size_t slot)
-{ 
-    if (!inventory_ || !inventory_->slots[slot])
-        return;
-    
-    inventory_->active_slot = slot;
-    Equip(inventory_->slots[slot]);
-}
-
-void game::PlayerCharacter::UpdateHudData() 
-{
-    if (!player_)
-        return;
-
-    // general
-    hud_data_.health = static_cast<uint8_t>(GetHealth());
-
-    // item
-    const auto& item = GetHeldItem();
-    hud_data_.ammo_loaded = item ? item->ammo : 0;
-
-    hud_data_.ammo_total = 0;
-    if (item && inventory_)
-    {
-        auto it = inventory_->ammo.find(item->def->ammo_type);
-        if (it != inventory_->ammo.end())
-        {
-            hud_data_.ammo_total = it->second;
-        }
-    }
-
-    // death
-    hud_data_.dead = IsDead() ? 1 : 0;
-
-    player_->SetHudData(hud_data_);
-}
-
-void game::PlayerCharacter::UpdateHudSlots()
-{
-    hud_data_.weapon_slots = 0;
-
-    if (!inventory_ || IsDead())
-        return;
-
-    for (size_t i = 0; i < 10; ++i)
-    {
-        if (inventory_->slots[i])
-            hud_data_.weapon_slots |= 1 << i;
-    }
-
-
-}
-
-static std::string_view GetRandomDeathMessageFormat()
-{
-    switch (rand() % 8)
-    {
-    case 1:
-        return "byl zneškodněn";
-    case 2:
-        return "chcíp";
-    case 3:
-        return "umříl";
-    case 4:
-        return "umřel";
-    case 5:
-        return "pošel";
-    case 6:
-        return "odešel na věčné časy";
-    case 7:
-        return "už není mezi námi";
-    default:
-        return "zesnul";
-    }
-}
-
-static std::string_view GetRandomDeathMessageFormatKilled()
-{
-    switch (rand() % 8)
-    {
-    case 0:
-        return "zneškodnil";
-    case 1:
-        return "vyřešil";
-    case 2:
-        return "zajebal";
-    case 3:
-        return "zlikvidoval";
-    case 4:
-        return "odstranil";
-    case 5:
-        return "terminoval";
-    case 6:
-        return "zabil";
-    default:
-        return "kilnul";
-    }
-}
-
-void game::PlayerCharacter::SendDeathMessage(std::string_view killer_name)
-{
-    if (!player_)
-        return;
-
-    std::string message;
-
-    if (killer_name.empty())
-    {
-        message += player_->GetName();
-        message += "^r ";
-        message += GetRandomDeathMessageFormat();
-    }
-    else
-    {
-        message += killer_name;
-        message += "^r ";
-        message += GetRandomDeathMessageFormatKilled();
-        message += " ";
-        message += player_->GetName();
-    }
-
-    GetWorld().SendChat(message);
-
-}

src/game/player_character.hpp

@@ -3,7 +3,6 @@
 #include "drivable_vehicle.hpp"
 #include "player.hpp"
 #include "world.hpp"
-#include "inventory.hpp"
 
 namespace game
 {
@@ -17,50 +16,23 @@ public:
 
     virtual void Update() override;
 
-    virtual void ReceiveDamage(const DamageInfo& damage) override;
-
     void ProcessInput(PlayerInputType type, bool enabled);
 
     void DetachFromPlayer();
 
     Player* GetPlayer() const { return player_; }
 
-    void SetInventory(std::unique_ptr<Inventory> inventory);
+protected:
-    std::unique_ptr<Inventory> TakeInventory();
-
-    void GiveItem(std::shared_ptr<ItemInstance> item, bool can_equip = true);
-    void GiveAmmo(const std::string& ammo_name, size_t count);
-
-    virtual void OnDamageDealt(bool was_kill) override;
-
-    protected:
-    virtual float GetHitBoneDamageMultiplier(const std::string_view hitbone) override;
-    
     virtual void OnRideableChanged() override;
-    virtual void OnAimingChanged() override;
-    virtual void OnHeldItemChanged() override;
-    virtual bool HaveAmmo(const std::string& ammo_name) override;
-    virtual size_t GetAmmo(size_t required, const std::string& ammo_name) override;
-    virtual void SpawnLoot() override;
 
 private:
     void UpdatePlayerCamera();
     void UpdateInputs();
-    void UpdateAimTarget();
-    void CheckItemSwitch();
     
     void UpdateUseTarget();
     void UseChanged(bool enabled);
     void SendUseTargetInfo();
 
-    void EnsureInventory();
-    void SetWeaponSlot(size_t slot);
-
-    void UpdateHudData();
-    void UpdateHudSlots();
-
-    void SendDeathMessage(std::string_view killer_name);
-
 private:
     Player* player_;
 
@@ -71,10 +43,6 @@ private:
     const char* use_error_ = nullptr;
     bool using_ = false; // not drugs lol
     float use_progress_ = 0.0f;
-
-    std::unique_ptr<Inventory> inventory_;
-
-    PlayerHudData hud_data_;
 };
 
 

src/game/player_hud_data.hpp

@@ -1,45 +0,0 @@
-#pragma once
-
-#include "net/defs.hpp"
-
-namespace game
-{
-
-using PlayerHudFields = uint8_t;
-enum PlayerHudField : PlayerHudFields
-{
-    PHUD_HEALTH = 1,
-    PHUD_WEAPON_SLOTS = 2,
-    PHUD_ITEM = 4,
-    PHUD_AMMO_LOADED = 8,
-    PHUD_AMMO_TOTAL = 16,
-    PHUD_DEATH = 32,
-};
-
-struct PlayerHudData
-{
-    // general
-    uint8_t health = 0;
-    // TODO: stamina ?
-    uint8_t weapon_slots = 0;
-    
-    // held item
-    std::string held_item;
-    uint8_t ammo_loaded = 0;
-    uint32_t ammo_total = 0;
-    
-    // death
-    uint8_t dead = 0;
-    
-    // TODO: use target
-
-};
-
-enum DamageEventType : uint8_t
-{
-    DAMAGE_EVENT_RECEIVED,
-    DAMAGE_EVENT_DEALT,
-    DAMAGE_EVENT_DEALT_KILL,
-};
-
-}

src/game/player_input.hpp

@@ -4,7 +4,7 @@
 
 namespace game
 {
-	using PlayerInputFlags = uint32_t;
+	using PlayerInputFlags = uint16_t;
 
 	enum PlayerInputType : uint8_t
 	{
@@ -16,20 +16,7 @@ namespace game
 		IN_CROUCH,
 		IN_SPRINT,
 		IN_USE,
-		IN_ATTACK_PRIMARY,
+		IN_ATTACK,
-		IN_ATTACK_SECONDARY,
-		IN_HOLSTER,
-		IN_RELOAD,
-		IN_WEAPON_1,
-		IN_WEAPON_2,
-		IN_WEAPON_3,
-		IN_WEAPON_4,
-		IN_WEAPON_5,
-		IN_WEAPON_6,
-		IN_WEAPON_7,
-		IN_WEAPON_8,
-		IN_WEAPON_9,
-		IN_WEAPON_0,
 		IN_DEBUG1,
 		IN_DEBUG2,
 		IN_DEBUG3,

src/game/rideable.cpp

@@ -2,12 +2,7 @@
 
 #include <stdexcept>
 
-#include "world.hpp"
+game::Rideable::Rideable(Entity& entity, RideableType type) : entity_(entity), type_(type) {}
-
-game::Rideable::Rideable(Entity& entity, RideableType type) : entity_(entity), type_(type)
-{
-    last_passenger_leave_time_ = entity_.GetWorld().GetTime();
-}
 
 void game::Rideable::SetPassenger(size_t seat_idx, HumanCharacter* passenger) 
 {
@@ -22,8 +17,6 @@ void game::Rideable::SetPassenger(size_t seat_idx, HumanCharacter* passenger)
     if (seat.passenger)
     {
         seat.passenger->SetRideable(nullptr, 0); // remove current passenger
-        seat.passenger = nullptr;
-        OnPassengerChanged(seat_idx, nullptr);
     }
 
     seat.passenger = passenger;
@@ -34,10 +27,9 @@ void game::Rideable::SetPassenger(size_t seat_idx, HumanCharacter* passenger)
     }
 
     OnPassengerChanged(seat_idx, passenger);
-    UpdateLeaveTime();
 }
 
-game::HumanCharacter* game::Rideable::GetPassenger(size_t seat_idx) const
+game::HumanCharacter* game::Rideable::GetPassenger(size_t seat_idx)
 {
     if (seat_idx >= seats_.size())
         return nullptr;
@@ -45,7 +37,7 @@ game::HumanCharacter* game::Rideable::GetPassenger(size_t seat_idx) const
     return seats_[seat_idx].passenger;
 }
 
-const glm::vec3& game::Rideable::GetSeatOffset(size_t seat_idx) const
+const glm::vec3& game::Rideable::GetSeatOffset(size_t seat_idx)
 {
     if (seat_idx >= seats_.size())
         throw std::runtime_error("Invalid seat index");
@@ -62,28 +54,6 @@ void game::Rideable::KickAll()
     }
 }
 
-void game::Rideable::OnRideableDamaged(const DamageInfo& damage) const
-{
-    for (const auto& seat : seats_)
-    {
-        if (seat.passenger)
-        {
-            seat.passenger->OnRideableDamaged(damage);
-        }
-    }
-}
-
-bool game::Rideable::IsAbandoned(int64_t time) const
-{
-    // still someone in
-    if (last_passenger_leave_time_ < 0)
-    {
-        return false;
-    }
-
-    return entity_.GetWorld().GetTime() - last_passenger_leave_time_ >= time;
-}
-
 game::Rideable::~Rideable()
 {
     // kick passengers
@@ -97,25 +67,3 @@ size_t game::Rideable::AddSeat(const glm::vec3& offset)
     seats_.emplace_back(seat);
     return seats_.size() - 1;
 }
-
-void game::Rideable::UpdateLeaveTime()
-{
-    size_t num_passengers = 0;
-    for (const auto& seat : seats_)
-    {
-        if (seat.passenger)
-        {
-            ++num_passengers;
-        }
-    }
-
-    if (num_passengers > 0)
-    {
-        last_passenger_leave_time_ = -1;
-    }
-    else
-    {
-        last_passenger_leave_time_ = entity_.GetWorld().GetTime();
-    }
-
-}

src/game/rideable.hpp

@@ -25,20 +25,16 @@ public:
     Rideable(Entity& entity, RideableType type);
 
     void SetPassenger(size_t seat_idx, HumanCharacter* passenger);
-    HumanCharacter* GetPassenger(size_t seat_idx) const;
+    HumanCharacter* GetPassenger(size_t seat_idx);
-    const glm::vec3& GetSeatOffset(size_t seat_idx) const;
+    const glm::vec3& GetSeatOffset(size_t seat_idx);
     size_t GetNumSeats() const { return seats_.size(); }
     void KickAll();
 
     virtual void SetRideableInput(PlayerInputFlags in) {}
-    virtual void SetRideableViewAngles(float yaw, float pitch) {}
+    virtual void SetRideableYaw(float yaw) {}
-    
-    void OnRideableDamaged(const DamageInfo& damage) const;
     
     RideableType GetRideableType() const { return type_; }
     
-    bool IsAbandoned(int64_t time) const;
-
     Entity& GetEntity() { return entity_; }
     const Entity& GetEntity() const { return entity_; }
 
@@ -48,15 +44,10 @@ protected:
     size_t AddSeat(const glm::vec3& offset);
     virtual void OnPassengerChanged(size_t seat_idx, HumanCharacter* passenger) {}
 
-private:
-    void UpdateLeaveTime();
-
 private:
     Entity& entity_;
     RideableType type_;
     std::vector<RideableSeat> seats_;
-
-    int64_t last_passenger_leave_time_ = -1;
 };
 
 

src/game/skeletoninstance.cpp

@@ -7,15 +7,6 @@ game::SkeletonInstance::SkeletonInstance(std::shared_ptr<const assets::Skeleton>
     SetupBoneNodes();
 }
 
-const game::TransformNode* game::SkeletonInstance::GetBoneNodeByName(const std::string& bone_name) const
-{
-    auto idx = skeleton_->GetBoneIndex(bone_name);
-    if (idx < 0)
-        return nullptr;
-
-    return &GetBoneNode(idx);
-}
-
 void game::SkeletonInstance::ApplySkelAnim(const assets::Animation& anim, float time, float weight)
 {
     float anim_frame = time * anim.GetTPS();
@@ -61,32 +52,6 @@ void game::SkeletonInstance::ApplySkelAnim(const assets::Animation& anim, float
     }
 }
 
-void game::SkeletonInstance::ApplyAim(float yaw, float pitch)
-{
-    const auto& aim_bones = skeleton_->GetAimBones();
-    if (aim_bones.empty())
-        return;
-
-    for (const auto& aim_bone : aim_bones)
-    {
-        auto& bone_transform = bone_nodes_[aim_bone.idx].local;
-
-        if (aim_bone.pitch_weight > 0.0f)
-        {
-            auto pitch_rotation = glm::angleAxis(-pitch * aim_bone.pitch_weight, aim_bone.pitch_axis);
-            bone_transform.rotation = pitch_rotation * bone_transform.rotation;
-        }
-        
-        if (aim_bone.yaw_weight > 0.0f)
-        {
-            auto yaw_rotation = glm::angleAxis(yaw * aim_bone.yaw_weight, aim_bone.yaw_axis);
-            bone_transform.rotation = yaw_rotation * bone_transform.rotation;
-        }
-        
-
-    }
-}
-
 void game::SkeletonInstance::UpdateBoneMatrices()
 {
     for (TransformNode& node : bone_nodes_)

src/game/skeletoninstance.hpp

@@ -15,11 +15,8 @@ public:
 
     const TransformNode* GetRootNode() const { return root_node_; }
     const TransformNode& GetBoneNode(size_t index) const { return bone_nodes_[index]; }
-    const TransformNode* GetBoneNodeByName(const std::string& bone_name) const;
 
     void ApplySkelAnim(const assets::Animation& anim, float time, float weight);
-    void ApplyAim(float yaw, float pitch);
-
     void UpdateBoneMatrices();
 
     const std::vector<TransformNode> GetBoneNodes() const { return bone_nodes_; }

src/game/vehicle.cpp

@@ -5,7 +5,6 @@
 #include "player.hpp"
 #include "player_input.hpp"
 #include "utils/random.hpp"
-#include "utils/math.hpp"
 
 #include <iostream>
 
@@ -14,24 +13,23 @@ static std::shared_ptr<const assets::VehicleModel> LoadVehicleModelByName(const
     return assets::CacheManager::GetVehicleModel("data/" + model_name + ".veh");
 }
 
-game::Vehicle::Vehicle(World& world, const VehicleSpawnInfo& info)
+game::Vehicle::Vehicle(World& world, const VehicleTuning& tuning)
-    : Entity(world, net::ET_VEHICLE), tuning_(info.tuning), model_(LoadVehicleModelByName(info.tuning.model)),
+    : Entity(world, net::ET_VEHICLE), tuning_(tuning), model_(LoadVehicleModelByName(tuning.model)),
-      tuninglist_(VehicleTuningList::LoadFromFile("data/" + info.tuning.model + ".tun"))
+      tuninglist_(VehicleTuningList::LoadFromFile("data/" + tuning.model + ".tun"))
 {
-    root_.local.position = info.position;
+    root_.local.position.z = 10.0f;
-    root_.local.rotation = glm::angleAxis(info.yaw, glm::vec3(0.0f, 0.0f, 1.0f));
 
     wheels_.resize(model_->GetWheels().size());
 
-    ApplyTuning(info.tuning);
+    ApplyTuning(tuning);
 
     // init deform
-    gfx::DeformGridInfo deform_info{};
+    gfx::DeformGridInfo info{};
-    deform_info.min = glm::vec3(-1.0f, -2.5f, 0.10f);
+    info.min = glm::vec3(-1.0f, -2.5f, 0.10f);
-    deform_info.max = glm::vec3(1.0f, 2.0f, 1.8f);
+    info.max = glm::vec3(1.0f, 2.0f, 1.8f);
-    deform_info.res = glm::ivec3(8, 16, 8);
+    info.res = glm::ivec3(8, 16, 8);
-    deform_info.max_offset = 0.1f;
+    info.max_offset = 0.1f;
-    deformgrid_ = std::make_unique<DeformGrid>(deform_info);
+    deformgrid_ = std::make_unique<DeformGrid>(info);
 
     Update();
 }
@@ -40,11 +38,6 @@ void game::Vehicle::Update()
 {
     Super::Update();
 
-    if (physics_)
-    {
-        physics_->Update();
-    }
-
     root_.UpdateMatrix();
 
     flags_ = 0;
@@ -83,32 +76,20 @@ void game::Vehicle::OnContact(const collision::ContactInfo& info)
     if (info.impulse < 1000.0f)
         return;
 
-    ApplyDamage(info.impulse * 0.01f);
+    if (health_ > 0.0f)
-    Deform(info.pos, -glm::normalize(info.normal) * 0.1f, 1.0f);
-
-}
-
-void game::Vehicle::ReceiveDamage(const DamageInfo& damage)
-{
-    Super::ReceiveDamage(damage);
-
-    if (!physics_)
-        return;
-
-    if (damage.type == DAMAGE_BULLET)
     {
-        // TODO: adjust impulse
+        health_ -= info.impulse;
-        auto impulse = damage.normal * -60.0f;
-        auto& bt_body = physics_->GetBtBody();
-        bt_body.activate();
-        bt_body.applyImpulse(btVector3(impulse.x, impulse.y, impulse.z),
-                             btVector3(damage.impact_pos.x, damage.impact_pos.y, damage.impact_pos.z) -
-                                 bt_body.getCenterOfMassPosition());
 
-        ApplyDamage(damage.damage * 0.2f);
+        if (health_ <= 0.0f) // just broken
-        // Deform(damage.impact_pos, damage.normal * -0.1f, 1.0f);
+        {
+            PlaySound("breakwindow", 1.0f, 1.0f);
+        }
     }
 
+    if (health_ <= 0.0f)
+    {
+        Deform(info.pos, -glm::normalize(info.normal) * 0.1f, 1.0f);
+    }
 }
 
 void game::Vehicle::SetInput(VehicleInputType type, bool enable)
@@ -190,11 +171,7 @@ void game::Vehicle::ProcessInput()
     float steeringClamp = std::max(minsc, (1.f - (std::abs(speed) / sl)) * maxsc);
     // steeringClamp = .5f;
     float steeringSpeed = steeringClamp * 5.0f;
-    if (steering_analog_)
-        steeringSpeed *= 3.0f;
-
     float steeringInc = steeringSpeed * t_delta;
-    float steeringDec = steeringInc * 2.0f;
 
     const bool in_forward = in_ & (1 << VIN_FORWARD);
     const bool in_backward = in_ & (1 << VIN_BACKWARD);
@@ -269,9 +246,23 @@ void game::Vehicle::ProcessInput()
     }
     else
     {
-        auto target_steering_clamped = glm::clamp(target_steering_, -steeringClamp, steeringClamp);
+        if (steering_ < target_steering_)
-        MoveToward(steering_, target_steering_clamped,
+        {
-                   glm::abs(target_steering_clamped) < glm::abs(steering_) ? steeringInc : steeringDec);
+            steering_ += steeringInc;
+            if (steering_ > target_steering_)
+                steering_ = target_steering_;
+        }
+        else if (steering_ > target_steering_)
+        {
+            steering_ -= steeringInc;
+            if (steering_ < target_steering_)
+                steering_ = target_steering_;
+        }
+
+        if (steering_ > steeringClamp)
+            steering_ = steeringClamp;
+        else if (steering_ < -steeringClamp)
+            steering_ = -steeringClamp;
     }
 
     auto& vehicle = physics_->GetBtVehicle();
@@ -361,46 +352,30 @@ void game::Vehicle::UpdateCrash()
     }
     else
     {
-        if (physics_)
+        if (crash_intensity_ > 1000.0f)
         {
-            auto bt_vel = physics_->GetBtBody().getLinearVelocity();
+            float volume = RandomFloat(0.9f, 1.2f);
-            glm::vec3 velocity(bt_vel.x(), bt_vel.y(), bt_vel.z());
+            float pitch = RandomFloat(1.0f, 1.3f);
-            float diff = glm::distance(velocity, prev_velocity_);
-            prev_velocity_ = velocity;
 
-            if (glm::length2(velocity) > 9.0f)
+            if (crash_intensity_ > 12000.0f)
-                diff = 0.0f;
-
-            float snd_crash_intensity = glm::max(diff * 500.0f, crash_intensity_);
-
-            if (snd_crash_intensity > 1000.0f)
             {
-                float volume = RandomFloat(0.9f, 1.2f);
+                volume *= 1.7f;
-                float pitch = RandomFloat(1.0f, 1.3f);
+                pitch *= 0.8f;
-
+            }
-                if (snd_crash_intensity > 12000.0f)
+            if (crash_intensity_ > 4000.0f)
-                {
+            {
-                    volume *= 1.7f;
+                volume *= 1.3f;
-                    pitch *= 0.8f;
+                pitch *= 0.8f;
-                }
+            }
-                if (snd_crash_intensity > 4000.0f)
+            else
-                {
+            {
-                    volume *= 1.3f;
+                volume *= 0.8f;
-                    pitch *= 0.8f;
+                pitch *= 1.2f;
-                }
-                else
-                {
-                    volume *= 0.8f;
-                    pitch *= 1.2f;
-                }
-
-                PlaySound("crash", volume, pitch);
-                no_crash_frames_ = 8 + rand() % 5;
             }
 
+            PlaySound("crash", volume, pitch);
+            no_crash_frames_ = 7 + rand() % 10;
         }
-
-
     }
 
     crash_intensity_ = 0.0f;
@@ -529,20 +504,6 @@ void game::Vehicle::SendUpdateMsg()
     msg.WriteAt(fields_pos, fields);
 }
 
-void game::Vehicle::ApplyDamage(float damage)
-{
-    if (health_ <= 0.0f)
-        return;
-
-    health_ -= damage;
-
-    if (health_ <= 0.0f) // just broken
-    {
-        PlaySound("breakwindow", 1.0f, 1.0f);
-        health_ = 0.0f;
-    }
-}
-
 void game::Vehicle::WriteDeformSync(net::OutMessage& msg) const
 {
     const auto texels = deformgrid_->GetData();
@@ -574,9 +535,6 @@ void game::Vehicle::WriteDeformSync(net::OutMessage& msg) const
 
 void game::Vehicle::Deform(const glm::vec3& pos, const glm::vec3& deform, float radius)
 {
-    if (health_ > 0.0f)
-        return;
-
     net::PositionQ pos_q;
     net::PositionQ deform_q;
     net::EncodePosition(pos, pos_q);
@@ -739,28 +697,9 @@ game::VehiclePhysics::VehiclePhysics(collision::DynamicsWorld& world, Transform&
     }
 
     auto& bt_world = world_.GetBtWorld();
-    bt_world.addRigidBody(body_.get(), collision::OG_DEFAULT, ~collision::OG_PROJECTILE);
+    bt_world.addRigidBody(body_.get(), btBroadphaseProxy::DefaultFilter, btBroadphaseProxy::AllFilter);
     bt_world.addAction(vehicle_.get());
 
-
-    // make bullet hitbox
-    auto col_mesh = model.GetModel()->GetColMesh();
-    if (col_mesh)
-    {
-        bullet_hitbox_ = std::make_unique<btCollisionObject>();
-        bullet_hitbox_->setCollisionShape(col_mesh->GetShape());
-        collision::SetObjectInfo(bullet_hitbox_.get(), collision::OT_ENTITY, 0, &obj_cb);
-    
-        bt_world.addCollisionObject(bullet_hitbox_.get(), collision::OG_DEFAULT, collision::OG_PROJECTILE);
-
-        UpdateBulletHitboxTransform();
-    }
-
-}
-
-void game::VehiclePhysics::Update()
-{
-    UpdateBulletHitboxTransform();
 }
 
 game::VehiclePhysics::~VehiclePhysics()
@@ -768,17 +707,4 @@ game::VehiclePhysics::~VehiclePhysics()
     auto& bt_world = world_.GetBtWorld();
     bt_world.removeRigidBody(body_.get());
     bt_world.removeAction(vehicle_.get());
-
-    if (bullet_hitbox_)
-    {
-        bt_world.removeCollisionObject(bullet_hitbox_.get());
-    }
-}
-
-void game::VehiclePhysics::UpdateBulletHitboxTransform()
-{
-    if (!bullet_hitbox_)
-        return;
-
-    bullet_hitbox_->setWorldTransform(body_->getWorldTransform());
 }

src/game/vehicle.hpp

@@ -41,29 +41,16 @@ public:
 
     DELETE_COPY_MOVE(VehiclePhysics)
 
-    void Update();
-
     btRigidBody& GetBtBody() { return *body_; }
     collision::RaycastVehicle& GetBtVehicle() { return *vehicle_; }
 
     ~VehiclePhysics();
 
-private:
-    void UpdateBulletHitboxTransform();
-
 private:
     collision::DynamicsWorld& world_;
     collision::MotionState motion_;
     std::unique_ptr<btRigidBody> body_;
     std::unique_ptr<collision::RaycastVehicle> vehicle_;
-    std::unique_ptr<btCollisionObject> bullet_hitbox_;
-};
-
-struct VehicleSpawnInfo
-{
-    glm::vec3 position;
-    float yaw;
-    VehicleTuning tuning;
 };
 
 class Vehicle : public Entity
@@ -71,13 +58,12 @@ class Vehicle : public Entity
 public:
     using Super = Entity;
 
-    Vehicle(World& world, const VehicleSpawnInfo& info);
+    Vehicle(World& world, const VehicleTuning& tuning);
 
     virtual void Update() override;
     virtual void SendInitData(Player& player, net::OutMessage& msg) const override;
 
     virtual void OnContact(const collision::ContactInfo& info) override;
-    virtual void ReceiveDamage(const DamageInfo& damage) override;
 
     void SetInput(VehicleInputType type, bool enable);
     void SetInputs(VehicleInputFlags inputs) { in_ = inputs; }
@@ -110,8 +96,6 @@ private:
     VehicleSyncFieldFlags WriteState(net::OutMessage& msg, const VehicleSyncState& base) const;
     void SendUpdateMsg();
 
-    void ApplyDamage(float damage);
-
     void WriteDeformSync(net::OutMessage& msg) const;
     void Deform(const glm::vec3& pos, const glm::vec3& deform, float radius);
     void SendDeformMsg(const net::PositionQ& pos, const net::PositionQ& deform);
@@ -145,11 +129,10 @@ private:
 
     VehicleInputFlags in_ = 0;
 
-    float health_ = 100.0f;
+    float health_ = 10000.0f;
 
     float crash_intensity_ = 0.0f;
     size_t no_crash_frames_ = 0;
-    glm::vec3 prev_velocity_ = glm::vec3(0.0f);
 
     std::unique_ptr<DeformGrid> deformgrid_;
 

src/game/world.cpp

@@ -8,9 +8,6 @@
 #include "destroyed_object.hpp"
 #include "utils/allocnum.hpp"
 #include "player_character.hpp"
-#include "net/utils.hpp"
-#include "marker.hpp"
-#include "utils/math.hpp"
 
 game::World::World(std::string mapname) : Scheduler(time_ms_), map_(*this, std::move(mapname)) {}
 
@@ -71,7 +68,6 @@ void game::World::Update(int64_t delta_time)
 void game::World::FinishFrame()
 {
     ResetMsg();
-    ResetLocalMsgs();
 
     // reset ent msgs
     for (auto& [entnum, ent] : ents_)
@@ -175,226 +171,6 @@ const game::UseTarget* game::World::GetBestUseTarget(game::PlayerCharacter& char
     return cb.best_target;
 }
 
-bool game::World::TraceBullet(const glm::vec3& start, const glm::vec3& end, game::HumanCharacter* shooter,
-                              glm::vec3& out_hit_pos)
-{
-    return TraceBulletInternal(start, end, shooter, out_hit_pos) != nullptr;
-}
-
-static uint32_t GetMaterialColor(collision::Material material)
-{
-    switch (material)
-    {
-    case collision::PM_STONE:
-        return 0xFFFFFF;
-    case collision::PM_DIRT:
-        return 0x224488;
-    case collision::PM_GRASS:
-        return 0x00FF00;
-    case collision::PM_WOOD:
-        return 0x0000FF;
-    case collision::PM_METAL:
-        return 0x0077FF;
-    case collision::PM_GLASS:
-        return 0xFF7700;
-    case collision::PM_FLESH:
-        return 0xFF00FF;
-    default:
-        return 0xFFFFFF;
-    }
-}
-
-static std::string GetMaterialImpactFx(collision::Material material)
-{
-    switch (material)
-    {
-    case collision::PM_STONE:
-        return "impact_stone";
-    case collision::PM_DIRT:
-        return "impact_dirt";
-    case collision::PM_GRASS:
-        return "impact_grass";
-    case collision::PM_WOOD:
-        return "impact_wood";
-    case collision::PM_METAL:
-        return "impact_metal";
-    case collision::PM_GLASS:
-        return "impact_glass";
-    case collision::PM_FLESH:
-        return "impact_flesh";
-    default:
-        return "impact_stone";
-    }
-}
-
-void game::World::FireBullet(const BulletInfo& bullet)
-{
-    glm::vec3 hit_pos, hit_normal;
-    collision::Material material;
-    auto hit_obj = TraceBulletInternal(bullet.start, bullet.end, bullet.shooter, hit_pos, &hit_normal, &material);
-    if (!hit_obj)
-    {
-        // Beam(bullet.start, bullet.end, 0x0044DD, 0.04f);
-        return;
-    }
-    
-    hit_normal = glm::normalize(hit_normal);
-
-    auto obj_cb = collision::GetObjectCallback(hit_obj);
-    if (obj_cb)
-    {
-        // apply damage
-        DamageInfo damage;
-        damage.type = DAMAGE_BULLET;
-        damage.damage = bullet.damage;
-        damage.from_pos = bullet.start;
-        damage.impact_pos = hit_pos;
-        damage.inflictor = bullet.shooter;
-        damage.hit_object = hit_obj;
-        damage.normal = hit_normal;
-        obj_cb->ReceiveDamage(damage);
-    }
-
-    // TODO: remove
-    // const float box_extent = 0.1f;
-    // BeamBox(hit_pos - box_extent, hit_pos + box_extent, GetMaterialColor(material), 1.0f);
-    
-    // Beam(bullet.start, hit_pos, 0x0044DD, 0.04f);
-
-    // effect
-    Effect(GetMaterialImpactFx(material), hit_pos, hit_normal);
-}
-
-void game::World::Beam(const glm::vec3& start, const glm::vec3& end, uint32_t color, float time)
-{
-    auto msg = BeginLocalMsg(start, 500.0f, net::MSG_BEAM);
-    net::WritePosition(msg, start);
-    net::WritePosition(msg, end);
-    net::WriteRGB(msg, color);
-    msg.Write<net::BeamTimeQ>(time);
-}
-
-void game::World::BeamBox(const glm::vec3& min, const glm::vec3& max, uint32_t color, float time)
-{
-    const glm::vec3& p0 = min;
-    const glm::vec3 p1(max.x, min.y, min.z);
-    const glm::vec3 p2(max.x, max.y, min.z);
-    const glm::vec3 p3(min.x, max.y, min.z);
-    const glm::vec3 p4(min.x, min.y, max.z);
-    const glm::vec3 p5(max.x, min.y, max.z);
-    const glm::vec3& p6 = max;
-    const glm::vec3 p7(min.x, max.y, max.z);
-
-    Beam(p0, p1, color, time);
-    Beam(p1, p2, color, time);
-    Beam(p2, p3, color, time);
-    Beam(p3, p0, color, time);
-
-    Beam(p4, p5, color, time);
-    Beam(p5, p6, color, time);
-    Beam(p6, p7, color, time);
-    Beam(p7, p4, color, time);
-
-    Beam(p0, p4, color, time);
-    Beam(p1, p5, color, time);
-    Beam(p2, p6, color, time);
-    Beam(p3, p7, color, time);
-}
-
-void game::World::Effect(const std::string& name, const glm::vec3& pos, const glm::vec3& dir)
-{
-    auto msg = BeginLocalMsg(pos, 400.0f, net::MSG_FX);
-    msg.Write(net::ModelName(name));
-    net::WritePosition(msg, pos);
-    msg.Write<net::DirQ>(dir.x);
-    msg.Write<net::DirQ>(dir.y);
-    msg.Write<net::DirQ>(dir.z);
-}
-
-void game::World::SendChat(const std::string& text)
-{
-    auto msg = BeginMsg(net::MSG_CHAT);
-    msg.Write(net::ChatMessage(text));
-}
-
-void game::World::CreateItemPickup(const glm::vec3& position, std::shared_ptr<ItemInstance> item, int64_t despawn_time,
-                                   int64_t respawn_time, size_t ammo_count)
-{
-    MarkerInfo marker_info{};
-    marker_info.position = position;
-    marker_info.type = MARKER_PICKUP;
-    marker_info.color = 0xFFFFFF;
-    marker_info.model = item->def->model_name;
-
-    auto& marker = Spawn<Marker>(marker_info);
-    marker.SetUseTarget(
-        "sebrat ^ccc" + item->def->displayname,
-        [](PlayerCharacter& character, UseTargetQueryResult& res) {
-            res.enabled = true;
-            res.delay = 0.1f;
-            res.error_text = nullptr;
-            return true;
-        },
-        [this, position, item, despawn_time, respawn_time, ammo_count, &marker](PlayerCharacter& character) {
-            auto player = character.GetPlayer();
-            if (!player)
-                return;
-
-            character.GiveItem(item);
-
-            if (ammo_count > 0)
-            {
-                character.GiveAmmo(item->def->ammo_type, ammo_count);
-            }
-
-            character.PlaySound("pickup_ammo");
-
-            player->SendChat("sebrals ^ccc" + item->def->displayname);
-            marker.SetUseable(false);
-            marker.Remove();
-
-            if (respawn_time > 0)
-            {
-                Schedule(respawn_time, [this, position, item, despawn_time, respawn_time, ammo_count]() {
-                    CreateItemPickup(position, item, despawn_time, respawn_time, ammo_count);
-                });
-            }
-        });
-
-    if (despawn_time > 0)
-    {
-        marker.Schedule(despawn_time, [&marker]{
-            marker.Remove();
-        });
-    }
-}
-
-static void ApplyCrashDamage(collision::ObjectCallback& obj_cb, collision::ObjectCallback* other_obj_cb, float impulse, const glm::vec3& normal, const glm::vec3& velocity)
-{
-    if (glm::length(impulse) < 1000.0f)
-        return;
-
-    if (normal.z < -0.707f)
-        return;
-
-    // float velocity_magnitude = glm::length(velocity);
-    float dmg = glm::mix(10.0f, 100.0f, impulse * 0.0001f);
-
-    // if (dmg < 10.0f)
-    //     return;
-
-    game::DamageInfo damage{};
-    damage.type = game::DAMAGE_CRASH;
-    damage.impulse = impulse;
-    damage.inflictor = other_obj_cb ? other_obj_cb->GetResponsibleCharacter() : nullptr;
-    damage.damage = dmg;
-
-    if (damage.inflictor)
-    {
-        obj_cb.ReceiveDamage(damage);
-    }
-}
-
 void game::World::HandleContacts()
 {
     auto& bt_world = GetBtWorld();
@@ -413,22 +189,12 @@ void game::World::HandleContacts()
 
         if (cb && (flags & collision::OF_NOTIFY_CONTACT))
         {
-            
             collision::ContactInfo info;
             info.pos = glm::vec3(pos.x(), pos.y(), pos.z());
             info.normal = glm::vec3(normal.x(), normal.y(), normal.z());
             info.impulse = impulse;
-            // info.other_velocity = glm::vec3(ov.x(), ov.y(), ov.z());
             cb->OnContact(info);
         }
-        
-        if (cb && (flags & collision::OF_CRASH_DAMAGE))
-        {
-            auto ov = other_body->getLinearVelocity();
-            auto other_obj_cb = collision::GetObjectCallback(other_body);
-            ApplyCrashDamage(*cb, other_obj_cb, impulse, glm::normalize(glm::vec3(normal.x(), normal.y(), normal.z())),
-                             glm::vec3(ov.x(), ov.y(), ov.z()));
-        }
 
         if (type == collision::OT_MAP_OBJECT && (flags & collision::OF_DESTRUCTIBLE))
         {
@@ -503,120 +269,3 @@ void game::World::SendObjRespawnedMsg(net::ObjNum objnum)
     auto msg = BeginMsg(net::MSG_OBJRESPAWN);
     msg.Write(objnum);
 }
-
-static bool IsMeOrMyRideOrOtherPassengerOfMyRide(const game::HumanCharacter* me, const btCollisionObject* obj)
-{
-    if (!me) // i am not
-        return false;
-
-    // is me?
-    auto obj_cb = collision::GetObjectCallback(obj);
-    if (!obj_cb)
-        return false; // is nothing
-
-    if (obj_cb == me)
-        return true; // its me
-
-    auto my_ride = me->GetRideable();
-    if (!my_ride)
-        return false; // im not riding anything
-
-    // is my ride?
-    if (&my_ride->GetEntity() == obj_cb)
-        return true; // yes
-
-    // is other passenger?
-    auto character = dynamic_cast<game::HumanCharacter*>(obj_cb);
-    if (!character)
-        return false; // is not even human
-
-    return character->GetRideable() == my_ride;
-}
-
-struct NotMeNotMyRideAndNotOtherPassengersOfMyRideClosestRayResultCallback : public btCollisionWorld::ClosestRayResultCallback
-{
-    using Super = ClosestRayResultCallback;
-
-    NotMeNotMyRideAndNotOtherPassengersOfMyRideClosestRayResultCallback(const btVector3& rayFromWorld,
-                                                                        const btVector3& rayToWorld)
-        : ClosestRayResultCallback(rayFromWorld, rayToWorld)
-    {
-    }
-
-    game::HumanCharacter* me = nullptr;
-    int triangle_idx = 0;
-
-    virtual btScalar addSingleResult(btCollisionWorld::LocalRayResult& rayResult, bool normalInWorldSpace) override
-    {
-        if (IsMeOrMyRideOrOtherPassengerOfMyRide(me, rayResult.m_collisionObject))
-            return rayResult.m_hitFraction;
-        
-        triangle_idx = rayResult.m_localShapeInfo ? rayResult.m_localShapeInfo->m_triangleIndex : -1;
-
-        return Super::addSingleResult(rayResult, normalInWorldSpace);
-    }
-};
-
-const btCollisionObject* game::World::TraceBulletInternal(const glm::vec3& start, const glm::vec3& end,
-                                                          game::HumanCharacter* shooter, glm::vec3& out_hit_pos,
-                                                          glm::vec3* out_hit_normal,
-                                                          collision::Material* out_hit_material)
-{
-    btVector3 bt_start(start.x, start.y, start.z);
-    btVector3 bt_end(end.x, end.y, end.z);
-
-    // find hitbone targets first
-    btCollisionWorld::AllHitsRayResultCallback hitbone_cb(bt_start, bt_end);
-    hitbone_cb.m_collisionFilterGroup = collision::OG_PROJECTILE;
-    hitbone_cb.m_collisionFilterMask = collision::OG_HITBONES_PROXY;
-    GetBtWorld().rayTest(bt_start, bt_end, hitbone_cb);
-
-    for (size_t i = 0; i < hitbone_cb.m_collisionObjects.size(); ++i)
-    {
-        auto col_obj = hitbone_cb.m_collisionObjects[i];
-        auto obj_cb = collision::GetObjectCallback(col_obj);
-        if (!obj_cb)
-            continue;
-
-        obj_cb->ActivateHitBones();
-    }
-
-    NotMeNotMyRideAndNotOtherPassengersOfMyRideClosestRayResultCallback cb(bt_start, bt_end);
-    cb.m_collisionFilterGroup = collision::OG_PROJECTILE;
-    cb.m_collisionFilterMask = ~collision::OG_HITBONES_PROXY;
-    cb.me = shooter;
-    GetBtWorld().rayTest(bt_start, bt_end, cb);
-
-    if (!cb.hasHit())
-        return nullptr;
-
-    out_hit_pos = glm::vec3(cb.m_hitPointWorld.x(), cb.m_hitPointWorld.y(), cb.m_hitPointWorld.z());
-    
-    if (out_hit_normal)
-    {
-        *out_hit_normal = glm::vec3(cb.m_hitNormalWorld.x(), cb.m_hitNormalWorld.y(), cb.m_hitNormalWorld.z());
-    }
-
-    // get material
-    if (out_hit_material)
-    {
-        *out_hit_material = collision::PM_STONE;
-        auto shape = cb.m_collisionObject->getCollisionShape();
-        if (shape)
-        {
-            *out_hit_material = collision::GetShapeMaterial(*shape);
-
-            // try to get triangle material
-            if (cb.triangle_idx >= 0)
-            {
-                auto shape_info = collision::GetShapeInfo(*shape);
-                if (shape_info && shape_info->triangle_materials.size() > cb.triangle_idx)
-                {
-                    *out_hit_material = shape_info->triangle_materials[cb.triangle_idx];
-                }
-            }
-        }
-    }
-
-    return cb.m_collisionObject;
-}

src/game/world.hpp

@@ -9,42 +9,11 @@
 #include "net/defs.hpp"
 #include "player_input.hpp"
 #include "usable.hpp"
-#include "item_instance.hpp"
 
 namespace game
 {
 
-enum DamageType
+class World : public collision::DynamicsWorld, public net::MsgProducer, public Scheduler
-{
-    DAMAGE_OTHER,
-    DAMAGE_BULLET,
-    DAMAGE_CRASH,
-};
-
-class HumanCharacter;
-
-struct DamageInfo
-{
-    DamageType type = DAMAGE_OTHER;
-    float damage = 0.0f;
-    float impulse = 0.0f;
-    glm::vec3 from_pos{};
-    glm::vec3 impact_pos{};
-    glm::vec3 normal{};
-    HumanCharacter* inflictor = nullptr;
-    const btCollisionObject* hit_object = nullptr;
-};
-
-struct BulletInfo
-{
-    HumanCharacter* shooter;
-    glm::vec3 start;
-    glm::vec3 end;
-    float damage;
-    float impulse;
-};
-
-class World : public collision::DynamicsWorld, public net::MsgProducer, public net::LocalMsgProducer, public Scheduler
 {
 public:
     World(std::string mapname);
@@ -83,19 +52,6 @@ public:
     float GetDayTime() const { return daytime_; }
     void SetDayTime(float daytime) { daytime_ = glm::mod(daytime, 24.0f); }
 
-    bool TraceBullet(const glm::vec3& start, const glm::vec3& end, game::HumanCharacter* shooter, glm::vec3& out_hit_pos);
-    void FireBullet(const BulletInfo& bullet);
-
-    void Beam(const glm::vec3& start, const glm::vec3& end, uint32_t color, float time);
-    void BeamBox(const glm::vec3& min, const glm::vec3& max, uint32_t color, float time);
-
-    void Effect(const std::string& name, const glm::vec3& pos, const glm::vec3& dir);
-
-    void SendChat(const std::string& text);
-
-    void CreateItemPickup(const glm::vec3& position, std::shared_ptr<ItemInstance> item, int64_t despawn_time,
-                          int64_t respawn_time, size_t ammo_count);
-
     virtual ~World() = default;
 
 private:
@@ -106,11 +62,6 @@ private:
     void SendObjDestroyedMsg(net::ObjNum objnum);
     void SendObjRespawnedMsg(net::ObjNum objnum);
 
-    const btCollisionObject* TraceBulletInternal(const glm::vec3& start, const glm::vec3& end,
-                                                 game::HumanCharacter* shooter, glm::vec3& out_hit_pos,
-                                                 glm::vec3* out_hit_normal = nullptr,
-                                                 collision::Material* out_hit_material = nullptr);
-
 private:
     MapInstance map_;
     std::set<net::ObjNum> destroyed_objs_;

src/gameview/characterview.cpp

@@ -34,13 +34,6 @@ game::view::CharacterView::CharacterView(WorldView& world, net::InMessage& msg)
 
     UpdateSurfaceMask();
 
-    // read item
-    net::ModelName item_name;
-    if (!msg.Read(item_name))
-        throw EntityInitError();
-
-    SetItem(item_name);
-
     // read initial state
     if (!ReadState(&msg))
         throw EntityInitError();
@@ -54,10 +47,6 @@ bool game::view::CharacterView::ProcessMsg(net::EntMsgType type, net::InMessage&
 {
     switch (type)
     {
-    case net::EMSG_EQUIP:
-        return ProcessEquipMsg(msg);
-    case net::EMSG_FIRE:
-        return ProcessFireMsg(msg);
     default:
         return Super::ProcessMsg(type, msg);
     }
@@ -74,45 +63,23 @@ void game::view::CharacterView::Update(const UpdateInfo& info)
 
     // interpolate states
     float tps = 25.0f;
-    float t = (info.time - update_time_) * tps * 0.8f; // assume some jitter, interpolate for longer;
+    float t = (info.time - update_time_) * tps * 0.8f; // assume some jitter, interpolate for longer
     t = glm::clamp(t, 0.0f, 2.0f);
-    float t_sane = glm::clamp(t, 0.0f, 1.0f);
 
     root_.local = Transform::Lerp(states_[0].trans, states_[1].trans, t);
-
-    // loco
     animstate_.loco_blend = glm::mix(states_[0].loco_blend, states_[1].loco_blend, t);
-           
+
     float loco_phase0 = states_[0].loco_phase;
     float loco_phase1 = states_[1].loco_phase;
-
+    if (loco_phase0 > loco_phase1)
-    // interpolate across 0-1 wrap using the shortest direction
+        loco_phase0 -= 1.0f;
-    // compute signed shortest delta in range [-0.5,0.5)
+    animstate_.loco_phase = glm::mod(glm::mix(loco_phase0, loco_phase1, t), 1.0f);
-    float delta = glm::mod(loco_phase1 - loco_phase0 + 0.5f, 1.0f) - 0.5f;
-    float interp = loco_phase0 + delta * t;
-    animstate_.loco_phase = glm::mod(interp, 1.0f);
-
-    // action
-    animstate_.action_time = glm::mix(states_[0].action_time, states_[1].action_time, t_sane);
-    // if (animstate_.action_anim_idx != assets::NO_ANIM)
-    // {
-    //     std::cout <<"phase: " << animstate_.action_phase << std::endl;
-    // }
-
-    // aim
-    animstate_.yaw = glm::mix(states_[0].aim_yaw, states_[1].aim_yaw, t_sane);
-    animstate_.pitch = glm::mix(states_[0].aim_pitch, states_[1].aim_pitch, t_sane);
 
     animstate_.ApplyToSkeleton(sk_);
 
     root_.UpdateMatrix();
     sk_.UpdateBoneMatrices();
     ubo_valid_ = false;
-
-    if (item_)
-    {
-        item_node_.UpdateMatrix();
-    }
 }
 
 void game::view::CharacterView::Draw(const DrawArgs& args)
@@ -128,17 +95,17 @@ void game::view::CharacterView::Draw(const DrawArgs& args)
     //args.dlist.AddBeam(start, end, 0xFF007700, 0.05f);
 
     //// draw bones debug
-    // const auto& bone_nodes = sk_.GetBoneNodes();
+    const auto& bone_nodes = sk_.GetBoneNodes();
-    // for (const auto& bone_node : bone_nodes)
+    for (const auto& bone_node : bone_nodes)
-    // {
+    {
-    //     if (!bone_node.parent)
+        if (!bone_node.parent)
-    //         continue;
+            continue;
 
-    //    glm::vec3 p0 = bone_node.parent->matrix[3];
+       glm::vec3 p0 = bone_node.parent->matrix[3];
-    //    glm::vec3 p1 = bone_node.matrix[3];
+       glm::vec3 p1 = bone_node.matrix[3];
 
-    //    args.dlist.AddBeam(p0, p1, 0xFF00EEEE, 0.01f);
+       args.dlist.AddBeam(p0, p1, 0xFF00EEEE, 0.01f);
-    // }
+    }
 
     // update skinning matrices
     if (!ubo_valid_)
@@ -175,8 +142,6 @@ void game::view::CharacterView::Draw(const DrawArgs& args)
         cmd.skinning = &ubo_;
         args.dlist.AddSurface(cmd);
     }
-
-    DrawItem(args);
 }
 
 void game::view::CharacterView::OnAttach()
@@ -192,17 +157,13 @@ void game::view::CharacterView::OnAttach()
 bool game::view::CharacterView::ReadState(net::InMessage* msg)
 {
     update_time_ = world_.GetTime();
-    
-    auto& old_state = states_[0];
-    auto& new_state = states_[1];
 
     // init lerp start state
-    old_state.trans = root_.local;
+    states_[0].trans = root_.local;
-    old_state.loco_blend = animstate_.loco_blend;
+    states_[0].loco_blend = animstate_.loco_blend;
-    old_state.loco_phase = animstate_.loco_phase;
+    states_[0].loco_phase = animstate_.loco_phase;
-    old_state.action_time = animstate_.action_time;
+
-    old_state.aim_yaw = animstate_.yaw;
+    auto& new_state = states_[1];
-    old_state.aim_pitch = animstate_.pitch;
 
     if (msg)
     {
@@ -248,42 +209,6 @@ bool game::view::CharacterView::ReadState(net::InMessage* msg)
             new_state.loco_blend = sync_.loco_blend.Decode();
             new_state.loco_phase = sync_.loco_phase.Decode();
         }
-
-        // action anim
-        if (fields & CSF_ACTION_ANIM)
-        {
-            if (!msg->Read(sync_.action_anim))
-                return false;
-
-            animstate_.action_anim_idx = sync_.action_anim;
-        }
-
-        // action time
-        if (fields & CSF_ACTION_TIME)
-        {
-            if (!net::ReadDelta(*msg, sync_.action_time))
-                return false;
-
-            new_state.action_time = sync_.action_time.Decode();
-
-            if (fields & CSF_ACTION_ANIM)
-            {
-                // anim just changed, dont blend time
-                old_state.action_time = new_state.action_time;
-                animstate_.action_time = new_state.action_time;
-            }
-        }
-
-        // aim
-        if (fields & CSF_AIM)
-        {
-            if (!net::ReadDelta(*msg, sync_.aim_yaw) || !net::ReadDelta(*msg, sync_.aim_pitch))
-                return false; 
-
-            new_state.aim_yaw = sync_.aim_yaw.Decode();
-            new_state.aim_pitch = sync_.aim_pitch.Decode();
-        }
-
     }
 
     return true;
@@ -333,94 +258,3 @@ void game::view::CharacterView::AddClothes(const std::string& name, const glm::v
 
     clothes_.emplace_back(std::move(c));
 }
-
-bool game::view::CharacterView::ProcessEquipMsg(net::InMessage& msg)
-{
-    net::ModelName item_name;
-    if (!msg.Read(item_name))
-        return false;
-
-    SetItem(item_name);
-
-    return true;
-}
-
-bool game::view::CharacterView::ProcessFireMsg(net::InMessage& msg)
-{
-    FireItem();
-    return true;
-}
-
-void game::view::CharacterView::SetItem(const std::string& item_name)
-{
-    if (item_name == item_name_)
-        return;
-
-    item_name_ = item_name;
-
-    fire_snd_.reset();
-    fire_fx_.reset();
-
-    if (item_name.empty())
-    {
-        item_.reset();
-        return;
-    }
-
-    item_ = assets::CacheManager::GetItem("data/" + item_name + ".item");
-
-    auto bone_node = sk_.GetBoneNodeByName(item_->bone);
-    item_node_.parent = bone_node ? bone_node : &root_;
-    item_node_.local = item_->bone_offset;
-
-    // snd
-    if (!item_->fire_snd.empty())
-    {
-        fire_snd_ = assets::CacheManager::GetSound("data/" + item_->fire_snd + ".snd");
-    }
-
-    // fx
-    if (!item_->fire_fx.empty())
-    {
-        fire_fx_ = assets::CacheManager::GetEffect("data/" + item_->fire_fx + ".fx");
-        auto loc = item_->model->GetLocation(item_->fire_fx_loc);
-        fire_fx_offset_ = loc ? loc->position : glm::vec3(0.0f);
-    }
-
-}
-
-void game::view::CharacterView::DrawItem(const DrawArgs& args)
-{
-    if (!item_ || !item_->model)
-        return;
-
-    const auto& mesh = *item_->model->GetMesh();
-    for (const auto& surface : mesh.surfaces)
-    {
-        gfx::DrawSurfaceCmd cmd;
-        cmd.surface = &surface;
-        cmd.matrices = &item_node_.matrix;
-        args.dlist.AddSurface(cmd);
-    }
-}
-
-void game::view::CharacterView::FireItem()
-{
-    if (!item_)
-        return;
-
-    if (fire_snd_)
-    {
-        auto snd = audioplayer_.PlaySound(fire_snd_, &item_node_);
-        // snd->SetPosition(item_node_.GetGlobalPosition());
-    }
-
-    if (fire_fx_)
-    {
-        glm::vec3 pos = item_node_.matrix * glm::vec4(fire_fx_offset_, 1.0f);
-        glm::vec3 dir = item_node_.matrix * glm::vec4(0.0f, 1.0f, 0.0f, 0.0f);
-        world_.GetEmitter().Emit(fire_fx_, pos, glm::normalize(dir));
-    }
-
-
-}

src/gameview/characterview.hpp

@@ -2,8 +2,6 @@
 
 #include "entityview.hpp"
 #include "assets/model.hpp"
-#include "assets/item.hpp"
-#include "assets/effect.hpp"
 #include "game/skeletoninstance.hpp"
 #include "skinning_ubo.hpp"
 #include "game/character_anim_state.hpp"
@@ -15,14 +13,8 @@ namespace game::view
 struct CharacterViewState
 {
     Transform trans;
-    
     float loco_blend = 0.0f;
     float loco_phase = 0.0f;
-    
-    float action_time = 0.0f;
-
-    float aim_yaw = 0.0f;
-    float aim_pitch = 0.0f; 
 };
 
 struct CharacterViewClothes
@@ -57,13 +49,6 @@ private:
 
     void AddClothes(const std::string& name, const glm::vec3& color);
 
-    bool ProcessEquipMsg(net::InMessage& msg);
-    bool ProcessFireMsg(net::InMessage& msg);
-
-    void SetItem(const std::string& item_name);
-    void DrawItem(const DrawArgs& args);
-    void FireItem();
-
 private:
     float yaw_ = 0.0f;
 
@@ -81,13 +66,6 @@ private:
     CharacterSyncState sync_;
     CharacterViewState states_[2];
     float update_time_ = 0.0f;
-
-    std::string item_name_;
-    TransformNode item_node_;
-    std::shared_ptr<const assets::Item> item_;
-    std::shared_ptr<const audio::Sound> fire_snd_;
-    std::shared_ptr<const assets::Effect> fire_fx_;
-    glm::vec3 fire_fx_offset_{};
 };
 
 }

src/gameview/client_session.cpp

@@ -7,10 +7,8 @@
 #include "utils/version.hpp"
 #include "utils.hpp"
 #include "vehicleview.hpp"
-#include "assets/cache.hpp"
-#include "game/player_hud_data.hpp"
 
-game::view::ClientSession::ClientSession(App& app) : app_(app), hud_(app.GetTime())
+game::view::ClientSession::ClientSession(App& app) : app_(app), use_target_hud_(app.GetTime())
 {
     // send login
     auto msg = BeginMsg(net::MSG_ID);
@@ -49,12 +47,6 @@ bool game::view::ClientSession::ProcessSingleMessage(net::MessageType type, net:
     case net::MSG_CHAT:
         return ProcessChatMsg(msg);
 
-    case net::MSG_HUD:
-        return ProcessHudMsg(msg);
-
-    case net::MSG_DAMAGE:
-        return ProcessDamageMsg(msg);
-
     case net::MSG_USETARGET:
         return ProcessUseTargetMsg(msg);
 
@@ -83,14 +75,18 @@ void game::view::ClientSession::Input(game::PlayerInputType in, bool pressed, bo
 
 void game::view::ClientSession::ProcessMouseMove(float delta_yaw, float delta_pitch)
 {
-    auto sens_mult = glm::mix(1.0f, 0.3f, camera_controller_.GetAimFactor());
+    yaw_ = glm::mod(yaw_ + delta_yaw, glm::two_pi<float>());
 
-    float yaw = glm::mod(camera_controller_.GetYaw() + delta_yaw * sens_mult, glm::two_pi<float>());
+    pitch_ += delta_pitch;
-
+    // Clamp pitch to avoid gimbal lock
-    float pitch = camera_controller_.GetPitch() + delta_pitch * sens_mult;
+    if (pitch_ > glm::radians(89.0f))
-    pitch = glm::clamp(pitch, glm::radians(-89.0f), glm::radians(89.0f)); // Clamp pitch to avoid gimbal lock
+    {
-    
+        pitch_ = glm::radians(89.0f);
-    camera_controller_.SetViewAngles(yaw, pitch);
+    }
+    else if (pitch_ < glm::radians(-89.0f))
+    {
+        pitch_ = glm::radians(-89.0f);
+    }
 }
 
 void game::view::ClientSession::Update(const UpdateInfo& info)
@@ -99,10 +95,7 @@ void game::view::ClientSession::Update(const UpdateInfo& info)
     {
         world_->Update(info);
         SendViewAngles(info.time);
-        UpdateCamera(info);
     }
-
-    hud_.Update(info.delta_time);
 }
 
 void game::view::ClientSession::Draw(gfx::DrawList& dlist, gfx::DrawListParams& params, gui::Context& gui)
@@ -110,14 +103,41 @@ void game::view::ClientSession::Draw(gfx::DrawList& dlist, gfx::DrawListParams&
     if (world_)
     {
         DrawWorld(dlist, params, gui);
+    }
 
-        if (world_->IsLoaded())
+    use_target_hud_.Draw(gui);
+
+    DrawMenus(gui);
+}
+
+void game::view::ClientSession::GetViewInfo(glm::vec3& eye, glm::mat4& view) const
+{
+    glm::vec3 start(0.0f, 0.0f, 2.0f);
+    float distance = 5.0f;
+
+    if (follow_ent_)
+    {
+        auto ent = world_->GetEntity(follow_ent_);
+        if (ent)
         {
-            hud_.Draw(gui);
+            start += ent->GetRoot().GetGlobalPosition();
+
+            if (dynamic_cast<const VehicleView*>(ent))
+                distance = 8.0f;
         }
     }
 
-    DrawMenus(gui);
+    float yaw_cos = glm::cos(yaw_);
+    float yaw_sin = glm::sin(yaw_);
+    float pitch_cos = glm::cos(pitch_);
+    float pitch_sin = glm::sin(pitch_);
+    glm::vec3 dir(-yaw_sin * pitch_cos, yaw_cos * pitch_cos, pitch_sin);
+
+    glm::vec3 end = start - dir * distance;
+
+    // start.z -= 0.5f; // shift this a bit to make it better when occluded
+    eye = world_->CameraSweep(start, end);
+    view = glm::lookAt(eye, eye + dir, glm::vec3(0, 0, 1));
 }
 
 audio::Master& game::view::ClientSession::GetAudioMaster() const
@@ -141,7 +161,7 @@ bool game::view::ClientSession::ProcessWorldMsg(net::InMessage& msg)
 
 bool game::view::ClientSession::ProcessCameraMsg(net::InMessage& msg)
 {
-    if (!msg.Read(camera_info_.character_entnum) || !msg.Read(camera_info_.rideable_entnum) || !msg.Read(camera_info_.flags))
+    if (!msg.Read(follow_ent_))
         return false;
 
     return true;
@@ -157,98 +177,6 @@ bool game::view::ClientSession::ProcessChatMsg(net::InMessage& msg)
     return true;
 }
 
-bool game::view::ClientSession::ProcessHudMsg(net::InMessage& msg)
-{
-    PlayerHudFields fields{};
-    if (!msg.Read(fields))
-        return false;
-
-    PlayerHudData hud_data{};
-
-    if (fields & PHUD_HEALTH)
-    {
-        if (!msg.Read(hud_data.health))
-            return false;
-
-        hud_.SetHealth(static_cast<float>(hud_data.health));
-    }
-
-    if (fields & PHUD_WEAPON_SLOTS)
-    {
-        if (!msg.Read(hud_data.weapon_slots))
-            return false;
-        
-        hud_.SetWeaponSlots(hud_data.weapon_slots);
-    }
-
-    if (fields & PHUD_ITEM)
-    {
-        net::ModelName item_name;
-        if (!msg.Read(item_name))
-            return false;
-
-        hud_data.held_item = item_name;
-
-        // determine clip size
-        std::string displayname = hud_data.held_item;
-        size_t clip_size = 0;
-        size_t item_slot = 0;
-        if (!hud_data.held_item.empty())
-        {
-            auto item = assets::CacheManager::GetItem("data/" + hud_data.held_item + ".item");
-            displayname = item->displayname;
-            clip_size = item->clip_size;
-            item_slot = item->slot;
-        }
-
-        hud_.SetItemInfo(displayname, item_slot, clip_size);
-    }
-
-    if (fields & PHUD_AMMO_LOADED)
-    {
-        if (!msg.Read(hud_data.ammo_loaded))
-            return false;
-
-        hud_.SetLoadedAmmo(static_cast<size_t>(hud_data.ammo_loaded));
-    }
-
-    if (fields & PHUD_AMMO_TOTAL)
-    {
-        if (!msg.Read(hud_data.ammo_total))
-            return false;
-
-        hud_.SetTotalAmmo(static_cast<size_t>(hud_data.ammo_total));
-    }
-
-    if (fields & PHUD_DEATH)
-    {
-        if (!msg.Read(hud_data.dead))
-            return false;
-
-        hud_.SetDead(hud_data.dead > 0);
-    }
-
-    return true;
-}
-
-bool game::view::ClientSession::ProcessDamageMsg(net::InMessage& msg)
-{
-    DamageEventType type;
-    if (!msg.Read(type))
-        return false;
-
-    if (type == DAMAGE_EVENT_RECEIVED)
-    {
-        hud_.ShowDamageReceived();
-    }
-    else
-    {
-        hud_.ShowDamageDealt(type == DAMAGE_EVENT_DEALT_KILL);
-    }
-
-    return true;
-}
-
 bool game::view::ClientSession::ProcessUseTargetMsg(net::InMessage& msg)
 {
     net::UseTargetName text, error_text;
@@ -257,7 +185,7 @@ bool game::view::ClientSession::ProcessUseTargetMsg(net::InMessage& msg)
     if (!msg.Read(text) || !msg.Read(error_text) || !msg.Read<net::UseDelayQ>(delay))
         return false;
 
-    hud_.SetUseTargetData(text, error_text, delay);
+    use_target_hud_.SetData(text, error_text, delay);
     return true;
 }
 
@@ -294,21 +222,6 @@ bool game::view::ClientSession::ProcessMenuMsg(net::InMessage& msg)
     }
 }
 
-void game::view::ClientSession::UpdateCamera(const UpdateInfo& info)
-{
-    auto character = world_->GetEntity(camera_info_.character_entnum);
-    camera_controller_.SetCharacterTransform(character ? &character->GetRoot().matrix : nullptr);
-    
-    auto rideable = world_->GetEntity(camera_info_.rideable_entnum);
-    camera_controller_.SetRideableTransform(rideable ? &rideable->GetRoot().matrix : nullptr);
-    
-    camera_controller_.SetAiming(camera_info_.flags & CAM_AIMING);
-    camera_controller_.Update(info.delta_time);
-    camera_controller_.Recalculate(world_.get());
-
-    hud_.SetDisplayCrosshair(camera_controller_.GetAimFactor() >= 0.5f);
-}
-
 void game::view::ClientSession::DrawWorld(gfx::DrawList& dlist, gfx::DrawListParams& params, gui::Context& gui)
 {
     // glm::mat4 view = glm::lookAt(glm::vec3(15.0f, 0.0f, 1.0f), glm::vec3(0.0f, 0.0f, -13.0f), glm::vec3(0.0f,
@@ -318,14 +231,16 @@ void game::view::ClientSession::DrawWorld(gfx::DrawList& dlist, gfx::DrawListPar
     const float farplane = 3000.0f;
 
     glm::mat4 proj = glm::perspective(glm::radians(45.0f), aspect, 0.1f, farplane);
-    glm::mat4 view = camera_controller_.GetViewMatrix();
+    glm::vec3 eye;
+    glm::mat4 view;
+    GetViewInfo(eye, view);
 
     params.view_proj = proj * view;
-    params.cam_pos = camera_controller_.GetEye();
+    params.cam_pos = eye;
 
     // glm::mat4 fake_view_proj = glm::perspective(glm::radians(30.0f), aspect, 0.1f, 3000.0f) * view;
 
-    game::view::DrawArgs draw_args(dlist, params.env, gui, params.view_proj, params.cam_pos,
+    game::view::DrawArgs draw_args(dlist, params.env, gui, params.view_proj, eye,
                                    glm::ivec2(params.screen_width, params.screen_height), farplane, 500.0f);
     world_->Draw(draw_args);
 
@@ -349,8 +264,8 @@ void game::view::ClientSession::SendViewAngles(float time)
 
     net::ViewYawQ yaw_q;
     net::ViewPitchQ pitch_q;
-    yaw_q.Encode(camera_controller_.GetYaw());
+    yaw_q.Encode(yaw_);
-    pitch_q.Encode(camera_controller_.GetPitch());
+    pitch_q.Encode(pitch_);
 
     if (yaw_q.value == view_yaw_q_.value && pitch_q.value == view_pitch_q_.value)
         return;
@@ -397,4 +312,3 @@ game::view::RemoteMenuView* game::view::ClientSession::FindMenu(net::MenuId id)
 
     return nullptr;
 }
-

src/gameview/client_session.hpp

@@ -3,16 +3,15 @@
 #include <memory>
 
 #include "worldview.hpp"
+
 #include "gfx/draw_list.hpp"
 #include "gfx/renderer.hpp"
 #include "net/defs.hpp"
 #include "net/inmessage.hpp"
 #include "net/msg_producer.hpp"
 #include "game/player_input.hpp"
-#include "gui/player_hud.hpp"
+#include "gui/use_target_hud.hpp"
 #include "remote_menu_view.hpp"
-#include "game/camera_info.hpp"
-#include "game/camera_controller.hpp"
 
 class App;
 
@@ -34,6 +33,7 @@ public:
     void Draw(gfx::DrawList& dlist, gfx::DrawListParams& params, gui::Context& gui);
 
     const WorldView* GetWorld() const { return world_.get(); } 
+    void GetViewInfo(glm::vec3& eye, glm::mat4& view) const;
     audio::Master& GetAudioMaster() const;
 
 private:
@@ -41,12 +41,9 @@ private:
     bool ProcessWorldMsg(net::InMessage& msg);
     bool ProcessCameraMsg(net::InMessage& msg);
     bool ProcessChatMsg(net::InMessage& msg);
-    bool ProcessHudMsg(net::InMessage& msg);
-    bool ProcessDamageMsg(net::InMessage& msg);
     bool ProcessUseTargetMsg(net::InMessage& msg);
     bool ProcessMenuMsg(net::InMessage& msg);
 
-    void UpdateCamera(const UpdateInfo& info);
     void DrawWorld(gfx::DrawList& dlist, gfx::DrawListParams& params, gui::Context& gui);
     
     void SendInput(game::PlayerInputType type, bool enable);
@@ -61,14 +58,14 @@ private:
     
     std::unique_ptr<WorldView> world_;
 
-    CameraController camera_controller_;
+    float yaw_ = 0.0f, pitch_ = 0.0f;
-    CameraInfo camera_info_;
+    net::EntNum follow_ent_ = 0;
-    
+
     net::ViewYawQ view_yaw_q_;
     net::ViewPitchQ view_pitch_q_;
     float last_send_time_ = 0.0f;
 
-    gui::PlayerHud hud_;
+    gui::UseTargetHud use_target_hud_;
 
     std::vector<std::unique_ptr<RemoteMenuView>> remote_menus_;
 };

src/gameview/entityview.cpp

@@ -99,11 +99,8 @@ bool game::view::EntityView::ProcessPlaySoundMsg(net::InMessage& msg)
     if (!msg.Read(name) || !msg.Read<net::SoundVolumeQ>(volume) || !msg.Read<net::SoundPitchQ>(pitch))
         return false;
 
-    if (!world_.IsLoaded())
-        return true; // dont play if not loaded yet
-
     auto sound = assets::CacheManager::GetSound("data/" + std::string(name) + ".snd");
-    auto snd = audioplayer_.PlaySound(sound, &root_);
+    auto snd = audioplayer_.PlaySound(sound, &root_.local.position);
     snd->SetVolume(volume);
     snd->SetPitch(pitch);
 

src/gameview/markerview.cpp

@@ -13,75 +13,46 @@ game::view::MarkerView::MarkerView(WorldView& world, net::InMessage& msg) : Supe
 
 void game::view::MarkerView::Update(const UpdateInfo& info)
 {
-    float rotation_speed = marker_type_ == MARKER_PICKUP ? 2.0f : 0.5f;
+    root_.local.rotation = glm::quat(glm::vec3(0.0f, 0.0f, info.time * 0.5f));
-    root_.local.rotation = glm::quat(glm::vec3(0.0f, 0.0f, info.time * rotation_speed));
-
-    icon_node_.parent = &root_;
-
-    if (marker_type_ == MARKER_PICKUP)
-    {
-        icon_node_.local.position.z = 0.6f + glm::sin(info.time * 2.0f) * 0.1f;
-    }
-    else
-    {
-        icon_node_.local.position.z = 1.0f;
-    }
-
     root_.UpdateMatrix();
-    icon_node_.UpdateMatrix();
 }
 
 void game::view::MarkerView::Draw(const DrawArgs& args)
 {
     Super::Draw(args);
 
-    if (base_model_)
+    if (!model_)
-    {
+        return;
-        DrawModel(args, *base_model_, root_);
-    }
-    
-    if (model_)
-    {
-        DrawModel(args, *model_, icon_node_);
-    }
-}
 
-bool game::view::MarkerView::Init(net::InMessage& msg)
+    const auto& mesh = *model_->GetMesh();
-{
-    uint32_t color;
-    net::ModelName model_name;
-    if (!msg.Read(marker_type_) || !net::ReadPosition(msg, root_.local.position) || !net::ReadRGB(msg, color) || !msg.Read(model_name))
-        return false;
-    
-    root_.UpdateMatrix();
-
-    color_ = glm::unpackUnorm4x8(color | 0xFF000000);
-
-    std::string model_name_str = model_name;
-    if (!model_name_str.empty())
-    {
-        model_ = assets::CacheManager::GetModel("data/" + model_name_str + ".mdl");
-    }
-
-    if (marker_type_ == MARKER_FOOT || marker_type_ == MARKER_VEHICLE)
-    {
-        base_model_ = assets::CacheManager::GetModel("data/marker_base.mdl");
-    }
-
-
-
-    return true;
-}
-
-void game::view::MarkerView::DrawModel(const DrawArgs& args, const assets::Model& model, const TransformNode& node)
-{
-    const auto& mesh = *model.GetMesh();
     for (const auto& surface : mesh.surfaces)
     {
         gfx::DrawSurfaceCmd cmd;
         cmd.surface = &surface;
-        cmd.matrices = &node.matrix;
+        cmd.matrices = &root_.matrix;
         cmd.color = &color_;
         args.dlist.AddSurface(cmd);
     }
+
+}
+
+bool game::view::MarkerView::Init(net::InMessage& msg)
+{
+    net::PositionQ pos_q;
+    uint32_t color;
+
+    if (!msg.Read(marker_type_) || !net::ReadPositionQ(msg, pos_q) || !net::ReadRGB(msg, color))
+        return false;
+    
+    net::DecodePosition(pos_q, root_.local.position);
+    root_.UpdateMatrix();
+
+    color_ = glm::unpackUnorm4x8(color | 0xFF000000);
+
+    if (marker_type_ == MARKER_FOOT || marker_type_ == MARKER_VEHICLE)
+    {
+        model_ = assets::CacheManager::GetModel("data/marker_tuning.mdl");
+    }
+
+    return true;
 }

src/gameview/markerview.hpp

@@ -22,15 +22,11 @@ public:
 private:
     bool Init(net::InMessage& msg);
 
-    void DrawModel(const DrawArgs& args, const assets::Model& model, const TransformNode& node);
-
 private:
     MarkerType marker_type_;
     glm::vec4 color_;
 
-    std::shared_ptr<const assets::Model> base_model_;
     std::shared_ptr<const assets::Model> model_;
-    TransformNode icon_node_;
 
 };
 

src/gameview/particle_emitter.cpp

@@ -1,114 +0,0 @@
-#include "particle_emitter.hpp"
-#include "assets/cache.hpp"
-#include "utils/random.hpp"
-
-game::view::ParticleEmitter::ParticleEmitter(audio::Player* audioplayer) : audioplayer_(audioplayer)
-{
-    quad_model_ = assets::CacheManager::GetModel("data/quad.mdl");
-}
-
-void game::view::ParticleEmitter::Update(float delta_time)
-{
-    for (auto& particle : particles_)
-    {
-        particle.time += delta_time;
-        particle.velocity.z -= delta_time * particle.gravity;
-        particle.position += particle.velocity * delta_time;
-
-        if (particle.time > particle.fade_start)
-        {
-            float opacity = 1.0f - glm::clamp((particle.time - particle.fade_start) / (particle.lifetime - particle.fade_start), 0.0f, 1.0f);
-            particle.color.a = opacity;
-        }
-    }
-
-    // erase expired particles
-    particles_.erase(std::remove_if(particles_.begin(), particles_.end(),
-                                    [this](const Particle& particle) { return particle.lifetime < particle.time; }),
-                     particles_.end());
-}
-
-void game::view::ParticleEmitter::Draw(const DrawArgs& args)
-{
-    for (auto& particle : particles_)
-    {
-        // calc matrixa
-        auto forward = args.eye - particle.position;
-        auto right = glm::normalize(glm::cross(forward, glm::vec3(0.0f, 0.0f, 1.0f))); 
-        auto up = normalize(glm::cross(right, forward));
-
-        particle.matrix = glm::rotate(glm::mat4(
-            glm::vec4(right * particle.size, 0.0f),
-            glm::vec4(forward, 0.0f),
-            glm::vec4(up * particle.size, 0.0f),
-            glm::vec4(particle.position, 1.0f)
-        ), particle.rotation, glm::vec3(0.0f, 1.0f, 0.0f));
-
-        gfx::DrawSurfaceCmd cmd{};
-        cmd.surface = &particle.surface;
-        cmd.matrices = &particle.matrix;
-        cmd.color = &particle.color;
-        cmd.dist = glm::dot(forward, forward);
-        args.dlist.AddSurface(cmd);
-    }
-
-
-}
-
-void game::view::ParticleEmitter::Emit(const std::shared_ptr<const assets::Effect>& fx, const glm::vec3& pos,
-                                       const glm::vec3& dir)
-{
-    // spawn particles
-    for (const auto& def : fx->GetParticleDefs())
-    {
-        auto count = RandomInt(def.count_min, def.count_max);
-
-        if (count <= 0)
-            continue;
-
-        // steal a quad surface from quad model
-        gfx::Surface surface = quad_model_->GetMesh()->surfaces[0];
-        surface.texture = def.texture;
-        surface.sflags = gfx::SF_2SIDED | gfx::SF_OBJECT_COLOR | gfx::SF_OBJECT_COLOR_MULT;
-
-        // setup blending
-        if (def.blend == assets::PTB_BLEND_NORMAL)
-            surface.sflags |= gfx::SF_BLEND;
-        else if (def.blend == assets::PTB_BLEND_ADDITIVE)
-            surface.sflags |= gfx::SF_BLEND | gfx::SF_BLEND_ADDITIVE | gfx::SF_UNLIT;
-
-        for (int i = 0; i < count; ++i)
-        {
-            auto& particle = particles_.emplace_back();
-            particle.surface = surface;
-            particle.time = 0.0f;
-            
-            particle.position = pos;
-            particle.rotation = RandomFloat(0.0f, glm::two_pi<float>());
-            particle.size = RandomFloat(def.size_min, def.size_max);
-
-            float dispersion = RandomFloat(0.0f, def.max_dispersion);
-            float speed = RandomFloat(def.velocity_min, def.velocity_max);
-            particle.velocity = ApplyRandomDispersion(dir, dispersion) * speed;
-
-            particle.gravity = RandomFloat(def.gravity_min, def.gravity_max);
-
-            particle.lifetime = RandomFloat(def.lifetime_min, def.lifetime_max);
-            particle.fade_start = particle.lifetime - RandomFloat(def.fadetime_min, def.fadetime_max);
-
-            particle.color = glm::vec4(1.0f);
-        }
-    }
-
-    // play sounds
-    const auto& sounds = fx->GetSounds();
-    if (audioplayer_ && sounds.size() > 0)
-    {
-        auto sound_idx = rand() % sounds.size();
-
-        auto snd = audioplayer_->PlaySound(sounds[sound_idx], nullptr);
-        snd->SetPosition(pos);
-        snd->SetVolume(RandomFloat(0.9f, 1.1f));
-        // snd->SetPitch(RandomFloat(0.9f, 1.1f));
-    }
-}

src/gameview/particle_emitter.hpp

@@ -1,51 +0,0 @@
-#pragma once
-
-#include "assets/effect.hpp"
-#include "assets/model.hpp"
-#include "draw_args.hpp"
-#include "audio/player.hpp"
-
-namespace game::view
-{
-
-struct Particle
-{
-    std::shared_ptr<const assets::Effect> fx; // to keep resources alive
-
-    gfx::Surface surface;
-
-    // instance specific
-    float time;
-    glm::vec3 position;
-    float rotation;
-    float size;
-    glm::vec3 velocity;
-    float gravity;
-    float lifetime;
-    float fade_start;
-
-    // for drawing
-    glm::mat4 matrix;
-    glm::vec4 color;
-};
-
-class ParticleEmitter
-{
-public:
-    ParticleEmitter(audio::Player* audioplayer);
-
-    void Update(float delta_time);
-    void Draw(const DrawArgs& args);
-
-    void Emit(const std::shared_ptr<const assets::Effect>& fx, const glm::vec3& pos, const glm::vec3& dir);
-
-private:
-    audio::Player* audioplayer_;
-
-    std::shared_ptr<const assets::Model> quad_model_; // to steal quad VAO from
-    
-    std::vector<Particle> particles_;
-
-};
-
-}

src/gameview/vehicleview.cpp

@@ -93,8 +93,33 @@ void game::view::VehicleView::Update(const UpdateInfo& info)
         wheels_[i].node.UpdateMatrix();
     }
 
-    UpdateSounds();
+    // update snds
-    UpdateWindows();
+    bool accel = flags_ & VF_ACCELERATING;
+
+    if (accel && !snd_accel_src_)
+    {
+        snd_accel_src_ = audioplayer_.PlaySound(snd_accel_, &root_.local.position);
+        snd_accel_src_->SetLooping(true);
+    }
+    else if (!accel && snd_accel_src_)
+    {
+        snd_accel_src_->Delete();
+        snd_accel_src_ = nullptr;
+    }
+
+    // update windows
+    if ((flags_ & VF_BROKENWINDOWS) && !windows_broken_)
+    {
+        windows_broken_ = true;
+
+        auto it = mesh_.surface_names.find("carwindows"); 
+        if (it != mesh_.surface_names.end())
+        {
+            size_t idx = it->second;
+            mesh_.surfaces[idx].texture = assets::CacheManager::GetTexture("data/carbrokenwindows.png");
+        }
+    }
+
     UpdateLights(info.delta_time);
 }
 
@@ -378,40 +403,6 @@ void game::view::VehicleView::InitHeadlights()
     }
 }
 
-void game::view::VehicleView::UpdateSounds()
-{
-    if (!world_.IsLoaded())
-        return;
-
-    bool accel = flags_ & VF_ACCELERATING;
-
-    if (accel && !snd_accel_src_)
-    {
-        snd_accel_src_ = audioplayer_.PlaySound(snd_accel_, &root_);
-        snd_accel_src_->SetLooping(true);
-    }
-    else if (!accel && snd_accel_src_)
-    {
-        snd_accel_src_->Delete();
-        snd_accel_src_ = nullptr;
-    }
-}
-
-void game::view::VehicleView::UpdateWindows()
-{
-    if ((flags_ & VF_BROKENWINDOWS) && !windows_broken_)
-    {
-        windows_broken_ = true;
-
-        auto it = mesh_.surface_names.find("carwindows"); 
-        if (it != mesh_.surface_names.end())
-        {
-            size_t idx = it->second;
-            mesh_.surfaces[idx].texture = assets::CacheManager::GetTexture("data/carbrokenwindows.png");
-        }
-    }
-}
-
 void game::view::VehicleView::UpdateLights(float delta_t)
 {
     float max_delta = delta_t * 10.0f;

src/gameview/vehicleview.hpp

@@ -68,8 +68,6 @@ private:
 
     void InitHeadlights();
 
-    void UpdateSounds();
-    void UpdateWindows();
     void UpdateLights(float delta_t);
 
 private:

src/gameview/worldview.cpp

@@ -8,10 +8,9 @@
 #include "markerview.hpp"
 #include "client_session.hpp"
 #include "draw_args.hpp"
-#include "net/utils.hpp"
 
 game::view::WorldView::WorldView(ClientSession& session, net::InMessage& msg) : 
-    session_(session), audiomaster_(session_.GetAudioMaster()), audioplayer_(audiomaster_), emitter_(&audioplayer_)
+    session_(session), audiomaster_(session_.GetAudioMaster())
 {
     net::MapName mapname;
     if (!msg.Read(mapname))
@@ -70,12 +69,6 @@ bool game::view::WorldView::ProcessMsg(net::MessageType type, net::InMessage& ms
     case net::MSG_OBJRESPAWN:
         return ProcessObjDestroyOrRespawnMsg(msg, true);
 
-    case net::MSG_BEAM:
-        return ProcessBeamMsg(msg);
-
-    case net::MSG_FX:
-        return ProcessFxMsg(msg);
-
     default:
         return false;
     }
@@ -94,12 +87,9 @@ void game::view::WorldView::Update(const UpdateInfo& info)
     }
 
     UpdateEnv();
-    UpdateBeams();
-    audioplayer_.Update();
-    emitter_.Update(info.delta_time);
 }
 
-void game::view::WorldView::Draw(const DrawArgs& args)
+void game::view::WorldView::Draw(const DrawArgs& args) const
 {
     if (!map_->IsLoaded())
     {
@@ -116,9 +106,31 @@ void game::view::WorldView::Draw(const DrawArgs& args)
         if (args.frustum.IsSphereVisible(ent->GetBoundingSphere()))
             ent->Draw(args);
     }
+}
 
-    DrawBeams(args);
+glm::vec3 game::view::WorldView::CameraSweep(const glm::vec3& start, const glm::vec3& end)
-    emitter_.Draw(args);
+{
+    const auto& bt_world = GetBtWorld();
+
+    static const btSphereShape shape(0.1f);
+
+    btVector3 bt_start(start.x, start.y, start.z);
+    btVector3 bt_end(end.x, end.y, end.z);
+
+    btTransform from, to;
+    from.setIdentity();
+    from.setOrigin(bt_start);
+    to.setIdentity();
+    to.setOrigin(bt_end);
+
+    btCollisionWorld::ClosestConvexResultCallback cb(bt_start, bt_end);
+
+    bt_world.convexSweepTest(&shape, from, to, cb);
+
+    if (!cb.hasHit())
+        return end;
+
+    return glm::mix(start, end, cb.m_closestHitFraction);
 }
 
 game::view::EntityView* game::view::WorldView::GetEntity(net::EntNum entnum)
@@ -130,11 +142,6 @@ game::view::EntityView* game::view::WorldView::GetEntity(net::EntNum entnum)
     return nullptr;
 }
 
-bool game::view::WorldView::IsLoaded() const
-{
-    return map_ && map_->IsLoaded();
-}
-
 void game::view::WorldView::DrawLoadingScreen(const DrawArgs& args) const
 {
     float margin = 50.0f;
@@ -326,53 +333,7 @@ bool game::view::WorldView::ProcessObjDestroyOrRespawnMsg(net::InMessage& msg, b
     return true;
 }
 
-bool game::view::WorldView::ProcessBeamMsg(net::InMessage& msg)
-{
-    BeamView beam;
-    if (!net::ReadPosition(msg, beam.start) || !net::ReadPosition(msg, beam.end) || !net::ReadRGB(msg, beam.color) || !msg.Read<net::BeamTimeQ>(beam.expiration))
-    return false;
-    
-    beam.expiration += GetTime();
-    beam.width = 0.02f;
-    
-    beams_.emplace_back(beam);
-
-    return true;
-}
-
-bool game::view::WorldView::ProcessFxMsg(net::InMessage& msg)
-{
-    net::ModelName name;
-    glm::vec3 pos, dir;
-
-    if (!msg.Read(name) || !net::ReadPosition(msg, pos) || !msg.Read<net::DirQ>(dir.x) || !msg.Read<net::DirQ>(dir.y) ||
-        !msg.Read<net::DirQ>(dir.z))
-        return false;
-
-    if (glm::length2(dir) < 0.3f)
-        return true;// weird
-
-    emitter_.Emit(assets::CacheManager::GetEffect("data/" + std::string(name) + ".fx"), pos, glm::normalize(dir));
-    return true;
-
-}
-
 void game::view::WorldView::Cache(std::any val)
 {
     cache_.emplace_back(std::move(val));
 }
-
-void game::view::WorldView::UpdateBeams()
-{
-    beams_.erase(std::remove_if(beams_.begin(), beams_.end(),
-                                [this](const BeamView& beam) { return beam.expiration <= GetTime(); }),
-                 beams_.end());
-}
-
-void game::view::WorldView::DrawBeams(const DrawArgs& args) const
-{
-    for (const auto& beam : beams_)
-    {
-        args.dlist.AddBeam(beam.start, beam.end, beam.color | 0xFF000000, beam.width);
-    }
-}

src/gameview/worldview.hpp

@@ -10,22 +10,12 @@
 #include "entityview.hpp"
 #include "mapinstanceview.hpp"
 #include "worldenv.hpp"
-#include "particle_emitter.hpp"
 
 namespace game::view
 {
 
 class ClientSession;
 
-struct BeamView
-{
-    float expiration;
-    glm::vec3 start;
-    glm::vec3 end;
-    float width;
-    uint32_t color;
-};
-
 class WorldView : public collision::DynamicsWorld
 {
 public:
@@ -34,15 +24,14 @@ public:
     bool ProcessMsg(net::MessageType type, net::InMessage& msg);
 
     void Update(const UpdateInfo& info);
-    void Draw(const DrawArgs& args);
+    void Draw(const DrawArgs& args) const;
+
+    glm::vec3 CameraSweep(const glm::vec3& start, const glm::vec3& end);
 
     EntityView* GetEntity(net::EntNum entnum);
 
     float GetTime() const { return time_; }
     audio::Master& GetAudioMaster() const { return audiomaster_; }
-    ParticleEmitter& GetEmitter() { return emitter_; }
-
-    bool IsLoaded() const;
 
 private:
     void DrawLoadingScreen(const DrawArgs& args) const;
@@ -56,15 +45,11 @@ private:
     bool ProcessEntMsgMsg(net::InMessage& msg);
     bool ProcessUpdateEntsMsg(net::InMessage& msg);
     bool ProcessEntDestroyMsg(net::InMessage& msg);
+
     bool ProcessObjDestroyOrRespawnMsg(net::InMessage& msg, bool enable);
-    bool ProcessBeamMsg(net::InMessage& msg);
-    bool ProcessFxMsg(net::InMessage& msg);
 
     void Cache(std::any val);
 
-    void UpdateBeams();
-    void DrawBeams(const DrawArgs& args) const;
-
 private:
     ClientSession& session_;
     
@@ -79,14 +64,8 @@ private:
     float env_msg_time_ = 0.0f;
 
     audio::Master& audiomaster_;
-    audio::Player audioplayer_; // for non-entity sounds
 
     std::vector<std::any> cache_;
-
-    std::vector<BeamView> beams_;
-
-    ParticleEmitter emitter_;
-
 };
 
 } // namespace game::view

src/gui/context.cpp

@@ -19,9 +19,9 @@ void gui::Context::Begin(const glm::vec2& viewport_size)
     viewport_size_ = viewport_size;
 }
 
-void gui::Context::DrawRect(const glm::vec2& p0, const glm::vec2& p1, uint32_t color, const gfx::Texture* texture)
+void gui::Context::DrawRect(const glm::vec2& p0, const glm::vec2& p1, uint32_t color)
 {
-    BeginTexture(texture ? texture : white_tex_.get());
+    BeginTexture(white_tex_.get());
     PushRect(p0, glm::vec2(0.0f), p1, glm::vec2(1.0f), color);
 }
 

src/gui/context.hpp

@@ -34,7 +34,7 @@ public:
 
     void Begin(const glm::vec2& viewport_size);
 
-    void DrawRect(const glm::vec2& p0, const glm::vec2& p1, uint32_t color, const gfx::Texture* texture = nullptr);
+    void DrawRect(const glm::vec2& p0, const glm::vec2& p1, uint32_t color);
 
     glm::vec2 MeasureText(std::string_view text);
     void DrawText(std::string_view text, const glm::vec2& pos, uint32_t color = 0xFFFFFFFF, float scale = 1.0f);

src/gui/player_hud.cpp

@@ -1,265 +0,0 @@
-#include <format>
-
-#include "player_hud.hpp"
-#include "utils/math.hpp"
-
-#include "assets/cache.hpp"
-
-static uint32_t COLOR_ACTIVE = 0xFF00FFFF;
-static uint32_t COLOR_NORMAL = 0xFFFFFFFF;
-static uint32_t COLOR_DISABLED = 0xFFCCCCCC;
-static uint32_t COLOR_ERROR = 0xFF7777FF;
-
-#define PREFIX_SEPARATOR "^aaa"
-#define PREFIX_CLIPSIZE "^ccc"
-#define PREFIX_AMMO_NORMAL "^fff"
-#define PREFIX_AMMO_FULL "^9f9"
-#define PREFIX_AMMO_EMPTY "^f77"
-
-#define PREFIX_WEAPON_SLOT_INACTIVE "^888"
-#define PREFIX_WEAPON_SLOT_ACTIVE "^fff"
-#define PREFIX_WEAPON_SLOT_CURRENT "^ff0"
-
-gui::PlayerHud::PlayerHud(const float& time) : time_(time)
-{
-    crosshair_texture_ = assets::CacheManager::GetTexture("data/crosshair.png");
-
-    UpdateWeaponSlotsText();
-}
-
-void gui::PlayerHud::SetWeaponSlots(uint8_t slots)
-{
-    weapon_slots_ = slots;
-    UpdateWeaponSlotsText();
-}
-
-void gui::PlayerHud::SetItemInfo(std::string item_name, size_t slot, size_t clip_size)
-{
-    item_name_ = std::move(item_name);
-    clip_size_ = clip_size;
-    current_slot_ = slot;
-    UpdateWeaponSlotsText();
-}
-
-void gui::PlayerHud::SetUseTargetData(std::string text, std::string error_text, float delay)
-{
-    ut_text_ = std::move(text);
-
-    if (error_text.empty())
-        ut_error_text_.clear();
-    else
-        ut_error_text_ = "(" + error_text + ")";
-
-    ut_start_time_ = time_;
-    ut_end_time_ = delay > 0.01f ? ut_start_time_ + delay : ut_start_time_;
-}
-
-void gui::PlayerHud::ShowDamageReceived()
-{
-    damage_received_factor_ = glm::min(damage_received_factor_ + 0.2f, 0.5f);
-}
-
-void gui::PlayerHud::ShowDamageDealt(bool kill)
-{
-    (kill ? damage_dealt_kill_factor_ : damage_dealt_factor_) = 1.0f;
-}
-
-void gui::PlayerHud::Update(float delta_time)
-{
-    MoveToward(damage_received_factor_, 0.0f, 1.0f * delta_time);
-    MoveToward(damage_dealt_factor_, 0.0f, 5.0f * delta_time);
-    MoveToward(damage_dealt_kill_factor_, 0.0f, 2.0f * delta_time);
-}
-
-void gui::PlayerHud::Draw(Context& ctx) const
-{
-    DrawPain(ctx);
-    DrawCrosshair(ctx);
-    DrawHealthBar(ctx);
-    DrawItemInfo(ctx);
-    DrawUseTarget(ctx);
-    DrawDeathScreen(ctx);
-}
-
-void gui::PlayerHud::UpdateWeaponSlotsText()
-{
-    weapon_slots_text_.clear();
-
-    for (size_t slot = 0; slot < 10; ++slot)
-    {
-        weapon_slots_text_.push_back(' ');
-        
-        std::string_view prefix = PREFIX_WEAPON_SLOT_INACTIVE;
-        
-        if (weapon_slots_ & (1 << slot))
-            prefix = PREFIX_WEAPON_SLOT_ACTIVE;
-        
-        if (current_slot_ == slot + 1)
-            prefix = PREFIX_WEAPON_SLOT_CURRENT;
-
-        weapon_slots_text_ += prefix;
-        weapon_slots_text_ += std::to_string((slot + 1) % 10);
-    }
-}
-
-void gui::PlayerHud::DrawPain(Context& ctx) const
-{
-    if (damage_received_factor_ <= 0.01f)
-        return;
-
-    glm::vec4 color(1.0f, 0.3f, 0.3f, damage_received_factor_);
-    ctx.DrawRect(glm::vec2(0.0f), ctx.GetViewportSize(), glm::packUnorm4x8(color));
-}
-
-void gui::PlayerHud::DrawCrosshair(Context& ctx) const
-{
-    if (!display_crosshair_)
-        return;
-
-    glm::vec3 color(1.0f);
-    if (damage_dealt_factor_ > 0.01f)
-    {
-        color = glm::mix(color, glm::vec3(0.3f), damage_dealt_factor_);
-    }
-
-    if (damage_dealt_kill_factor_ > 0.01f)
-    {
-        color = glm::mix(color, glm::vec3(1.0f, 0.1f, 0.1f), damage_dealt_kill_factor_);
-    }
-
-    const float crosshair_size = 32.0f;
-
-    auto& viewport_size = ctx.GetViewportSize();
-
-    auto p0 = viewport_size * 0.5f - crosshair_size * 0.5f;
-    auto p1 = p0 + crosshair_size;
-
-    ctx.DrawRect(p0, p1, glm::packUnorm4x8(glm::vec4(color, 1.0f)), crosshair_texture_.get());
-}
-
-void gui::PlayerHud::DrawHealthBar(Context& ctx) const
-{
-    const float margin = 30.0f;
-    const glm::vec2 size(100.0f, 20.0f);
-
-    glm::vec2 p0(margin, ctx.GetViewportSize().y - margin - size.y);
-    glm::vec2 p1 = p0 + size;
-    ctx.DrawRect(p0, p1, 0x99000000); // bg
-    
-    glm::vec2 p1_bar = p0 + glm::vec2(size.x * health_ * 0.01f, size.y);
-    ctx.DrawRect(p0, p1_bar, 0xDD00BB00); // bar
-}
-
-static std::string_view GetAmmoColor(size_t loaded, size_t clip_size)
-{
-    if (loaded == 0)
-        return PREFIX_AMMO_EMPTY;
-
-    if (loaded == clip_size)
-        return PREFIX_AMMO_FULL;
-
-    return PREFIX_AMMO_NORMAL;
-}
-
-void gui::PlayerHud::DrawItemInfo(Context& ctx) const
-{
-    const float margin = 30.0f;
-    const float line_height = 30.0f;
-
-    glm::vec2 cursor(ctx.GetViewportSize() - margin);
-
-    ctx.DrawTextAligned(weapon_slots_text_, cursor, glm::vec2(-1.0f, -1.0f), COLOR_NORMAL);
-    cursor.y -= line_height * 1.5f;
-
-    if (!item_name_.empty())
-    {
-        std::string ammo_text =
-            std::format("{}{}" PREFIX_SEPARATOR "/" PREFIX_CLIPSIZE "{}" PREFIX_SEPARATOR " | {}{}",
-                        GetAmmoColor(loaded_ammo_, clip_size_), loaded_ammo_, clip_size_, GetAmmoColor(total_ammo_, 0), total_ammo_);
-
-        ctx.DrawTextAligned(ammo_text, cursor, glm::vec2(-1.0f, -1.0f), COLOR_NORMAL);
-        cursor.y -= line_height;
-        ctx.DrawTextAligned(item_name_, cursor, glm::vec2(-1.0f, -1.0f), COLOR_ACTIVE);
-        cursor.y -= line_height;
-    }
-}
-
-void gui::PlayerHud::DrawUseTarget(Context& ctx) const
-{
-        if (ut_text_.empty())
-        return;
-
-    bool active = ut_start_time_ != ut_end_time_;
-    uint32_t text_color = (!ut_error_text_.empty()) ? COLOR_DISABLED : (active ? COLOR_ACTIVE : COLOR_NORMAL);
-
-    const float spacing = 10.0f;
-    glm::vec2 key_size(30.0f);
-    glm::vec2 text_size = ctx.MeasureText(ut_text_);
-    float total_width = key_size.x + spacing + text_size.x;
-    
-    glm::vec2 error_size(0.0f);
-    if (!ut_error_text_.empty())
-    {
-        error_size = ctx.MeasureText(ut_error_text_);
-        total_width += spacing + error_size.x;
-    }
-
-    glm::vec2 progress_size(60.0f, 10.0f);
-    if (active)
-    {
-        total_width += spacing + progress_size.x;
-    }
-
-    auto& viewport_size = ctx.GetViewportSize();
-    float center_x = viewport_size.x * 0.5f;
-    float center_y = viewport_size.y - 50.0f;
-    float x = center_x - total_width * 0.5f;
-
-    // draw key bg
-    glm::vec2 bg_p0(x, center_y - key_size.y * 0.5f);
-    glm::vec2 bg_p1 = bg_p0 + key_size;
-    ctx.DrawRect(bg_p0, bg_p1, 0x77000000);
-    
-    // draw key text
-    static constexpr std::string_view key_text = "E";
-    ctx.DrawTextAligned(key_text, bg_p0 + key_size * 0.5f, glm::vec2(-0.5f, -0.5f), text_color);
-    
-    x += key_size.x + spacing;
-
-    // draw text
-    glm::vec2 text_p(x, center_y - text_size.y * 0.5f);
-    ctx.DrawText(ut_text_, text_p, text_color);
-    
-    x += text_size.x + spacing;
-    
-    // draw error text
-    if (!ut_error_text_.empty())
-    {
-        glm::vec2 error_text_p(x, center_y - error_size.y * 0.5f);
-        ctx.DrawText(ut_error_text_, error_text_p, COLOR_ERROR);
-    
-        x += error_size.x + spacing;
-    }
-
-    // draw progress bar
-    if (active)
-    {
-        float t = (time_ - ut_start_time_) / (ut_end_time_ - ut_start_time_); 
-        t = glm::clamp(t, 0.0f, 1.0f);
-
-        glm::vec2 progress_p0(x, center_y - progress_size.y * 0.5f);
-        glm::vec2 progress_p1 = progress_p0 + progress_size;
-        glm::vec2 progress_p1_bar = progress_p0 + glm::vec2(t * progress_size.x, progress_size.y);
-        
-        ctx.DrawRect(progress_p0, progress_p1, 0x77000000);
-        ctx.DrawRect(progress_p0, progress_p1_bar, COLOR_ACTIVE);
-    }
-}
-
-void gui::PlayerHud::DrawDeathScreen(Context& ctx) const
-{
-    if (!dead_)
-        return;
-
-    ctx.DrawTextAligned("si chcíp", ctx.GetViewportSize() * 0.5f, glm::vec2(-0.5f), 0xFFFFFFFF, 3.0f);
-}

src/gui/player_hud.hpp

@@ -1,80 +0,0 @@
-#pragma once
-
-#include <string>
-
-#include "context.hpp"
-
-namespace gui
-{
-
-class PlayerHud
-{
-public:
-    PlayerHud(const float& time);
-
-    void SetHealth(float health) { health_ = health; }
-    void SetWeaponSlots(uint8_t slots);
-    void SetItemInfo(std::string item_name, size_t slot, size_t clip_size);
-    void SetLoadedAmmo(size_t loaded_ammo) { loaded_ammo_ = loaded_ammo; }
-    void SetTotalAmmo(size_t total_ammo) { total_ammo_ = total_ammo; }
-
-    void SetUseTargetData(std::string text, std::string error_text, float delay);
-
-    void SetDisplayCrosshair(bool show) { display_crosshair_ = show; }
-    void ShowDamageReceived();
-    void ShowDamageDealt(bool kill);
-
-    void SetDead(bool dead) { dead_ = dead; }
-
-    void Update(float delta_time);
-    void Draw(Context& ctx) const;
-
-private:
-    void UpdateWeaponSlotsText();
-
-    void DrawPain(Context& ctx) const;
-    void DrawCrosshair(Context& ctx) const;
-    void DrawHealthBar(Context& ctx) const;
-    void DrawItemInfo(Context& ctx) const;
-    void DrawUseTarget(Context& ctx) const;
-    void DrawDeathScreen(Context& ctx) const;
-
-private:
-    const float& time_; 
-    
-    // resources
-    std::shared_ptr<const gfx::Texture> crosshair_texture_;
-
-    // general
-    float health_ = 0.0f;
-
-    // weapon slots
-    uint8_t weapon_slots_ = 0;
-    size_t current_slot_ = 0;
-    std::string weapon_slots_text_;
-
-    // held item
-    std::string item_name_;
-    size_t clip_size_ = 0;
-    size_t loaded_ammo_ = 0;
-    size_t total_ammo_ = 0;
-
-    // use target
-    std::string ut_text_;
-    std::string ut_error_text_;
-    float ut_start_time_ = 0.0f;
-    float ut_end_time_ = 0.0f;
-
-    // crosshair & events
-    bool display_crosshair_ = false;
-    float damage_received_factor_ = 0.0f;
-    float damage_dealt_factor_ = 0.0f;
-    float damage_dealt_kill_factor_ = 0.0f;
-    
-    // death
-    bool dead_ = false;
-
-};
-
-
-}

src/gui/use_target_hud.cpp

@@ -0,0 +1,88 @@
+#include "use_target_hud.hpp"
+
+gui::UseTargetHud::UseTargetHud(const float& time) : time_(time) {}
+
+void gui::UseTargetHud::SetData(std::string text, std::string error_text, float delay)
+{
+    text_ = std::move(text);
+
+    if (error_text.empty())
+        error_text_.clear();
+    else
+        error_text_ = "(" + error_text + ")";
+
+    start_time_ = time_;
+    end_time_ = delay > 0.01f ? start_time_ + delay : start_time_;
+}
+
+void gui::UseTargetHud::Draw(Context& ctx) const
+{
+    if (text_.empty())
+        return;
+
+    bool active = start_time_ != end_time_;
+    uint32_t text_color = (!error_text_.empty()) ? 0xFFCCCCCC : (active ? 0xFF00FFFF : 0xFFFFFFFF);
+
+    const float spacing = 10.0f;
+    glm::vec2 key_size(30.0f);
+    glm::vec2 text_size = ctx.MeasureText(text_);
+    float total_width = key_size.x + spacing + text_size.x;
+    
+    glm::vec2 error_size(0.0f);
+    if (!error_text_.empty())
+    {
+        error_size = ctx.MeasureText(error_text_);
+        total_width += spacing + error_size.x;
+    }
+
+    glm::vec2 progress_size(60.0f, 10.0f);
+    if (active)
+    {
+        total_width += spacing + progress_size.x;
+    }
+
+    auto& viewport_size = ctx.GetViewportSize();
+    float center_x = viewport_size.x * 0.5f;
+    float center_y = viewport_size.y - 50.0f;
+    float x = center_x - total_width * 0.5f;
+
+    // draw key bg
+    glm::vec2 bg_p0(x, center_y - key_size.y * 0.5f);
+    glm::vec2 bg_p1 = bg_p0 + key_size;
+    ctx.DrawRect(bg_p0, bg_p1, 0x77000000);
+    
+    // draw key text
+    static constexpr std::string_view key_text = "E";
+    ctx.DrawTextAligned(key_text, bg_p0 + key_size * 0.5f, glm::vec2(-0.5f, -0.5f), text_color);
+    
+    x += key_size.x + spacing;
+
+    // draw text
+    glm::vec2 text_p(x, center_y - text_size.y * 0.5f);
+    ctx.DrawText(text_, text_p, text_color);
+    
+    x += text_size.x + spacing;
+    
+    // draw error text
+    if (!error_text_.empty())
+    {
+        glm::vec2 error_text_p(x, center_y - error_size.y * 0.5f);
+        ctx.DrawText(error_text_, error_text_p, 0xFF7777FF);
+    
+        x += error_size.x + spacing;
+    }
+
+    // draw progress bar
+    if (active)
+    {
+        float t = (time_ - start_time_) / (end_time_ - start_time_); 
+        t = glm::clamp(t, 0.0f, 1.0f);
+
+        glm::vec2 progress_p0(x, center_y - progress_size.y * 0.5f);
+        glm::vec2 progress_p1 = progress_p0 + progress_size;
+        glm::vec2 progress_p1_bar = progress_p0 + glm::vec2(t * progress_size.x, progress_size.y);
+        
+        ctx.DrawRect(progress_p0, progress_p1, 0x77000000);
+        ctx.DrawRect(progress_p0, progress_p1_bar, 0xFF00FFFF);
+    }
+}

src/gui/use_target_hud.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <string>
+
+#include "context.hpp"
+
+namespace gui
+{
+
+class UseTargetHud
+{
+public:
+    UseTargetHud(const float& time);
+ 
+    void SetData(std::string text, std::string error_text, float delay);
+
+    void Draw(Context& ctx) const;
+    
+private:    
+    const float& time_; 
+    std::string text_;
+    std::string error_text_;
+    float start_time_ = 0.0f;
+    float end_time_ = 0.0f;
+};
+
+
+}

src/net/defs.hpp

@@ -46,12 +46,6 @@ enum MessageType : uint8_t
     // REMOTEMENU <MenuId> <MenuMessageType> ...
     MSG_REMOTEMENU,
 
-    // HUD ...
-    MSG_HUD,
-
-    // DAMAGE ...
-    MSG_DAMAGE,
-
     /*~~~~~~~~ Entity ~~~~~~~~*/
     // ENTSPAWN <EntNum> <EntType> data...
     MSG_ENTSPAWN,
@@ -68,12 +62,6 @@ enum MessageType : uint8_t
     // OBJRESPAWN <ObjNum>
     MSG_OBJRESPAWN,
     
-    /*~~~~~~~~ Effects ~~~~~~~~*/
-    // BEAM <Position start> <Position end> <Color> <BeamTime>
-    MSG_BEAM,
-
-    // FX <ModelName effect> <Position> <Dir x> <Dir y> <Dir z>
-    MSG_FX,
 
     /*~~~~~~~~~~~~~~~~*/
     MSG_COUNT,
@@ -120,8 +108,6 @@ enum EntMsgType : uint8_t
     EMSG_PLAYSOUND,
     EMSG_DEFORM,
     EMSG_TUNING,
-    EMSG_EQUIP,
-    EMSG_FIRE,
 };
 
 using PositionElemQ = Quantized<uint32_t, -10000, 10000, 1>;
@@ -151,10 +137,7 @@ using SoundVolumeQ = Quantized<uint8_t, 0, 2>;
 using SoundPitchQ = Quantized<uint8_t, 0, 2>;
 
 using AnimBlendQ = Quantized<uint8_t, 0, 1>;
-using AnimPhaseQ = Quantized<uint8_t, 0, 1>;
+using AnimTimeQ = Quantized<uint8_t, 0, 1>;
-using AnimTimeQ = Quantized<uint16_t, 0, 255>;
-
-using AnimAimAngleQ = Quantized<uint16_t, -PI_N, PI_N, PI_D>;
 
 using NumClothes = uint8_t;
 using ClothesName = FixedStr<32>;
@@ -208,8 +191,4 @@ enum MenuActionType
 
 using MenuSelectDir = uint8_t; // 0=left, 1=right
 
-using BeamTimeQ = Quantized<uint8_t, 0, 10>;
-
-using DirQ = Quantized<uint8_t, -1, 1>;
-
 } // namespace net

src/net/msg_producer.cpp

@@ -20,40 +20,3 @@ void net::MsgProducer::DiscardMsg()
 {
     message_buf_.resize(msg_start_);
 }
-
-net::OutMessage net::LocalMsgProducer::BeginLocalMsg(const glm::vec3& position, float radius, MessageType type)
-{
-    LocalMsgInfo& local_msg = local_msgs_.emplace_back();
-    local_msg.start = local_msg_buf_.size();
-    local_msg.position = position;
-    local_msg.radius = radius;
-
-    OutMessage msg(local_msg_buf_);
-    if (type != net::MSG_NONE)
-        msg.Write(type);
-    return msg;
-}
-
-void net::LocalMsgProducer::PickLocalMsgs(MsgProducer& target, const glm::vec3& target_pos)
-{
-    for (size_t i = 0; i < local_msgs_.size(); ++i)
-    {
-        const auto& local_msg = local_msgs_[i];
-
-        auto d = local_msg.position - target_pos;
-        if (glm::dot(d, d) > (local_msg.radius * local_msg.radius))
-            continue;
-
-        auto start = local_msgs_[i].start;
-        auto end = (i + 1) < local_msgs_.size() ? local_msgs_[i + 1].start : local_msg_buf_.size();
-
-        auto msg = target.BeginMsg();
-        msg.Write(std::span<char>(&local_msg_buf_[start], end - start));
-    }
-}
-
-void net::LocalMsgProducer::ResetLocalMsgs()
-{
-    local_msgs_.clear();
-    local_msg_buf_.clear();
-}

src/net/msg_producer.hpp

@@ -5,8 +5,6 @@
 #include "defs.hpp"
 #include "outmessage.hpp"
 
-#include <glm/glm.hpp>
-
 namespace net
 {
 
@@ -25,26 +23,4 @@ private:
     size_t msg_start_ = 0;
 };
 
-struct LocalMsgInfo
-{
-    size_t start;
-    glm::vec3 position;
-    float radius;
-};
-
-class LocalMsgProducer
-{
-public:
-    LocalMsgProducer() = default;
-
-    OutMessage BeginLocalMsg(const glm::vec3& position, float radius, MessageType type = MSG_NONE);
-    void PickLocalMsgs(MsgProducer& target, const glm::vec3& target_pos);
-    void ResetLocalMsgs();
-
-private:
-    std::vector<LocalMsgInfo> local_msgs_;
-    std::vector<char> local_msg_buf_;
-
-};
-
 }

src/net/utils.hpp

@@ -10,12 +10,12 @@ namespace net
 
 /// TRANSFORMS
 
-inline void WritePosition(OutMessage& msg, const glm::vec3& pos)
+// inline void WritePosition(OutMessage& msg, const glm::vec3& pos)
-{
+// {
-    msg.Write<PositionElemQ>(pos.x);
+//     msg.Write<PositionQ>(pos.x);
-    msg.Write<PositionElemQ>(pos.y);
+//     msg.Write<PositionQ>(pos.y);
-    msg.Write<PositionElemQ>(pos.z);
+//     msg.Write<PositionQ>(pos.z);
-}
+// }
 
 inline void EncodePosition(const glm::vec3& pos, PositionQ& out)
 {
@@ -66,10 +66,10 @@ inline void WriteRotationQ(OutMessage& msg, const QuatQ& rotq)
 //     WriteRotation(msg, trans.rotation);
 // }
 
-inline bool ReadPosition(InMessage& msg, glm::vec3& pos)
+// inline bool ReadPosition(InMessage& msg, glm::vec3& pos)
-{
+// {
-    return msg.Read<PositionElemQ>(pos.x) && msg.Read<PositionElemQ>(pos.y) && msg.Read<PositionElemQ>(pos.z);
+//     return msg.Read<PositionQ>(pos.x) && msg.Read<PositionQ>(pos.y) && msg.Read<PositionQ>(pos.z);
-}
+// }
 
 inline bool ReadPositionQ(InMessage& msg, PositionQ& posq)
 {
@@ -147,14 +147,14 @@ inline bool ReadRGB(InMessage& msg, uint32_t& color)
 
 // DELTA
 template <std::unsigned_integral T> requires (sizeof(T) == 1)
-inline void WriteDelta(OutMessage& msg, T current, T previous)
+inline void WriteDelta(OutMessage& msg, T previous, T current)
 {
     // 1 byte => just write current
     msg.Write(current);
 }
 
 template <std::unsigned_integral T> requires (sizeof(T) > 1)
-inline void WriteDelta(OutMessage& msg, T current, T previous)
+inline void WriteDelta(OutMessage& msg, T previous, T current)
 {
     static_assert(sizeof(T) <= 4);
 
@@ -169,18 +169,18 @@ inline void WriteDelta(OutMessage& msg, T current, T previous)
 template <AnyQuantized T>
 inline void WriteDelta(OutMessage& msg, T current, T previous)
 {
-    WriteDelta(msg, current.value, previous.value);
+    WriteDelta(msg, previous.value, current.value);
 }
 
 template <std::unsigned_integral T> requires (sizeof(T) == 1)
-inline bool ReadDelta(InMessage& msg, T& current, T previous)
+inline bool ReadDelta(InMessage& msg, T previous, T& current)
 {
     // 1 byte => just read current
     return msg.Read(current);
 }
 
 template <std::unsigned_integral T> requires (sizeof(T) > 1)
-inline bool ReadDelta(InMessage& msg, T& current, T previous)
+inline bool ReadDelta(InMessage& msg, T previous, T& current)
 {
     static_assert(sizeof(T) <= 4);
 

src/utils/random.hpp

@@ -6,29 +6,3 @@ inline float RandomFloat(float min, float max)
 {
     return min + (max - min) * static_cast<float>(rand() % 100) * 0.01f;
 }
-
-inline int RandomInt(int min, int max)
-{
-    return min + rand() % (max - min + 1);
-}
-
-inline glm::vec3 ApplyRandomDispersion(const glm::vec3& dir, float dispersion)
-{
-    float rand_rotation = RandomFloat(0.0f, glm::radians(360.0f));
-    float rand_dispersion = RandomFloat(0.0f, 0.01f) * dispersion; // dispersion in m/100m
-
-    auto right = glm::normalize(glm::cross(dir, glm::vec3(0.0f, 0.0f, 1.0f)));
-    auto up = glm::normalize(glm::cross(right, dir));
-
-    return dir + (right * glm::sin(rand_rotation) + up * glm::cos(rand_rotation)) * rand_dispersion;
-}
-
-inline bool Chance(float probability)
-{
-    return RandomFloat(0.0f, 1.0f) < probability;
-}
-
-inline bool ChanceAvgTime(float avg_time)
-{
-    return Chance((1.0f / 25.0f) / avg_time);
-}