PiecePool.h

Go to the documentation of this file.

// PiecePool.h
 
// Declares the cPiecePool class representing a pool of cPieces - "parts" of a structure, used in piece-generators
 
 
 
 
 
#pragma once
 
#include "ComposableGenerator.h"
#include "../Defines.h"
#include "../Cuboid.h"
 
 
 
 
 
class cPiece
{
public:
    // Force a virtual destructor in all descendants
    virtual ~cPiece() {}
 
    struct cConnector
    {
        enum eDirection
        {
            // The following values correspond to equivalent eBlockFace values:
            dirXM   =  BLOCK_FACE_XM,  // Pointing towards the X- side of the prefab
            dirXP   =  BLOCK_FACE_XP,  // Pointing towards the X+ side of the prefab
            dirYM   =  BLOCK_FACE_YM,  // Pointing towards the Y- side of the prefab, doesn't change with rotation around the Y axis
            dirYP   =  BLOCK_FACE_YP,  // Pointing towards the Y+ side of the prefab, doesn't change with rotation around the Y axis
            dirZM   =  BLOCK_FACE_ZM,  // Pointing towards the Z- side of the prefab
            dirZP   =  BLOCK_FACE_ZP,  // Pointing towards the Z+ side of the prefab
 
            // Special kind of the vertical connectors (changes with rotation around the Y axis)
            dirYM_XM_ZM = BLOCK_FACE_MAX + 1,  // Pointing towards the Y- side of the prefab, conceptually at the X- Z- corner of the block
            dirYM_XM_ZP,                       // Pointing towards the Y- side of the prefab, conceptually at the X- Z+ corner of the block
            dirYM_XP_ZM,                       // Pointing towards the Y- side of the prefab, conceptually at the X+ Z- corner of the block
            dirYM_XP_ZP,                       // Pointing towards the Y- side of the prefab, conceptually at the X+ Z+ corner of the block
            dirYP_XM_ZM,                       // Pointing towards the Y+ side of the prefab, conceptually at the X- Z- corner of the block
            dirYP_XM_ZP,                       // Pointing towards the Y+ side of the prefab, conceptually at the X- Z+ corner of the block
            dirYP_XP_ZM,                       // Pointing towards the Y+ side of the prefab, conceptually at the X+ Z- corner of the block
            dirYP_XP_ZP,                       // Pointing towards the Y+ side of the prefab, conceptually at the X+ Z+ corner of the block
        };
 
        Vector3i m_Pos;
 
        int m_Type;
 
        eDirection m_Direction;
 
        cConnector(int a_X, int a_Y, int a_Z, int a_Type, eDirection a_Direction);
        cConnector(const Vector3i & a_Pos, int a_Type, eDirection a_Direction);
 
        static Vector3i AddDirection(const Vector3i & a_Pos, eDirection a_Direction);
 
        static const char * DirectionToString(eDirection a_Direction);
 
        static bool IsValidDirection(int a_Direction);
 
        static eDirection RotateDirection(eDirection a_Direction);
 
        static eDirection RotateDirectionCCW(eDirection a_Direction);
 
        static eDirection RotateDirectionCW(eDirection a_Direction);
 
        static int GetNumCCWRotationsToFit(eDirection a_FixedDir, eDirection a_RotatingDir);
 
        static bool StringToDirection(const AString & a_Value, eDirection & a_Out);
    };
 
    typedef std::vector<cConnector> cConnectors;
 
 
    class cVerticalStrategy
    {
    public:
        // Force a virtual destructor in descendants
        virtual ~cVerticalStrategy() {}
 
        virtual int GetVerticalPlacement(int a_BlockX, int a_BlockZ) = 0;
 
        virtual bool InitializeFromString(const AString & a_Params, bool a_LogWarnings) = 0;
 
        virtual void AssignGens(int a_Seed, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_TerrainHeightGen, int a_SeaLevel) {}
    };
 
    typedef std::shared_ptr<cVerticalStrategy> cVerticalStrategyPtr;
 
 
    class cVerticalLimit
    {
    public:
        virtual ~cVerticalLimit() {}
 
        virtual bool CanBeAtHeight(int a_BlockX, int a_BlockZ, int a_Height) = 0;
 
        virtual bool InitializeFromString(const AString & a_Params, bool a_LogWarnings) = 0;
 
        virtual void AssignGens(int a_Seed, cBiomeGen & a_BiomeGen, cTerrainHeightGen & a_TerrainHeightGen, int a_SeaLevel) {}
    };
 
    typedef std::shared_ptr<cVerticalLimit> cVerticalLimitPtr;
 
 
    class cPieceModifier
    {
    public:
        // Force a virtual destructor in descendants
        virtual ~cPieceModifier() {}
 
        virtual bool InitializeFromString(const AString & a_Params, bool a_LogWarnings) = 0;
 
        virtual void Modify(cBlockArea & a_Image, const Vector3i a_PiecePos, const int a_PieceNumRotations) = 0;
 
