Tutorial 16.1: Scene Adventure

Overview

This first Tutorial 16 example loads Base/tiled/adventure/adventure.tmx. Its image layer draws the world, while the object layer contains the player, a polygon movement area and interactable key and door objects.

Right-click movement stays inside the polygon, left-click interaction checks distance and TMX properties, and the camera follows the player smoothly. A Scene-layer callback renders timed speech while a screen-space panel displays the collected key.

Final result

CRM64Pro Tutorial 16.1 Scene Adventure

Runtime controls

• Left-click: Interact with or pick up an object.
• Right-click: Move the player.
• S: Enable or disable smooth scrolling.
• D: Show or hide object and trigger debug overlays.
• Q or ESC: Exit the tutorial.

The debug toggle uses Scene::setDebugObjectOverlay() with ::SDOT_STANDARD, so the object AABB and trigger visualizations remain independent from tile and camera overlays.

Prerequisites

• CRM64Pro GDK installed and configured with a supported C++17 compiler.
• Tutorial package downloaded and fully extracted, preserving its folder structure.
• Run Tutorial 02 first so Tutorial.cdc contains Tutorial_bg.
• Keep the bin/Base/tiled/adventure TMX, TSX and image assets together.
• Complete the earlier input, GFX and resource tutorials.

What you will learn

• Load a TMX map through SceneMgr.
• Create custom objects with ISceneObjectFactory.
• Configure layers, callbacks and a target camera.
• Convert mouse coordinates and query an object layer.
• Constrain movement to a polygon.
• Drive interactions from TMX object properties.

Step by step

1. Create tutorial Scene objects

The factory creates one lightweight subclass for every TMX object. Only the player instance runs the custom movement update; inherited rendering needs no override.

class AdventureRenderObject : public SceneObject
{
public:
    void update(Scene*, SceneLayerContext& rContext) override
    {
        if(!g_pState) return;
        if(g_pState->pPlayer && getID() == g_pState->pPlayer->getID())
        {
            updatePlayerMovement(rContext.fDeltaTime);
        }
    }
};
 
class TutorialObjectFactory : public ISceneObjectFactory
{
public:
    SceneObject* create(const string&) override
    {
        return new(std::nothrow) AdventureRenderObject();
    }
};

2. Load and configure the Scene

Load the TMX with the factory, assign the centered viewport, enable both layers and attach the speech callback to the object layer.

const Sint32 iTE = mC64.sceneMgr().loadFromFile(BASEDIR "tiled/adventure/adventure.tmx", &sTutorialObjectFactory);
g_pState->pScene = mC64.sceneMgr().get(iTE);
if(!g_pState->pScene)
{
    if(pLog) pLog->msg(LL_ERROR, "Failed to load adventure map.\n");
    return false;
}
 
SDL_Rect rView = { iViewX, iViewY, iViewW, iViewH };
if(!g_pState->pScene->setViewport(&rView) ||
    !g_pState->pScene->setLayerFeatures(1, SLF_UPDATE | SLF_RENDER, true) ||
    !g_pState->pScene->setLayerFeatures(2, SLF_UPDATE | SLF_RENDER, true) ||
    !g_pState->pScene->setLayerFeatures(1, SLF_SMOOTHSCROLL, true) ||
    !g_pState->pScene->setLayerFeatures(2, SLF_SMOOTHSCROLL, true) ||
    !g_pState->pScene->setLayerOnRenderEnd(2, onLayerRenderSpeech))
{
    if(pLog) pLog->msg(LL_ERROR, "Failed to configure adventure Scene layers.\n");
    return false;
}

3. Resolve the required TMX objects

Find the player and optional movement area by type or name. The player is required; without area_player, movement remains unrestricted.

if((pObj->getType() == "player" || pObj->getName() == "player") && !g_pState->pPlayer)
{
    g_pState->pPlayer = pObj;
    g_pState->fTargetX = pObj->getX() + (pObj->getWidth() * 0.5f);
    g_pState->fTargetY = pObj->getY() + pObj->getHeight();
}
else if((pObj->getType() == "area_player" || pObj->getName() == "area_player") && !g_pState->pAreaPlayer)
{
    g_pState->pAreaPlayer = pObj;
}

if(!g_pState->pPlayer)
{
    if(pLog) pLog->msg(LL_ERROR, "Player object not found (name/type: player).\n");
    return false;
}
if(!g_pState->pAreaPlayer && pLog) pLog->msg(LL_WARNING, "area_player object not found.\n");

4. Follow the player with a smooth camera

Use the player's feet as the target anchor, center that point in the viewport and clamp camera movement to Scene bounds.

SceneCameraParams mCam;
mCam.fDamping = 10.0f;
mCam.bClampToBounds = true;
mCam.ptTargetAnchor = { 0.5f, 1.0f };
mCam.ptScreenAnchor = { 0.5f, 0.5f };
if(!g_pState->pScene->setCameraTarget(2, g_pState->pPlayer) ||
    !g_pState->pScene->setCameraParams(2, mCam) ||
    !g_pState->pScene->setCameraMode(2, SCM_SMOOTH))
{
    if(pLog) pLog->msg(LL_ERROR, "Failed to configure adventure camera.\n");
    return false;
}

