CCmpUnitMotionManager.h

Go to the documentation of this file.

/* Copyright (C) 2022 Wildfire Games.
 * This file is part of 0 A.D.
 *
 * 0 A.D. is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 2 of the License, or
 * (at your option) any later version.
 *
 * 0 A.D. is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef INCLUDED_CCMPUNITMOTIONMANAGER
#define INCLUDED_CCMPUNITMOTIONMANAGER

#include "simulation2/system/Component.h"
#include "ICmpUnitMotionManager.h"

#include "simulation2/MessageTypes.h"
#include "simulation2/components/ICmpTerrain.h"
#include "simulation2/helpers/Grid.h"
#include "simulation2/system/EntityMap.h"

class CCmpUnitMotion;

class CCmpUnitMotionManager final : public ICmpUnitMotionManager
{
public:
    static void ClassInit(CComponentManager& componentManager);

    DEFAULT_COMPONENT_ALLOCATOR(UnitMotionManager)

    /**
     * Maximum value for pushing pressure.
     */
    static constexpr int MAX_PRESSURE = 255;

    // Persisted state for each unit.
    struct MotionState
    {
        MotionState(ICmpPosition* cmpPos, CCmpUnitMotion* cmpMotion);

        // Component references - these must be kept alive for the duration of motion.
        // NB: this is generally a super dangerous thing to do,
        // but the tight coupling with CCmpUnitMotion makes it workable.
        // NB: this assumes that components do _not_ move in memory,
        // which is currently a fair assumption but might change in the future.
        ICmpPosition* cmpPosition;
        CCmpUnitMotion* cmpUnitMotion;

        // Position before units start moving
        CFixedVector2D initialPos;
        // Transient position during the movement.
        CFixedVector2D pos;

        // Accumulated "pushing" from nearby units.
        CFixedVector2D push;

        fixed speed;

        fixed initialAngle;
        fixed angle;

        // Used for formations - units with the same control group won't push at a distance.
        // (this is required because formations may be tight and large units may end up never settling.
        entity_id_t controlGroup = INVALID_ENTITY;

        // This is a ad-hoc counter to store under how much pushing 'pressure' an entity is.
        // More pressure will slow the unit down and make it harder to push,
        // which effectively bogs down groups of colliding units.
        uint8_t pushingPressure = 0;

        // Meta-flag -> this entity won't push nor be pushed.
        // (used for entities that have their obstruction disabled).
        bool ignore = false;

        // If true, the entity needs to be handled during movement.
        bool needUpdate = false;

        bool wentStraight = false;
        bool wasObstructed = false;

        // Clone of the obstruction manager flag for efficiency
        bool isMoving = false;
    };

    // "Template" state, not serialized (cannot be changed mid-game).

    // The maximal distance at which units push each other is the combined unit clearances, multipled by this factor,
    // itself pre-multiplied by the circle-square correction factor.
    entity_pos_t m_PushingRadiusMultiplier;
    // Additive modifiers to the maximum pushing distance for moving units and idle units respectively.
    entity_pos_t m_MovingPushExtension;
    entity_pos_t m_StaticPushExtension;
    // Multiplier for the pushing 'spread'.
    // This should be understand as the % of the maximum distance where pushing will be "in full force".
    entity_pos_t m_MovingPushingSpread;
    entity_pos_t m_StaticPushingSpread;

    // Pushing forces below this value are ignored - this prevents units moving forever by very small increments.
    entity_pos_t m_MinimalPushing;

    // Multiplier for pushing pressure strength.
    entity_pos_t m_PushingPressureStrength;
    // Per-turn reduction in pushing pressure.
    entity_pos_t m_PushingPressureDecay;

    // These vectors are reconstructed on deserialization.

    EntityMap<MotionState> m_Units;
    EntityMap<MotionState> m_FormationControllers;

    // Turn-local state below, not serialised.

    Grid<std::vector<EntityMap<MotionState>::iterator>> m_MovingUnits;
    bool m_ComputingMotion;

    static std::string GetSchema()
    {
        return "<a:component type='system'/><empty/>";
    }

    void Init(const CParamNode& UNUSED(paramNode)) override;

    void Deinit() override
    {
    }

    void Serialize(ISerializer& serialize) override;
    void Deserialize(const CParamNode& paramNode, IDeserializer& deserialize) override;

    void HandleMessage(const CMessage& msg, bool global) override;

    void Register(CCmpUnitMotion* component, entity_id_t ent, bool formationController) override;
    void Unregister(entity_id_t ent) override;

    bool ComputingMotion() const override
    {
        return m_ComputingMotion;
    }

    bool IsPushingActivated() const override
    {
        return m_PushingRadiusMultiplier != entity_pos_t::Zero();
    }

private:
    void OnDeserialized();
    void ResetSubdivisions();
    void OnTurnStart();

    void MoveUnits(fixed dt);
    void MoveFormations(fixed dt);
    void Move(EntityMap<MotionState>& ents, fixed dt);

    void Push(EntityMap<MotionState>::value_type& a, EntityMap<MotionState>::value_type& b, fixed dt);
};

REGISTER_COMPONENT_TYPE(UnitMotionManager)

#endif // INCLUDED_CCMPUNITMOTIONMANAGER