gfCAutoTestAim.h

Go to the documentation of this file.

/********************************************************************
*
*       File:           gfCAutoTestAim.h
*
*       Purpose:        Auto play aimed input - cheat the aim, never the result
*
*********************************************************************/
 
#ifndef gfCAutoTestAimhdr
#define gfCAutoTestAimhdr
 
#include <vector>
 
#include <fsCore/fsBaseTypes.h>
#include <fsCore/fsPoint.h>
#include <fsCore/fsStr.h>
 
class fsCEntity;
class fsIComponent;
class gfCAutoTestPointer;
class gfCJigsawMinigameComponent;
 
 
// Asks the scene where a thing is, then sends real pointer events at it, so the
// input path still runs in full. It reports a landed/attempted ratio, never a
// failure - it cannot tell "broken" from "not available to the player yet".
class gfCAutoTestAim
{
public:
 
        gfCAutoTestAim(const fsIComponent& pOwner, gfCAutoTestPointer& pPointer, fsS32 pMissLimit);
 
        // Each returns true if it made an attempt.
        fsBool tapTry();
        // Starts a drag of a key onto a lock; finish with dragVerdictRecord().
        fsBool dragTry();
        // Taps a loose jigsaw piece upright, then drags it onto its home.
        fsBool jigsawTry(const std::vector<fsCEntity*>& pPieces);
        // Call once the drag dragTry() or jigsawTry() started has dropped.
        void dragVerdictRecord();
        // The drag was released early - it owes no verdict.
        void dragForget();
 
        // Logs the finished level's tally and forgets per-level state - entities are per level.
        void levelChange();
        // Logs the last level's tally and the total for the whole run.
        void runEnd();
 
private:
 
        void tallyReport();
 
        // True while the tutorial sequencer is consuming every pointer message.
        fsBool tutorialInputStolenGet() const;
 
        fsCEntity* tapTargetGet() const;
        // The loose piece the last pointer down picked up, if any.
        static fsCEntity* jigsawGrabbedPieceGet(const std::vector<fsCEntity*>& pPieces, const fsPoint& pAt);
        // pLocalPos in posGet() space of the space the piece is dragged in.
        static fsPoint jigsawScreenPosGet(gfCJigsawMinigameComponent* pPiece, const fsPoint& pLocalPos);
        // Scene INS keys plus inventory INT tools - both open locks.
        std::vector<fsCEntity*> draggableKeyEntitiesGet() const;
        fsBool dragKeyRefusedGet() const;
 
        fsS32 missesGet(const fsCEntity* pEnt) const;
        // Ages a target out of aiming, forcing a lock open once it has given up.
        void missAdvance(fsCEntity* pEnt, const fsStr& pWhat);
        // pWhat is the miss reason as tallied; pDetail only goes into the give-up note.
        void outcomeRecord(fsCEntity* pEnt, fsBool pTaken, const fsStr& pWhat, const fsStr& pDetail = "");
 
        const fsIComponent& mOwner;
        gfCAutoTestPointer& mPointer;
 
        // Targets written off after mMissLimit tries, so one stuck entity does not
        // stall the aiming or report itself over and over.
        struct sMiss
        {
                const fsCEntity* mEnt;
                fsS32 mMisses;
        };
        std::vector<sMiss> mMisses;
        const fsS32 mMissLimit;
 
        // Attempts and how many landed - this level, then the whole run.
        fsS32 mTried;
        fsS32 mTaken;
        fsS32 mRunTried;
        fsS32 mRunTaken;
        fsStr mLevelName;
 
        // This level's misses by reason, logged with the tally.
        struct sMissReason
        {
                fsStr mWhat;
                fsS32 mCount;
        };
        std::vector<sMissReason> mMissReasons;
 
        // Rotates the starting lock, so it cannot loop on a pair the tutorial
        // sequencer will never accept.
        fsS32 mLockCursor;
        fsS32 mPieceCursor;
 
        // The aimed drag in flight, checked when it drops - a key onto a lock, or a
        // jigsaw piece onto its home.
        fsCEntity* mDragLockEnt;
        fsCEntity* mDragKeyEnt;
        fsCEntity* mDragPieceEnt;
        fsStr mDragFailReason;
};
 
#endif