5. Query objects under the pointer

Convert the mouse from screen to layer-world coordinates, query the spatial region and keep only shapes that contain the exact point.

const bool bCursorWorldValid = (g_pState->pScene && g_pState->pObjLayer &&
    g_pState->pScene->mouseToWorld(&fWX, &fWY, 2));
 
if(bCursorWorldValid)
{
    vector<SceneObject*> vCandidates;
    g_pState->pObjLayer->queryRegion(fWX, fWY, 1.0f, 1.0f, vCandidates);
 
    for(SceneObject* pObj : vCandidates)
    {
        if(pObj && pObj->containsPoint(fWX, fWY))
        {
            vHits.push_back(pObj);
        }
    }
}

6. Constrain movement to the polygon

Accept a point inside the area, try axis-aligned sliding, then fall back to the closest polygon boundary point.

// Keep a hotspot inside the player area.
static bool constrainHotspotToPlayerArea(float oldHotX, float oldHotY, float newHotX, float newHotY, float& rOutHotX, float& rOutHotY)
{
    if(isInsidePlayerArea(newHotX, newHotY))
    {
        rOutHotX = newHotX;
        rOutHotY = newHotY;
        return true;
    }
 
    if(isInsidePlayerArea(newHotX, oldHotY))
    {
        rOutHotX = newHotX;
        rOutHotY = oldHotY;
        return true;
    }
 
    if(isInsidePlayerArea(oldHotX, newHotY))
    {
        rOutHotX = oldHotX;
        rOutHotY = newHotY;
        return true;
    }
 
    float edgeX = oldHotX;
    float edgeY = oldHotY;
    if(nearestPointOnAreaBoundary(newHotX, newHotY, edgeX, edgeY))
    {
        rOutHotX = edgeX;
        rOutHotY = edgeY;
        return true;
    }
 
    return false;
}

7. Choose a right-click destination

Use the world point directly when it is inside the area, otherwise project it to the nearest boundary before starting movement.

if(g_pState->pAreaPlayer)
{
    bValidTarget = g_pState->pAreaPlayer->containsPoint(fTX, fTY);
    if(!bValidTarget)
    {
        bValidTarget = nearestPointOnAreaBoundary(fTX, fTY, fMoveTX, fMoveTY);
    }
}
 
if(bValidTarget)
{
    g_pState->fTargetX = fMoveTX;
    g_pState->fTargetY = fMoveTY;
    g_pState->bMoving = true;
}
else if(pLog) pLog->msg(LL_INFO, "Target out of area_player: (%.1f, %.1f)\n", fTX, fTY);

8. Read interaction properties

Require proximity, then read the TMX pickup and keydoor properties to select the gameplay action.

if(!isPlayerNearObject(pObj, fInteractDistance))
{
    setSpeech("I need to get closer.");
    continue;
}
 
const bool bPickup = pObj->getPropertyBool("pickup", false);
const Sint32 iKeyDoor = pObj->getPropertyInt("keydoor", -1);

9. Pick up the key safely

Copy the borrowed object's identity and remove it first. Inventory changes only after closeObject() succeeds.

if(bPickup)
{
    const Sint32 idObject = pObj->getID();
    const string sObjectName = pObj->getName();
    if(!g_pState->pObjLayer->closeObject(idObject))
    {
        if(pLog) pLog->msg(LL_ERROR, "Failed to pick up '%s'.\n", sObjectName.c_str());
        setSpeech("I couldn't pick that up.");
        continue;
    }
    if(iKeyDoor >= 0)
    {
        g_pState->iCollectedKeyDoor = iKeyDoor;
        g_pState->bHasKeyInInventory = true;
    }
    if(pLog) pLog->msg(LL_INFO, "Picked up '%s' (keydoor=%d)\n", sObjectName.c_str(), iKeyDoor);
    setSpeech("You got the key.");
    continue;
}

10. Unlock the matching door

A matching keydoor value removes the door, clears the inventory slot and ends the example. Failed removal leaves gameplay state untouched.

if(g_pState->iCollectedKeyDoor == iKeyDoor)
{
    const Sint32 idObject = pObj->getID();
    const string sObjectName = pObj->getName();
    if(!g_pState->pObjLayer->closeObject(idObject))
    {
        if(pLog) pLog->msg(LL_ERROR, "Failed to unlock '%s'.\n", sObjectName.c_str());
        setSpeech("The door would not open.");
        continue;
    }
    if(pLog) pLog->msg(LL_INFO, "Unlocked '%s' with keydoor=%d\n", sObjectName.c_str(), iKeyDoor);
    g_pState->bHasKeyInInventory = false;
    if(!g_pState->bGameFinished)
    {
        g_pState->bGameFinished = true;
        g_pState->pScene->pause();
        mC64.tool().messageBox("Adventure", "You unlocked the door. End of game.", MBB_OK, MBT_INFO);
        g_pState->pScene->resume();
        bDone = true;
        break;
    }
}

11. Render speech in layer coordinates

The layer callback converts a point above the player into screen coordinates and uses the font loaded during setup.