        virtual void AssignSeed(int a_Seed) {}
    };
 
 
    typedef std::shared_ptr<cPieceModifier> cPieceModifierPtr;
 
    typedef std::vector<cPieceModifierPtr> cPieceModifiers;
 
    cVerticalStrategyPtr m_VerticalStrategy;
 
    cVerticalLimitPtr m_VerticalLimit;
 
    cPieceModifiers m_Modifiers;
 
    virtual cConnectors GetConnectors(void) const = 0;
 
    virtual Vector3i GetSize(void) const = 0;
 
    virtual cCuboid GetHitBox(void) const = 0;
 
    virtual bool CanRotateCCW(int a_NumRotations) const = 0;
 
    int GetStartingPieceHeight(int a_BlockX, int a_BlockZ)
    {
        if (m_VerticalStrategy != nullptr)
        {
            return m_VerticalStrategy->GetVerticalPlacement(a_BlockX, a_BlockZ);
        }
        return -1;
    }
 
    void SetVerticalStrategy(cVerticalStrategyPtr a_VerticalStrategy)
    {
        m_VerticalStrategy = std::move(a_VerticalStrategy);
    }
 
    cVerticalStrategyPtr GetVerticalStrategy(void) const
    {
        return m_VerticalStrategy;
    }
 
    cVerticalLimitPtr GetVerticalLimit(void) const
    {
        return m_VerticalLimit;
    }
 
    cPieceModifiers GetModifiers(void) const
    {
        return m_Modifiers;
    }
 
    bool SetVerticalStrategyFromString(const AString & a_StrategyDesc, bool a_LogWarnings);
 
    bool SetVerticalLimitFromString(const AString & a_LimitDesc, bool a_LogWarnings);
 
    bool SetPieceModifiersFromString(const AString & a_Definition, bool a_LogWarnings);
 
    Vector3i RotatePos(const Vector3i & a_Pos, int a_NumCCWRotations) const;
 
    cConnector RotateMoveConnector(const cConnector & a_Connector, int a_NumCCWRotations, int a_MoveX, int a_MoveY, int a_MoveZ) const;
 
    cCuboid RotateHitBoxToConnector(const cConnector & a_MyConnector, const Vector3i & a_ToConnectorPos, int a_NumCCWRotations) const;
 
    cCuboid RotateMoveHitBox(int a_NumCCWRotations, int a_MoveX, int a_MoveY, int a_MoveZ) const;
};
 
typedef std::vector<cPiece *> cPieces;
 
 
 
 
// fwd:
class cPlacedPiece;
 
 
 
 
 
class cPiecePool
{
public:
    // Force a virtual destructor in all descendants:
    virtual ~cPiecePool() {}
 
    virtual cPieces GetPiecesWithConnector(int a_ConnectorType) = 0;
 
    virtual cPieces GetStartingPieces(void) = 0;
 
    virtual int GetPieceWeight(
        const cPlacedPiece & a_PlacedPiece,
        const cPiece::cConnector & a_ExistingConnector,
        const cPiece & a_NewPiece
    )
    {
        return 1;
    }
 
    virtual int GetStartingPieceWeight(const cPiece & a_NewPiece)
    {
        return 1;
    }
 
    virtual void PiecePlaced(const cPiece & a_Piece) = 0;
 
    virtual void Reset(void) = 0;
};
 
 
 
 
 
class cPlacedPiece
{
public:
    cPlacedPiece(const cPlacedPiece * a_Parent, const cPiece & a_Piece, const Vector3i & a_Coords, int a_NumCCWRotations);
 
    const cPlacedPiece * GetParent           (void) const { return m_Parent; }
    const cPiece &       GetPiece            (void) const { return *m_Piece; }
    const Vector3i &     GetCoords           (void) const { return m_Coords; }
    int                  GetNumCCWRotations  (void) const { return m_NumCCWRotations; }
    const cCuboid &      GetHitBox           (void) const { return m_HitBox; }
    int                  GetDepth            (void) const { return m_Depth; }
    bool                 HasBeenMovedToGround(void) const { return m_HasBeenMovedToGround; }
 
    Vector3i & GetCoords(void) { return m_Coords; }
 
    cPiece::cConnector GetRotatedConnector(size_t a_Index) const;
 
    cPiece::cConnector GetRotatedConnector(const cPiece::cConnector & a_Connector) const;
 
    void MoveToGroundBy(int a_OffsetY);
 
protected:
    const cPlacedPiece * m_Parent;
    const cPiece * m_Piece;
    Vector3i m_Coords;
    int m_NumCCWRotations;
    cCuboid m_HitBox;  // Hitbox of the placed piece, in world coords
    int m_Depth;       // Depth in the generated piece tree
 
    bool m_HasBeenMovedToGround;
};
 
typedef std::unique_ptr<cPlacedPiece> cPlacedPiecePtr;
typedef std::vector<cPlacedPiecePtr> cPlacedPieces;