MazeElement.h

Go to the documentation of this file.

// MazeElement.h
//
// Copyright (c) 1995-1998 - Richard Langlois and Grokksoft Inc.
//
// Licensed under GrokkSoft HoverRace SourceCode License v1.0(the "License");
// you may not use this file except in compliance with the License.
//
// A copy of the license should have been attached to the package from which
// you have taken this file. If you can not find the license you can not use
// this file.
//
//
// The author makes no representations about the suitability of
// this software for any purpose.  It is provided "as is" "AS IS",
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
// implied.
//
// See the License for the specific language governing permissions
// and limitations under the License.
//

#pragma once

#include "../Util/DllObjectFactory.h"
#include "../VideoServices/Viewport3D.h"
#include "ContactEffect.h"
#include "Shapes.h"

#if defined(_WIN32) && defined(HR_ENGINE_SHARED)
#   ifdef MR_ENGINE
#       define MR_DllDeclare   __declspec( dllexport )
#   else
#       define MR_DllDeclare   __declspec( dllimport )
#   endif
#else
#   define MR_DllDeclare
#endif

namespace HoverRace {
    namespace Model {
        class Level;
        class Track;
    }
    namespace Parcel {
        class ObjStream;
    }
}

class MR_FreeElementHandleClass;
using MR_FreeElementHandle = MR_FreeElementHandleClass*;

namespace HoverRace {
namespace Model {

struct ElementNetState
{
    int mDataLen;
    const MR_UInt8 *mData;
};

class MR_DllDeclare Element : public Util::ObjectFromFactory
{
    using SUPER = Util::ObjectFromFactory;

public:
    Element(const Util::ObjectFromFactoryId &id) : SUPER(id) { }
    virtual ~Element() { }

    virtual void AddRenderer() { }

    // Contact effect interface
    virtual void ApplyEffect(const ContactEffect *pEffect,
        MR_SimulationTime pTime, MR_SimulationTime pDuration,
        BOOL pValidDirection, MR_Angle pHorizontalDirection,
        MR_Int32 pZMin, MR_Int32 pZMax,
        Track &track)
    {
        HR_UNUSED(pEffect, pTime, pDuration,
            pValidDirection, pHorizontalDirection,
            pZMin, pZMax, track);
    }

    virtual const ContactEffectList *GetEffectList() { return nullptr; }

    // Helper functions
    void ApplyEffects(const ContactEffectList *pList,
        MR_SimulationTime pTime, MR_SimulationTime pDuration,
        BOOL pValidDirection, MR_Angle pHorizontalDirection,
        MR_Int32 pZMin, MR_Int32 pZMax,
        Track &track)
    {
        if (pList) {
            for (auto lEffect : *pList) {
                ApplyEffect(lEffect, pTime, pDuration,
                    pValidDirection, pHorizontalDirection,
                    pZMin, pZMax, track);
            }
        }
    }

public:
    // Prevent overriding of the Serialize function.
    void Serialize(Parcel::ObjStream&) override final { }
};

class MR_DllDeclare SurfaceElement : public Element
{
    using SUPER = Element;

public:
    SurfaceElement(const Util::ObjectFromFactoryId &id) : SUPER(id) { }
    virtual ~SurfaceElement() { }

    virtual void RenderWallSurface(VideoServices::Viewport3D *pDest,
        const MR_3DCoordinate &pUpperLeft, const MR_3DCoordinate &pLowerRight,
        MR_Int32 pLen, MR_SimulationTime pTime)
    {
        HR_UNUSED(pDest, pUpperLeft, pLowerRight, pLen, pTime);
    }

    virtual void RenderHorizontalSurface(VideoServices::Viewport3D *pDest,
        int pNbVertex, const MR_2DCoordinate *pVertexList,
        MR_Int32 pLevel, BOOL pTop, MR_SimulationTime pTime)
    {
        HR_UNUSED(pDest, pNbVertex, pVertexList, pLevel, pTop, pTime);
    }
};

class MR_DllDeclare FreeElement :
    public Element,
    public std::enable_shared_from_this<FreeElement>
{
    using SUPER = Element;

public:
    //HACK: Temporary default value for scripting.
    FreeElement(const Util::ObjectFromFactoryId &id = { 0, 0 }) : SUPER(id)
    {
    }
    virtual ~FreeElement() { }

    virtual void Render(VideoServices::Viewport3D *pDest,
        MR_SimulationTime pTime)
    {
        HR_UNUSED(pDest, pTime);
    }

    virtual void PlayInternalSounds() { }
    virtual void PlayExternalSounds(int pDB, int pPan) { HR_UNUSED(pDB, pPan); }

    virtual ElementNetState GetNetState() const
    {
        return { 0, nullptr };
    }

    virtual void SetNetState(int pDataLen, const MR_UInt8 *pData)
    {
        HR_UNUSED(pDataLen, pData);
        assert(pDataLen == 0);
    }

    //TODO: Track physics & collision data in a separate heap.

    // Logic interface (For simulation)

    virtual int Simulate(MR_SimulationTime pTimeSlice, Track &track, int pRoom)
    {
        HR_UNUSED(pTimeSlice, track);
        return pRoom;
    }

    virtual const ShapeInterface *GetObstacleShape() { return nullptr; }

    virtual const ShapeInterface *GetReceivingContactEffectShape() { return nullptr; }

    virtual const ShapeInterface *GetGivingContactEffectShape() { return nullptr; }

    // Perm state hook

    virtual bool AssignPermNumber(int pNumber)
    {
        HR_UNUSED(pNumber);
        return false;
    }

    virtual void SetOwnerId(int pOwnerId) { HR_UNUSED(pOwnerId); }

public:
    MR_3DCoordinate mPosition;
    MR_Angle mOrientation;
};

}  // namespace Model
}  // namespace HoverRace

#undef MR_DllDeclare