if(g_pState->pPlayer)
{
    SDL_FPoint pScreen = rContext.worldToScreen(
        g_pState->pPlayer->getX() + (g_pState->pPlayer->getWidth() * 0.5f) + 16.0f,
        g_pState->pPlayer->getY() - 20.0f, true);
    fTextX = pScreen.x;
    fTextY = pScreen.y;
}
 
if(fTextX < static_cast<float>(rContext.rViewport.x)) fTextX = static_cast<float>(rContext.rViewport.x);
if(fTextY < static_cast<float>(rContext.rViewport.y)) fTextY = static_cast<float>(rContext.rViewport.y);
 
pFont->setPosition(fTextX, fTextY);
pFont->render(g_pState->sSpeech.c_str());

12. Update and release in ownership order

Scene::update() advances objects and the camera. A shared cleanup function also handles partially completed setup, closing the Scene before the font and image resources it uses.

if(bDone) break;
g_pState->pScene->update();

static void closeTutorial()
{
    Main& mC64 = Main::instance();
    mC64.sceneMgr().close(0);
    mC64.fontMgr().close(0);
    mC64.imageMgr().close(0);
    Main::terminate();
}

mC64.sceneMgr().info();
closeTutorial();
return 0;

Complete source

The tutorial source is authoritative. The following listing is included directly from validation/source/Tutorial_16_Scene_Adventure.cpp.

/* ----------------------------------------------------------------------
    CRM64Pro GDK - Roberto Prieto
    Copyright (C) 2013-2026 MegaStorm Systems
 
    This software is provided 'as-is', without any express or implied
    warranty. In no event will the authors be held liable for any damages
    arising from the use of this software.
 
    Permission is granted to anyone to use this software for any purpose,
    including commercial applications, and to alter it and redistribute it
    freely, subject to the following restrictions:
 
    1. The origin of this software must not be misrepresented; you must not
       claim that you wrote the original software.
    2. Altered source versions must be plainly marked as such, and must not be
       misrepresented as being the original software.
    3. This notice may not be removed or altered from any source distribution.
 
------------------------------------------------------------------------
              Tutorial 16 Scene Adventure (Point&Click Basics)
------------------------------------------------------------------------
 
    Overview:
    This tutorial loads a point-and-click adventure map, moves the player with
    the mouse, picks up a key, and opens a matching door.
 
    Key concepts:
    - Load a TMX map with SceneMgr.
    - Use TMX object properties for gameplay data.
    - Query an object layer from the mouse position.
    - Move a SceneObject inside a polygon area.
    - Use a Screen render callback to draw the Scene.
 
    Layer layout:
    - Layer 1: Image world background.
    - Layer 2: Object layer (player, area_player, interactables).
 
    Controls:
    - Left-Click: Interact / pick up.
    - Right-Click: Move player.
    - S: Toggle smooth scroll.
    - D: Toggle object debug AABB and trigger zones.
    - Q / ESC: Quit.
 
    Loop order:
    - Poll events and capture mouse button edges.
    - Convert the mouse position to world coordinates.
    - Resolve hover, interaction and movement targets.
    - Run one fixed logic tick via Scene::update().
    - Let Scene update the camera.
    - Render from callback using Scene::render().
------------------------------------------------------------------------ */
 
#include "CRM64Pro.h"
#include "RunParameter.h"
 
using namespace CRM64Pro;
 
#define BASEDIR "Base/"
#ifdef CRM64PRO_PLATFORM_WINDOWS
#define OUTPUTDIR "Win64/"
#elif defined(CRM64PRO_PLATFORM_LINUX)
#define OUTPUTDIR "Linux/"
#elif defined(CRM64PRO_PLATFORM_MACOS)
#define OUTPUTDIR "macOS/"
#endif
 
#define RESOURCE_BG_CDC_NAME "Tutorial_bg"
#define OUTPUT_CDC OUTPUTDIR"Tutorial.cdc"
 
// Screen and viewport size.
static const Sint32 iScreenW = 960;
static const Sint32 iScreenH = 540;
static const Sint32 iViewW = 600;
static const Sint32 iViewH = 500;
static const Sint32 iViewX = (iScreenW - iViewW) / 2;
static const Sint32 iViewY = 0;
 
// Logic timing.
static const Sint32 iLogicRate = 20;
static const float fPlayerSpeed = 80.0f;
static const float fInteractDistance = 20.0f;
static const Uint32 iSpeechDurationMS = 1700;
 
struct TutorialState
{
    Scene* pScene = nullptr;
    Sint32 idBgImage = -1;
    Sint32 idGuiImage = -1;
    Sint32 idKeyImage = -1;
    Sint32 idBuiltInFont = -1;
    string sSpeech;
    Uint64 iSpeechUntil = 0;
    SceneLayerObject* pObjLayer = nullptr;
    SceneObject* pPlayer = nullptr;
    SceneObject* pAreaPlayer = nullptr;
    float fTargetX = 0.0f;
    float fTargetY = 0.0f;
    bool bMoving = false;
    Sint32 iCollectedKeyDoor = -1;
    bool bHasKeyInInventory = false;
    bool bGameFinished = false;
};
 
static TutorialState* g_pState = nullptr;
 
static void updatePlayerMovement(float fDeltaTime);
static void onLayerRenderSpeech(const SceneLayerContext& rContext);
 
class AdventureRenderObject : public SceneObject
{
public:
    void update(Scene*, SceneLayerContext& rContext) override
    {
        if(!g_pState) return;
        if(g_pState->pPlayer && getID() == g_pState->pPlayer->getID())
        {
            updatePlayerMovement(rContext.fDeltaTime);
        }
    }
};
 
class TutorialObjectFactory : public ISceneObjectFactory
{
public:
    SceneObject* create(const string&) override
    {
        return new(std::nothrow) AdventureRenderObject();
    }
};
 
// Show a speech message for the requested duration.
static void setSpeech(const string& sText, Uint32 iDurationMS = iSpeechDurationMS)
{
    g_pState->sSpeech = sText;
    g_pState->iSpeechUntil = Main::instance().timer().getTicks() + static_cast<Uint64>(iDurationMS);
}
 
// Check whether a hotspot is inside the player area.
static bool isInsidePlayerArea(float fHotX, float fHotY)
{
    if(!g_pState) return true;
    if(!g_pState->pAreaPlayer) return true;
    return g_pState->pAreaPlayer->containsPoint(fHotX, fHotY);
}
 
// Find the closest point on the player area boundary.
static bool nearestPointOnAreaBoundary(float px, float py, float& rOutX, float& rOutY)
{
    if(!g_pState) return false;
    if(!g_pState->pAreaPlayer) return false;
    const SceneShapeData& shape = g_pState->pAreaPlayer->getShape();
    if(shape.eType != SST_POLYGON || shape.vPoints.size() < 2) return false;
 
    const float baseX = g_pState->pAreaPlayer->getX();
    const float baseY = g_pState->pAreaPlayer->getY();
    float bestDist2 = 1.0e30f;
    float bestX = px;
    float bestY = py;
    const size_t n = shape.vPoints.size();
 
    for(size_t i = 0; i < n; ++i)
    {
        const SDL_FPoint& a = shape.vPoints[i];
        const SDL_FPoint& b = shape.vPoints[(i + 1) % n];
        const float ax = baseX + a.x;
        const float ay = baseY + a.y;
        const float bx = baseX + b.x;
        const float by = baseY + b.y;
        const float abx = bx - ax;
        const float aby = by - ay;
        const float apx = px - ax;
        const float apy = py - ay;
        const float abLen2 = (abx * abx) + (aby * aby);
 
        float t = 0.0f;
        if(abLen2 > 0.00001f)
        {
            t = ((apx * abx) + (apy * aby)) / abLen2;
            if(t < 0.0f) t = 0.0f;
            if(t > 1.0f) t = 1.0f;
        }
 
        const float qx = ax + (abx * t);
        const float qy = ay + (aby * t);
        const float dx = px - qx;
        const float dy = py - qy;
        const float d2 = (dx * dx) + (dy * dy);
        if(d2 < bestDist2)
        {
            bestDist2 = d2;
            bestX = qx;
            bestY = qy;
        }
    }
 
    rOutX = bestX;
    rOutY = bestY;
    return true;
}
 
// Keep a hotspot inside the player area.
static bool constrainHotspotToPlayerArea(float oldHotX, float oldHotY, float newHotX, float newHotY, float& rOutHotX, float& rOutHotY)
{
    if(isInsidePlayerArea(newHotX, newHotY))
    {
        rOutHotX = newHotX;
        rOutHotY = newHotY;
        return true;
    }
 
    if(isInsidePlayerArea(newHotX, oldHotY))
    {
        rOutHotX = newHotX;
        rOutHotY = oldHotY;
        return true;
    }
 
    if(isInsidePlayerArea(oldHotX, newHotY))
    {
        rOutHotX = oldHotX;
        rOutHotY = newHotY;
        return true;
    }
 
    float edgeX = oldHotX;
    float edgeY = oldHotY;
    if(nearestPointOnAreaBoundary(newHotX, newHotY, edgeX, edgeY))
    {
        rOutHotX = edgeX;
        rOutHotY = edgeY;
        return true;
    }
 
    return false;
}
 
// Check whether the player is close enough to an object.
static bool isPlayerNearObject(const SceneObject* pObj, float fMaxDistance)
{
    if(!g_pState) return false;
    if(!pObj || !g_pState->pPlayer) return false;
 
    // Player proximity uses full player box (not a single hotspot point).
    const float pX = g_pState->pPlayer->getX();
    const float pY = g_pState->pPlayer->getY();
    const float pW = g_pState->pPlayer->getWidth();
    const float pH = g_pState->pPlayer->getHeight();
    const float pMinX = pX;
    const float pMinY = pY;
    const float pMaxX = pX + pW;
    const float pMaxY = pY + pH;
 
    const Physics::AABB& aabb = pObj->getShape().AABB;
    const float oMinX = aabb.minX - fMaxDistance;
    const float oMinY = aabb.minY - fMaxDistance;
    const float oMaxX = aabb.maxX + fMaxDistance;
    const float oMaxY = aabb.maxY + fMaxDistance;
 
    const bool bOverlapX = (pMaxX >= oMinX) && (pMinX <= oMaxX);
    const bool bOverlapY = (pMaxY >= oMinY) && (pMinY <= oMaxY);
    return bOverlapX && bOverlapY;
}
 
// Adapt the renderer to the engine callback signature.
static Sint32 renderWrapper(Sint32)
{
    if(!g_pState || !g_pState->pScene) return 0;
 
    if(g_pState->idBgImage > 0)
    {
        Image* pBG = Main::instance().imageMgr().get(g_pState->idBgImage);
        if(pBG) pBG->render();
    }
 
    g_pState->pScene->render();
 
    // UI overlay (screen space): centered in the strip below the viewport.
    Image* pGUI = (g_pState->idGuiImage > 0) ? Main::instance().imageMgr().get(g_pState->idGuiImage) : nullptr;
    if(pGUI)
    {
        const float fGuiW = static_cast<float>(pGUI->getWidth());
        const float fGuiH = static_cast<float>(pGUI->getHeight());
        const float fGuiX = (static_cast<float>(iScreenW) - fGuiW) * 0.5f;
        const float fGuiAreaY = static_cast<float>(iViewY + iViewH);
        const float fGuiAreaH = static_cast<float>(iScreenH - (iViewY + iViewH));
        const float fGuiY = fGuiAreaY + ((fGuiAreaH - fGuiH) * 0.5f);
        SDL_FRect rGuiDst = { fGuiX, fGuiY, fGuiW, fGuiH };
        pGUI->render(0, nullptr, &rGuiDst);
 
        if(g_pState->bHasKeyInInventory && g_pState->idKeyImage > 0)
        {
            Image* pKey = Main::instance().imageMgr().get(g_pState->idKeyImage);
            if(pKey)
            {
                const float fKeyW = static_cast<float>(pKey->getWidth());
                const float fKeyH = static_cast<float>(pKey->getHeight());
                // Fixed inventory slot over gui.png (left-side slot).
                const float fKeyX = fGuiX + 10.0f;
                const float fKeyY = fGuiY + ((fGuiH - fKeyH) * 0.5f);
                SDL_FRect rKeyDst = { fKeyX, fKeyY, fKeyW, fKeyH };
                pKey->render(0, nullptr, &rKeyDst);
            }
        }
    }
 
    return 0;
}
 
// Draw the active speech message on the scene layer.
static void onLayerRenderSpeech(const SceneLayerContext& rContext)
{
    if(rContext.idLayer != 2) return;
    if(g_pState->sSpeech.empty()) return;
    if(Main::instance().timer().getTicks() > g_pState->iSpeechUntil) return;
 
    Font* pFont = Main::instance().fontMgr().get(g_pState->idBuiltInFont);
    if(!pFont) return;
 
    float fTextX = static_cast<float>(rContext.rViewport.x + 14);
    float fTextY = static_cast<float>(rContext.rViewport.y + 14);
 
    if(g_pState->pPlayer)
    {
        SDL_FPoint pScreen = rContext.worldToScreen(
            g_pState->pPlayer->getX() + (g_pState->pPlayer->getWidth() * 0.5f) + 16.0f,
            g_pState->pPlayer->getY() - 20.0f, true);
        fTextX = pScreen.x;
        fTextY = pScreen.y;
    }
 
    if(fTextX < static_cast<float>(rContext.rViewport.x)) fTextX = static_cast<float>(rContext.rViewport.x);
    if(fTextY < static_cast<float>(rContext.rViewport.y)) fTextY = static_cast<float>(rContext.rViewport.y);
 
    pFont->setPosition(fTextX, fTextY);
    pFont->render(g_pState->sSpeech.c_str());
}
 
// Load the map and find the objects used by the tutorial.
static bool loadMapAndResolveObjects()
{
    if(!g_pState) return false;
    Main& mC64 = Main::instance();
    Log* pLog = mC64.logMgr().get();
    static TutorialObjectFactory sTutorialObjectFactory;
 
    const Sint32 iTE = mC64.sceneMgr().loadFromFile(BASEDIR "tiled/adventure/adventure.tmx", &sTutorialObjectFactory);
    g_pState->pScene = mC64.sceneMgr().get(iTE);
    if(!g_pState->pScene)
    {
        if(pLog) pLog->msg(LL_ERROR, "Failed to load adventure map.\n");
        return false;
    }
 
    SDL_Rect rView = { iViewX, iViewY, iViewW, iViewH };
    if(!g_pState->pScene->setViewport(&rView) ||
        !g_pState->pScene->setLayerFeatures(1, SLF_UPDATE | SLF_RENDER, true) ||
        !g_pState->pScene->setLayerFeatures(2, SLF_UPDATE | SLF_RENDER, true) ||
        !g_pState->pScene->setLayerFeatures(1, SLF_SMOOTHSCROLL, true) ||
        !g_pState->pScene->setLayerFeatures(2, SLF_SMOOTHSCROLL, true) ||
        !g_pState->pScene->setLayerOnRenderEnd(2, onLayerRenderSpeech))
    {
        if(pLog) pLog->msg(LL_ERROR, "Failed to configure adventure Scene layers.\n");
        return false;
    }
 
    if(pLog)
    {
        SceneLayerImage* pL1 = g_pState->pScene->accessLayerImage(1);
        SceneLayerObject* pL2 = g_pState->pScene->accessLayerObject(2);
        const float fL1W = (pL1 ? pL1->getTotalWidth() : -1.0f);
        const float fL1H = (pL1 ? pL1->getTotalHeight() : -1.0f);
        const float fL2W = (pL2 ? pL2->getTotalWidth() : -1.0f);
        const float fL2H = (pL2 ? pL2->getTotalHeight() : -1.0f);
 
        pLog->msg(LL_INFO, "Adventure: layer 1 image size: %.1fx%.1f | layer 2 object size: %.1fx%.1f | Scene size: %dx%d\n",
            fL1W, fL1H, fL2W, fL2H, g_pState->pScene->getWidth(), g_pState->pScene->getHeight());
    }
 
    g_pState->pObjLayer = g_pState->pScene->accessLayerObject(2);
    if(!g_pState->pObjLayer)
    {
        if(pLog) pLog->msg(LL_ERROR, "Object layer not found at index 2.\n");
        return false;
    }
    g_pState->pObjLayer->setRenderOrderMode(SORO_FEET);
 
    vector<SceneObject*> vObjects;
    g_pState->pObjLayer->queryRegion(0.0f, 0.0f, 100000.0f, 100000.0f, vObjects);
 
    for(SceneObject* pObj : vObjects)
    {
        if(pLog)
        {
            pLog->msg(LL_INFO, "Adventure object loaded: id=%d name='%s' type='%s'\n",
                pObj->getID(), pObj->getName().c_str(), pObj->getType().c_str());
        }
        const string& rType = pObj->getType();
        if(rType.empty() ||
            (rType != "player" &&
             rType != "area_player" &&
             rType != "interact"))
        {
            if(pLog)
            {
                pLog->msg(LL_WARNING,
                    "Unsupported adventure object type: id=%d name='%s' type='%s'\n",
                    pObj->getID(), pObj->getName().c_str(), pObj->getType().c_str());
            }
        }
 
        if((pObj->getType() == "player" || pObj->getName() == "player") && !g_pState->pPlayer)
        {
            g_pState->pPlayer = pObj;
            g_pState->fTargetX = pObj->getX() + (pObj->getWidth() * 0.5f);
            g_pState->fTargetY = pObj->getY() + pObj->getHeight();
        }
        else if((pObj->getType() == "area_player" || pObj->getName() == "area_player") && !g_pState->pAreaPlayer)
        {
            g_pState->pAreaPlayer = pObj;
        }
    }
 
    if(!g_pState->pPlayer)
    {
        if(pLog) pLog->msg(LL_ERROR, "Player object not found (name/type: player).\n");
        return false;
    }
    if(!g_pState->pAreaPlayer && pLog) pLog->msg(LL_WARNING, "area_player object not found.\n");
 
    SceneCameraParams mCam;
    mCam.fDamping = 10.0f;
    mCam.bClampToBounds = true;
    mCam.ptTargetAnchor = { 0.5f, 1.0f };
    mCam.ptScreenAnchor = { 0.5f, 0.5f };
    if(!g_pState->pScene->setCameraTarget(2, g_pState->pPlayer) ||
        !g_pState->pScene->setCameraParams(2, mCam) ||
        !g_pState->pScene->setCameraMode(2, SCM_SMOOTH))
    {
        if(pLog) pLog->msg(LL_ERROR, "Failed to configure adventure camera.\n");
        return false;
    }
 
    return true;
}
 
// Move the player according to the current input.
static void updatePlayerMovement(float fDeltaTime)
{
    if(!g_pState) return;
    if(!g_pState->bMoving || !g_pState->pPlayer) return;
 
    const float fHotX = g_pState->pPlayer->getX() + (g_pState->pPlayer->getWidth() * 0.5f);
    const float fHotY = g_pState->pPlayer->getY() + g_pState->pPlayer->getHeight();
    const float fDX = g_pState->fTargetX - fHotX;
    const float fDY = g_pState->fTargetY - fHotY;
    const float fDist = sqrtf(fDX * fDX + fDY * fDY);
    const float fStep = fPlayerSpeed * fDeltaTime;
 
    if(fDist <= fStep || fDist <= 0.001f)
    {
        float fOutHotX = fHotX;
        float fOutHotY = fHotY;
        if(constrainHotspotToPlayerArea(fHotX, fHotY, g_pState->fTargetX, g_pState->fTargetY, fOutHotX, fOutHotY))
        {
            g_pState->pPlayer->setPosition(fOutHotX - (g_pState->pPlayer->getWidth() * 0.5f), fOutHotY - g_pState->pPlayer->getHeight());
        }
        g_pState->bMoving = false;
        return;
    }
 
    const float fInvDist = 1.0f / fDist;
    const float fNewHotX = fHotX + (fDX * fInvDist * fStep);
    const float fNewHotY = fHotY + (fDY * fInvDist * fStep);
    float fOutHotX = fHotX;
    float fOutHotY = fHotY;
 
    if(!constrainHotspotToPlayerArea(fHotX, fHotY, fNewHotX, fNewHotY, fOutHotX, fOutHotY))
    {
        g_pState->bMoving = false;
        return;
    }
 
    g_pState->pPlayer->setPosition(fOutHotX - (g_pState->pPlayer->getWidth() * 0.5f), fOutHotY - g_pState->pPlayer->getHeight());
}
 
// Close resources in ownership order, including partially completed setup.
static void closeTutorial()
{
    Main& mC64 = Main::instance();
    mC64.sceneMgr().close(0);
    mC64.fontMgr().close(0);
    mC64.imageMgr().close(0);
    Main::terminate();
}
 
// Run the tutorial application and release its resources.
int main(int argc, char* argv[])
{
    eConfigRendererDriver eRenderer = CRD_SOFTWARE;
    if(!runParameterReadRender(argc, argv, eRenderer)) return 1;
 
    CMem::setStatsLevel(CMem::MSL_HIGH);
    atexit(CMem::destroy);
 
    Main& mC64 = Main::instance();
    TutorialState state;
    g_pState = &state;
 
    Log* pLog = mC64.logMgr().get();
 
    pLog->init("Tutorial_16_Scene_Adventure", LL_DEBUG, LM_FILE | LM_STDOUT, OUTPUTDIR"Tutorial_16_Scene_Adventure.log");
    if(!mC64.timer().init() || !mC64.timer().setRate(0, iLogicRate))
    {
        if(pLog) pLog->msg(LL_ERROR, "Failed to initialize tutorial timing.\n");
        Main::terminate();
        return -1;
    }
    mC64.configMgr().setMTFriendly(1);
 
    Screen* pScreen = mC64.configMgr().get();
    pScreen->setSize(iScreenW, iScreenH);
    pScreen->setDriver(eRenderer);
    pScreen->setTitle("Tutorial 16 Scene - Adventure");
    if(pScreen->show() < 0)
    {
        Main::terminate();
        return -1;
    }
    if(!pScreen->setRenderCallback(renderWrapper))
    {
        if(pLog) pLog->msg(LL_ERROR, "Failed to set the render callback.\n");
        Main::terminate();
        return -1;
    }
    g_pState->idBgImage = mC64.imageMgr().load(OUTPUT_CDC, RESOURCE_BG_CDC_NAME);
    g_pState->idGuiImage = mC64.imageMgr().loadFromFile(BASEDIR "tiled/adventure/gui.png");
    g_pState->idKeyImage = mC64.imageMgr().loadFromFile(BASEDIR "tiled/adventure/key.png", "keyGUI");
    g_pState->idBuiltInFont = mC64.fontMgr().getBuiltin("CourierNew10White");
    if(g_pState->idBgImage <= 0 || g_pState->idGuiImage <= 0 || g_pState->idKeyImage <= 0 ||
        g_pState->idBuiltInFont <= 0 || !mC64.fontMgr().get(g_pState->idBuiltInFont))
    {
        if(pLog) pLog->msg(LL_ERROR, "Failed to load adventure background, UI or font resources.\n");
        closeTutorial();
        return -1;
    }
 
    if(!loadMapAndResolveObjects())
    {
        closeTutorial();
        return -1;
    }
 
    if(pLog)
    {
        pLog->msg(LL_INFO, "Adventure tutorial loaded.\n");
        pLog->msg(LL_INFO, "\nCONTROLS:\n [Left-Click] Interact with objects\n [Right-Click] Move\n [S] Toggle smooth scroll\n [D] Toggle object AABB\n [Q/Esc] Quit\n\n");
    }
 
    SDL_Event ev;
    bool bDone = false;
    bool bSmooth = true;
 
    while(!bDone)
    {
        while(mC64.update(&ev))
        {
            if(ev.type == SDL_EVENT_QUIT) bDone = true;
            if(ev.type == SDL_EVENT_KEY_DOWN)
            {
                if(ev.key.key == SDLK_ESCAPE || ev.key.key == SDLK_Q) bDone = true;
                if(ev.key.key == SDLK_S && g_pState->pScene)
                {
                    bSmooth = !bSmooth;
                    g_pState->pScene->setLayerFeatures(1, SLF_SMOOTHSCROLL, bSmooth);
                    g_pState->pScene->setLayerFeatures(2, SLF_SMOOTHSCROLL, bSmooth);
                    if(pLog) pLog->msg(LL_INFO, "Smooth scroll: %s\n", bSmooth ? "ON" : "OFF");
                }
                if(ev.key.key == SDLK_D && g_pState->pObjLayer)
                {
                    const bool bEnabled = !g_pState->pScene->isDebugObjectOverlayEnabled(SDO_OBJECT_AABB, SDOT_STANDARD);
                    g_pState->pScene->setDebugObjectOverlay(SDO_OBJECT_AABB, SDOT_STANDARD, bEnabled);
                    g_pState->pScene->setDebugObjectOverlay(SDO_TRIGGER_ZONES, SDOT_STANDARD, bEnabled);
                    if(pLog) pLog->msg(LL_INFO, "Debug AABB: %s\n", bEnabled ? "ON" : "OFF");
                }
            }
        }
        if(bDone) break;
 
        const Sint32 iMouseButtons = mC64.cursorMgr().getButtons();
        const Sint32 iMouseButtonsPrev = mC64.cursorMgr().getButtonsPrev();
        const bool bLeftPressed =
            ((iMouseButtons & SDL_BUTTON_MASK(SDL_BUTTON_LEFT)) != 0) &&
            ((iMouseButtonsPrev & SDL_BUTTON_MASK(SDL_BUTTON_LEFT)) == 0);
        const bool bRightPressed =
            ((iMouseButtons & SDL_BUTTON_MASK(SDL_BUTTON_RIGHT)) != 0) &&
            ((iMouseButtonsPrev & SDL_BUTTON_MASK(SDL_BUTTON_RIGHT)) == 0);
 
        float fWX = 0.0f;
        float fWY = 0.0f;
        vector<SceneObject*> vHits;
 
        const bool bCursorWorldValid = (g_pState->pScene && g_pState->pObjLayer &&
            g_pState->pScene->mouseToWorld(&fWX, &fWY, 2));
 
        if(bCursorWorldValid)
        {
            vector<SceneObject*> vCandidates;
            g_pState->pObjLayer->queryRegion(fWX, fWY, 1.0f, 1.0f, vCandidates);
 
            for(SceneObject* pObj : vCandidates)
            {
                if(pObj && pObj->containsPoint(fWX, fWY))
                {
                    vHits.push_back(pObj);
                }
            }
        }
 
        bool bHoverInteract = false;
        for(SceneObject* pObj : vHits)
        {
            if(pObj->getType() == "interact")
            {
                bHoverInteract = true;
                break;
            }
        }
        mC64.cursorMgr().select(bHoverInteract ? SDL_SYSTEM_CURSOR_POINTER : SDL_SYSTEM_CURSOR_DEFAULT);
 
        if(bLeftPressed)
        {
            for(SceneObject* pObj : vHits)
            {
                if(!pObj || pObj->getType() != "interact") continue;
 
                if(!isPlayerNearObject(pObj, fInteractDistance))
                {
                    setSpeech("I need to get closer.");
                    continue;
                }
 
                const bool bPickup = pObj->getPropertyBool("pickup", false);
                const Sint32 iKeyDoor = pObj->getPropertyInt("keydoor", -1);
 
                if(bPickup)
                {
                    const Sint32 idObject = pObj->getID();
                    const string sObjectName = pObj->getName();
                    if(!g_pState->pObjLayer->closeObject(idObject))
                    {
                        if(pLog) pLog->msg(LL_ERROR, "Failed to pick up '%s'.\n", sObjectName.c_str());
                        setSpeech("I couldn't pick that up.");
                        continue;
                    }
                    if(iKeyDoor >= 0)
                    {
                        g_pState->iCollectedKeyDoor = iKeyDoor;
                        g_pState->bHasKeyInInventory = true;
                    }
                    if(pLog) pLog->msg(LL_INFO, "Picked up '%s' (keydoor=%d)\n", sObjectName.c_str(), iKeyDoor);
                    setSpeech("You got the key.");
                    continue;
                }
 
                if(iKeyDoor >= 0)
                {
                    if(g_pState->iCollectedKeyDoor == iKeyDoor)
                    {
                        const Sint32 idObject = pObj->getID();
                        const string sObjectName = pObj->getName();
                        if(!g_pState->pObjLayer->closeObject(idObject))
                        {
                            if(pLog) pLog->msg(LL_ERROR, "Failed to unlock '%s'.\n", sObjectName.c_str());
                            setSpeech("The door would not open.");
                            continue;
                        }
                        if(pLog) pLog->msg(LL_INFO, "Unlocked '%s' with keydoor=%d\n", sObjectName.c_str(), iKeyDoor);
                        g_pState->bHasKeyInInventory = false;
                        if(!g_pState->bGameFinished)
                        {
                            g_pState->bGameFinished = true;
                            g_pState->pScene->pause();
                            mC64.tool().messageBox("Adventure", "You unlocked the door. End of game.", MBB_OK, MBT_INFO);
                            g_pState->pScene->resume();
                            bDone = true;
                            break;
                        }
                    }
                    else
                    {
                        if(pLog) pLog->msg(LL_INFO, "'%s' is locked. Missing keydoor=%d\n", pObj->getName().c_str(), iKeyDoor);
                        setSpeech("It's locked.");
                    }
                }
            }
        }
 
        if(bRightPressed && g_pState->pPlayer && bCursorWorldValid)
        {
            const float fTX = fWX;
            const float fTY = fWY;
            bool bValidTarget = true;
            float fMoveTX = fTX;
            float fMoveTY = fTY;
 
            if(g_pState->pAreaPlayer)
            {
                bValidTarget = g_pState->pAreaPlayer->containsPoint(fTX, fTY);
                if(!bValidTarget)
                {
                    bValidTarget = nearestPointOnAreaBoundary(fTX, fTY, fMoveTX, fMoveTY);
                }
            }
 
            if(bValidTarget)
            {
                g_pState->fTargetX = fMoveTX;
                g_pState->fTargetY = fMoveTY;
                g_pState->bMoving = true;
            }
            else if(pLog) pLog->msg(LL_INFO, "Target out of area_player: (%.1f, %.1f)\n", fTX, fTY);
        }
 
        if(bDone) break;
        g_pState->pScene->update();
    }
    mC64.sceneMgr().info();
    closeTutorial();
    return 0;
}

Navigation

Previous: Tutorial 15 - Network

Back to the tutorials index

Next: Tutorial 16.2 - Island Game v2