C4Command Class Reference

#include <C4Command.h>

Collaboration diagram for C4Command:

Public Member Functions
	C4Command ()
	~C4Command ()
void	Set (int32_t iCommand, C4Object *pObj, C4Object *pTarget, C4Value iTx, int32_t iTy, C4Object *pTarget2, C4Value iData, int32_t iUpdateInterval, bool fEvaluated, int32_t iRetries, C4String *szText, int32_t iBaseMode)
void	Clear ()
void	Execute ()
void	ClearPointers (C4Object *pObj)
void	Default ()
void	Denumerate (C4ValueNumbers *)
void	CompileFunc (StdCompiler *pComp, C4ValueNumbers *)

Public Attributes
C4Object *	cObj
int32_t	Command
C4Value	Tx
int32_t	Ty
C4ObjectPtr	Target
C4ObjectPtr	Target2
C4Value	Data
int32_t	UpdateInterval
int32_t	Evaluated
int32_t	PathChecked
int32_t	Finished
int32_t	Failures
int32_t	Retries
int32_t	Permit
C4String *	Text
C4Command *	Next
int32_t	iExec
int32_t	BaseMode

Protected Member Functions
void	Call ()
void	Home ()
void	Retry ()
void	Fail (const char *szFailMessage=nullptr)
void	Acquire ()
void	Sell ()
void	Buy ()
void	Attack ()
void	Transfer ()
void	Finish (bool fSuccess=false, const char *szFailMessage=nullptr)
void	Follow ()
void	MoveTo ()
void	Enter ()
void	Exit ()
void	Grab ()
void	UnGrab ()
void	Throw ()
void	Jump ()
void	Wait ()
void	Take ()
void	Take2 ()
bool	GetTryEnter ()
void	Get ()
void	Put ()
void	Drop ()
void	Dig ()
void	Activate ()
void	PushTo ()
int32_t	CallFailed ()
bool	JumpControl ()
bool	FlightControl ()
bool	InitEvaluation ()
int32_t	GetExpGain ()

Detailed Description

Definition at line 74 of file C4Command.h.

Constructor & Destructor Documentation

C4Command()

C4Command::C4Command

(

)

Definition at line 197 of file C4Command.cpp.

{
    Default();
}

References Default().

Here is the call graph for this function:

~C4Command()

C4Command::~C4Command

(

)

Definition at line 202 of file C4Command.cpp.

{
    Clear();
}

References Clear().

Here is the call graph for this function:

Member Function Documentation

Acquire()

void C4Command::Acquire ( )

protected

Definition at line 1655 of file C4Command.cpp.

{
 
    // No type to acquire specified: fail
    if (!Data) { Finish(); return; }
 
    // Target material in inventory: done
    if (cObj->Contents.Find(Data.getDef()))
        { Finish(true); return; }
 
    // script overload
    int32_t scriptresult = cObj->Call(PSF_ControlCommandAcquire, &C4AulParSet(Target, Tx, Ty, Target2, Data)).getInt ();
 
    // script call might have deleted object
    if (!cObj->Status) return;
    if (1 == scriptresult) return;
    if (2 == scriptresult)
        { Finish(true); return; }
    if (3 == scriptresult)
        { Finish(); return; }
 
    // Find available material
    C4Object *pMaterial=nullptr;
    // Next closest
    while ((pMaterial = Game.FindObject(Data.getDef(),cObj->GetX(),cObj->GetY(),-1,-1,OCF_Available,pMaterial)))
        // Object is not in container to be ignored
        if (!Target2 || pMaterial->Contained!=Target2)
            // Object is near enough
            if (Inside(cObj->GetX()-pMaterial->GetX(),-Tx._getInt(),+Tx._getInt()))
                if (Inside(cObj->GetY()-pMaterial->GetY(),-Ty,+Ty))
                    // Must be complete
                    if (pMaterial->OCF & OCF_FullCon)
                        // Doesn't burn
                        if (!pMaterial->GetOnFire())
                            // We found one
                            break;
 
    // Available material found: get material
    if (pMaterial)
        { cObj->AddCommand(C4CMD_Get,pMaterial,0,0,40); return; }
 
    // No available material found: buy material
    // This command will fail immediately if buying at bases is not possible
    // - but the command should be created anyway because it might be overloaded
    cObj->AddCommand(C4CMD_Buy,nullptr,0,0,100,nullptr,true,Data,false,0,nullptr,C4CMD_Mode_Sub);
 
}

References C4Value::_getInt(), C4Object::AddCommand(), C4CMD_Buy, C4CMD_Get, C4CMD_Mode_Sub, C4PropList::Call(), cObj, C4Object::Contained, C4Object::Contents, Data, C4ObjectList::Find(), C4Game::FindObject(), Finish(), Game, C4Value::getDef(), C4Value::getInt(), C4Object::GetOnFire(), C4Object::GetX(), C4Object::GetY(), Inside(), C4Object::OCF, OCF_Available, OCF_FullCon, PSF_ControlCommandAcquire, C4PropList::Status, Target, Target2, Tx, and Ty.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Activate()

void C4Command::Activate ( )

protected

Definition at line 1105 of file C4Command.cpp.

{
 
    // Container specified, but no Target & no type: open activate menu for container
    if (Target2 && !Target && !Data)
    {
        cObj->ActivateMenu(C4MN_Activate,0,0,0,Target2);
        Finish(true);
        return;
    }
 
    // Target object specified & outside: success
    if (Target)
        if (!Target->Contained)
            { Finish(true); return; }
 
    // No container specified: determine container by target object
    if (!Target2)
        if (Target)
            Target2=Target->Contained;
 
    // No container specified: fail
    if (!Target2) { Finish(); return; }
 
    // Digging: stop
    if (cObj->GetProcedure()==DFA_DIG) ObjectComStop(cObj);
 
    // In container
    if (cObj->Contained==Target2)
    {
        for (Tx.SetInt(Data ? std::max<int32_t>(Tx._getInt(),1) : 1); Tx._getInt(); --Tx)
        {
            // If not specified get object from target contents by type
            // Find first object requested id that has no command exit yet
            if (!Target)
                for (C4Object *pObj : Target2->Contents)
                    if (pObj->Status && (pObj->Def==Data.getDef()))
                        if (!pObj->Command || (pObj->Command->Command!=C4CMD_Exit))
                            { Target=pObj; break; }
            // No target
            if (!Target) { Finish(); return; }
 
            // Thing in own container (target2)
            if (Target->Contained!=Target2) { Finish(); return; }
 
            // Activate object to exit
            Target->Controller = cObj->Controller;
            Target->SetCommand(C4CMD_Exit);
            Target = nullptr;
        }
 
        Finish(true); return;
    }
 
    // Leave own container
    if (cObj->Contained)
        { cObj->AddCommand(C4CMD_Exit,nullptr,0,0,50); return; }
 
    // Target container has entrance: enter
    if (Target2->OCF & OCF_Entrance)
        { cObj->AddCommand(C4CMD_Enter,Target2,0,0,50); return; }
 
    // Can't get to target due to target container: fail
    Finish();
 
}

References C4Value::_getInt(), C4Object::ActivateMenu(), C4Object::AddCommand(), C4CMD_Enter, C4CMD_Exit, C4MN_Activate, cObj, Command, C4Object::Command, C4Object::Contained, C4Object::Contents, C4Object::Controller, Data, C4Object::Def, DFA_DIG, Finish(), C4Value::getDef(), C4Object::GetProcedure(), ObjectComStop(), C4Object::OCF, OCF_Entrance, C4Object::SetCommand(), C4Value::SetInt(), C4PropList::Status, Target, Target2, and Tx.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Attack()

void C4Command::Attack ( )

protected

Definition at line 1600 of file C4Command.cpp.

{
 
    // No target: failure
    if (!Target) { Finish(); return; }
 
    // Target is crew member
    if (Target->OCF & OCF_CrewMember)
    {
 
        // Throw projectile at target
        for (C4Object *pProjectile : cObj->Contents)
            if (pProjectile->Def->Projectile)
            {
                // Add throw command
                cObj->AddCommand(C4CMD_Throw,pProjectile,Target->GetX(),Target->GetY(),2);
                return;
            }
 
        // Follow containment
        if (cObj->Contained!=Target->Contained)
        {
            // Exit
            if (cObj->Contained) cObj->AddCommand(C4CMD_Exit,nullptr,0,0,10);
            // Enter
            else cObj->AddCommand(C4CMD_Enter,Target->Contained,0,0,10);
            return;
        }
 
        // Move to target
        cObj->AddCommand(C4CMD_MoveTo,nullptr,Target->GetX(),Target->GetY(),10);
        return;
 
    }
 
    // For now, attack crew members only
    else
    {
        // Success, target might be no crew member due to that is has been killed
        Finish(true);
        return;
    }
 
}

References C4Object::AddCommand(), C4CMD_Enter, C4CMD_Exit, C4CMD_MoveTo, C4CMD_Throw, cObj, C4Object::Contained, C4Object::Contents, C4Object::Def, Finish(), C4Object::GetX(), C4Object::GetY(), C4Object::OCF, OCF_CrewMember, C4Def::Projectile, and Target.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Buy()

void C4Command::Buy ( )

protected

Definition at line 1645 of file C4Command.cpp.

{
    Finish();
}

References Finish().

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Call()

void C4Command::Call ( )

protected

Definition at line 1833 of file C4Command.cpp.

{
    // No function name: fail
    if (!Text || !Text->GetCStr() || !Text->GetCStr()[0]) { Finish(); return; }
    // No target object: fail
    if (!Target) { Finish(); return; }
    // Done: success
    Finish(true);
    // Object call FIXME:use c4string-api
    Target->Call(Text->GetCStr(),&C4AulParSet(cObj, Tx, Ty, Target2));
    // Extreme caution notice: the script call might do just about anything
    // including clearing all commands (including this) i.e. through a call
    // to SetCommand. Thus, we must not do anything in this command anymore
    // after the script call (even the Finish has to be called before).
    // The Finish call being misled to the freshly created Build command (by
    // chance, the this-pointer was simply crap at the time) was reason for
    // the latest sync losses in 4.62.
}

References C4PropList::Call(), cObj, Finish(), C4String::GetCStr(), Target, Target2, Text, Tx, and Ty.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

CallFailed()

int32_t C4Command::CallFailed ( )

protected

Definition at line 1918 of file C4Command.cpp.

{
    // No function name or no target object: cannot call fail-function
    if (!Text || !Text->GetCStr() || !Text->GetCStr()[0] || !Target) return 0;
    // Compose fail-function name
    char szFunctionFailed[1024+1]; sprintf(szFunctionFailed,"~%sFailed",Text->GetCStr());
    // Call failed-function
    return Target->Call(szFunctionFailed,&C4AulParSet(cObj, Tx, Ty, Target2))._getInt();
    // Extreme caution notice: the script call might do just about anything
    // including clearing all commands (including this) i.e. through a call
    // to SetCommand. Thus, we must not do anything in this command anymore
    // after the script call.
}

References C4Value::_getInt(), C4PropList::Call(), cObj, C4String::GetCStr(), sprintf, Target, Target2, Text, Tx, and Ty.

Referenced by Fail().

Here is the call graph for this function:

Here is the caller graph for this function:

Clear()

void C4Command::Clear

(

)

Definition at line 1456 of file C4Command.cpp.

{
    Command=C4CMD_None;
    cObj=nullptr;
    Evaluated=false;
    PathChecked=false;
    Tx=C4VNull;
    Ty=0;
    Target=Target2=nullptr;
    UpdateInterval=0;
    if (Text) Text->DecRef();
    Text=nullptr;
    BaseMode=C4CMD_Mode_SilentSub;
}

References BaseMode, C4CMD_Mode_SilentSub, C4CMD_None, C4VNull, cObj, Command, C4RefCnt::DecRef(), Evaluated, PathChecked, Target, Target2, Text, Tx, Ty, and UpdateInterval.

Referenced by Set(), and ~C4Command().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearPointers()

void C4Command::ClearPointers

(

C4Object *

pObj

)

Definition at line 1288 of file C4Command.cpp.

{
    if (cObj==pObj) cObj=nullptr;
    if (Target==pObj) Target=nullptr;
    if (Target2==pObj) Target2=nullptr;
}

References cObj, Target, and Target2.

Referenced by C4Object::ClearPointers().

Here is the caller graph for this function:

CompileFunc()

void C4Command::CompileFunc	(	StdCompiler *	pComp,
		C4ValueNumbers *	numbers
	)

Definition at line 1852 of file C4Command.cpp.

{
    // Version
    int32_t iVersion = 0;
    if (pComp->Separator(StdCompiler::SEP_DOLLAR))
    {
        iVersion = 1;
        pComp->Value(mkIntPackAdapt(iVersion));
        pComp->Separator(StdCompiler::SEP_SEP);
    }
    else
        pComp->NoSeparator();
    // Command name
    pComp->Value(mkEnumAdaptT<uint8_t>(Command, EnumAdaptCommandEntries));
    pComp->Separator(StdCompiler::SEP_SEP);
    // Target X/Y
    pComp->Value(mkParAdapt(Tx, numbers)); pComp->Separator(StdCompiler::SEP_SEP);
    pComp->Value(mkIntPackAdapt(Ty)); pComp->Separator(StdCompiler::SEP_SEP);
    // Target
    pComp->Value(Target); pComp->Separator(StdCompiler::SEP_SEP);
    pComp->Value(Target2); pComp->Separator(StdCompiler::SEP_SEP);
    // Data
    pComp->Value(mkParAdapt(Data, numbers)); pComp->Separator(StdCompiler::SEP_SEP);
    // Update interval
    pComp->Value(mkIntPackAdapt(UpdateInterval)); pComp->Separator(StdCompiler::SEP_SEP);
    // Flags
    pComp->Value(mkIntPackAdapt(Evaluated)); pComp->Separator(StdCompiler::SEP_SEP);
    pComp->Value(mkIntPackAdapt(PathChecked)); pComp->Separator(StdCompiler::SEP_SEP);
    pComp->Value(mkIntPackAdapt(Finished)); pComp->Separator(StdCompiler::SEP_SEP);
    // Retries
    pComp->Value(mkIntPackAdapt(Failures)); pComp->Separator(StdCompiler::SEP_SEP);
    pComp->Value(mkIntPackAdapt(Retries)); pComp->Separator(StdCompiler::SEP_SEP);
    pComp->Value(mkIntPackAdapt(Permit)); pComp->Separator(StdCompiler::SEP_SEP);
    // Base mode
    if (iVersion > 0)
    {
        pComp->Value(mkIntPackAdapt(BaseMode)); pComp->Separator(StdCompiler::SEP_SEP);
    }
    // Text
    StdStrBuf TextBuf;
    if (pComp->isSerializer())
    {
        if (Text)
            TextBuf.Ref(Text->GetData());
        else
            TextBuf.Ref("0");
    }
    pComp->Value(mkParAdapt(TextBuf, StdCompiler::RCT_All));
    if (pComp->isDeserializer())
    {
        if (Text)
            Text->DecRef();
        if (TextBuf == "0")
            { Text = nullptr; }
        else
            { Text = Strings.RegString(TextBuf); Text->IncRef(); }
    }
}

References BaseMode, Command, Data, C4RefCnt::DecRef(), EnumAdaptCommandEntries, Evaluated, Failures, Finished, C4String::GetData(), C4RefCnt::IncRef(), StdCompiler::isDeserializer(), StdCompiler::isSerializer(), mkIntPackAdapt(), mkParAdapt(), StdCompiler::NoSeparator(), PathChecked, Permit, StdCompiler::RCT_All, StdStrBuf::Ref(), C4StringTable::RegString(), Retries, StdCompiler::SEP_DOLLAR, StdCompiler::SEP_SEP, StdCompiler::Separator(), Strings, Target, Target2, Text, Tx, Ty, UpdateInterval, and StdCompiler::Value().

Here is the call graph for this function:

Default()

void C4Command::Default

(

)

Definition at line 207 of file C4Command.cpp.

{
    Command=C4CMD_None;
    cObj=nullptr;
    Evaluated=false;
    PathChecked=false;
    Finished=false;
    Tx=C4VNull;
    Ty=0;
    Target=Target2=nullptr;
    Data.Set0();
    UpdateInterval=0;
    Failures=0;
    Retries=0;
    Permit=0;
    Text=nullptr;
    Next=nullptr;
    iExec=0;
    BaseMode=C4CMD_Mode_SilentSub;
}

References BaseMode, C4CMD_Mode_SilentSub, C4CMD_None, C4VNull, cObj, Command, Data, Evaluated, Failures, Finished, iExec, Next, PathChecked, Permit, Retries, C4Value::Set0(), Target, Target2, Text, Tx, Ty, and UpdateInterval.

Referenced by C4Command(), and Set().

Here is the call graph for this function:

Here is the caller graph for this function:

Denumerate()

void C4Command::Denumerate

(

C4ValueNumbers *

numbers

)

Definition at line 1911 of file C4Command.cpp.

{
    Target.DenumeratePointers();
    Target2.DenumeratePointers();
    Tx.Denumerate(numbers);
}

References C4Value::Denumerate(), C4ObjectPtr::DenumeratePointers(), Target, Target2, and Tx.

Here is the call graph for this function:

Dig()

void C4Command::Dig ( )

protected

Definition at line 454 of file C4Command.cpp.

{
    // Current object and target coordinates
    int32_t cx,cy,tx,ty;
    cx=cObj->GetX(); cy=cObj->GetY();
    tx=Tx._getInt(); ty=Ty+cObj->Shape.GetY() + 3; // Target coordinates are bottom center
    bool fDigOutMaterial=Data.getBool();
 
    // Grabbing: let go
    if (cObj->GetProcedure()==DFA_PUSH)
        { cObj->AddCommand(C4CMD_UnGrab,nullptr,0,0,50); return; }
 
    // If contained: exit
    if (cObj->Contained)
        { cObj->AddCommand(C4CMD_Exit,nullptr,0,0,50); return; }
 
    // Scaling or hangling: let go
    if ((cObj->GetProcedure()==DFA_SCALE) || (cObj->GetProcedure()==DFA_HANGLE))
        ObjectComLetGo(cObj,(cObj->Action.Dir==DIR_Left) ? +1 : -1);
 
    // Determine move-to range
    int32_t iMoveToRange = MoveToRange;
    if (cObj->Def->MoveToRange > 0) iMoveToRange = cObj->Def->MoveToRange;
 
    // Target reached: success
    if (Inside(cx - tx, -iMoveToRange, +iMoveToRange)
        && Inside(cy - ty, -iMoveToRange, +iMoveToRange))
    {
        ObjectComStop(cObj);
        Finish(true); return;
    }
 
    // Can start digging only from walk
    if (cObj->GetProcedure()!=DFA_DIG)
        if (cObj->GetProcedure()!=DFA_WALK)
            // Continue trying (assume currently in flight)
            return;
 
    // Start digging
    if (cObj->GetProcedure()!=DFA_DIG)
        if (!ObjectComDig(cObj))
            { Finish(); return; }
 
    // Dig2Object
    if (fDigOutMaterial) cObj->Action.Data=1;
 
    // Head to target
    if (cx<tx-DigRange) cObj->Action.ComDir=COMD_Right;
    if (cx>tx+DigRange) cObj->Action.ComDir=COMD_Left;
    if (cy<ty-DigRange) cObj->Action.ComDir=COMD_Down;
    if (cx<tx-DigRange) if (cy<ty-DigRange) cObj->Action.ComDir=COMD_DownRight;
    if (cx>tx-DigRange) if (cy<ty-DigRange) cObj->Action.ComDir=COMD_DownLeft;
    if (cx<tx-DigRange) if (cy>ty+DigRange) cObj->Action.ComDir=COMD_UpRight;
    if (cx>tx+DigRange) if (cy>ty+DigRange) cObj->Action.ComDir=COMD_UpLeft;
 
}

References C4Value::_getInt(), C4Object::Action, C4Object::AddCommand(), C4CMD_Exit, C4CMD_UnGrab, cObj, COMD_Down, COMD_DownLeft, COMD_DownRight, COMD_Left, COMD_Right, COMD_UpLeft, COMD_UpRight, C4Action::ComDir, C4Object::Contained, Data, C4Action::Data, C4Object::Def, DFA_DIG, DFA_HANGLE, DFA_PUSH, DFA_SCALE, DFA_WALK, DigRange, C4Action::Dir, DIR_Left, Finish(), C4Value::getBool(), C4Object::GetProcedure(), C4Object::GetX(), C4Object::GetY(), C4Shape::GetY(), Inside(), MoveToRange, C4Def::MoveToRange, ObjectComDig(), ObjectComLetGo(), ObjectComStop(), C4Object::Shape, Tx, and Ty.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Drop()

void C4Command::Drop ( )

protected

Definition at line 841 of file C4Command.cpp.

{
 
    // Digging: stop
    if (cObj->GetProcedure()==DFA_DIG) ObjectComStop(cObj);
 
    // Drop specific object not in contents: get object
    if (Target)
        if (!cObj->Contents.GetLink(Target))
        {
            cObj->AddCommand(C4CMD_Get,Target,0,0,40);
            return;
        }
 
    // Determine move-to range
    int32_t iMoveToRange = MoveToRange;
    if (cObj->Def->MoveToRange > 0) iMoveToRange = cObj->Def->MoveToRange;
 
    // Target coordinates are not default 0/0: targeted drop
    if ((Tx._getInt()!=0) || (Ty!=0))
    {
        // Grabbing: let go
        if (cObj->GetProcedure()==DFA_PUSH)
            { cObj->AddCommand(C4CMD_UnGrab,nullptr,0,0,50); return; }
        // At target position: drop
        if (Inside<int32_t>(cObj->GetX() - Tx._getInt(), -iMoveToRange, +iMoveToRange) && Inside<int32_t>(cObj->GetY()-Ty,-15,+15))
        {
            cObj->Action.ComDir=COMD_Stop;
            ObjectComDrop(cObj,Target);
            Finish(true);
            return;
        }
        // Move to target position
        cObj->AddCommand(C4CMD_MoveTo,nullptr,Tx._getInt(),Ty,20);
        return;
    }
 
    // Contained: put
    if (cObj->Contained)
    {
        ObjectComPutTake(cObj,cObj->Contained,Target);
        Finish(true); return;
    }
 
    // Pushing: put
    if (cObj->GetProcedure()==DFA_PUSH)
    {
        if (cObj->Action.Target)
            ObjectComPutTake(cObj,cObj->Action.Target,Target);
        Finish(true); return;
    }
 
    // Outside: Drop
    ObjectComDrop(cObj,Target);
    Finish(true);
}

References C4Value::_getInt(), C4Object::Action, C4Object::AddCommand(), C4CMD_Get, C4CMD_MoveTo, C4CMD_UnGrab, cObj, COMD_Stop, C4Action::ComDir, C4Object::Contained, C4Object::Contents, C4Object::Def, DFA_DIG, DFA_PUSH, Finish(), C4ObjectList::GetLink(), C4Object::GetProcedure(), C4Object::GetX(), C4Object::GetY(), MoveToRange, C4Def::MoveToRange, ObjectComDrop(), ObjectComPutTake(), ObjectComStop(), Target, C4Action::Target, Tx, and Ty.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Enter()

void C4Command::Enter ( )

protected

Definition at line 564 of file C4Command.cpp.

{
    DWORD ocf;
 
    // No object to enter or can't enter by def
    if (!Target || cObj->Def->NoPushEnter) { Finish(); return; }
 
    // Already in target object
    if (cObj->Contained==Target) { Finish(true); return; }
 
    // Digging: stop
    if (cObj->GetProcedure()==DFA_DIG) ObjectComStop(cObj);
 
    // Pushing grab only or pushing not desired: let go
    if (cObj->GetProcedure()==DFA_PUSH)
        if (cObj->Action.Target)
            if (cObj->Action.Target->GetPropertyInt(P_Touchable) == 2 || !(Data.getInt() & C4CMD_Enter_PushTarget))
                { cObj->AddCommand(C4CMD_UnGrab,nullptr,0,0,50); return; }
 
    // Pushing target: let go
    if (cObj->GetProcedure()==DFA_PUSH)
        if (cObj->Action.Target==Target)
            { cObj->AddCommand(C4CMD_UnGrab,nullptr,0,0,50); return; }
 
    // Grabbing overrides position for target
    int32_t cx,cy;
    cx=cObj->GetX(); cy=cObj->GetY();
    if (cObj->GetProcedure()==DFA_PUSH)
        if (cObj->Action.Target)
            { cx=cObj->Action.Target->GetX(); cy=cObj->Action.Target->GetY(); }
 
    // If in entrance range
    ocf=OCF_Entrance;
    if (!cObj->Contained && Target->At(cx,cy,ocf) && (ocf & OCF_Entrance))
    {
        // Stop
        cObj->Action.ComDir=COMD_Stop;
        // Pushing: push target into entrance, then stop
        if ((cObj->GetProcedure()==DFA_PUSH) && cObj->Action.Target)
        {
            cObj->Action.Target->SetCommand(C4CMD_Enter,Target);
            Finish(true); return;
        }
        // Else, enter self
        else
        {
            // If entrance open, enter object
            if (Target->EntranceStatus!=0)
            {
                cObj->Enter(Target);
                Finish(true); return;
            }
            else // Else, activate entrance
                Target->ActivateEntrance(cObj->Controller,cObj);
        }
 
    }
    else // Else, move to object's entrance
    {
        int32_t ex,ey,ewdt,ehgt;
        if (Target->GetEntranceArea(ex,ey,ewdt,ehgt))
            cObj->AddCommand(C4CMD_MoveTo,nullptr,ex+ewdt/2,ey+ehgt/2,50, nullptr, true, C4VInt((Data.getInt() & C4CMD_Enter_PushTarget) ? C4CMD_MoveTo_PushTarget : 0));
    }
 
}

References C4Object::Action, C4Object::ActivateEntrance(), C4Object::AddCommand(), C4Object::At(), C4CMD_Enter, C4CMD_Enter_PushTarget, C4CMD_MoveTo, C4CMD_MoveTo_PushTarget, C4CMD_UnGrab, C4VInt(), cObj, COMD_Stop, C4Action::ComDir, C4Object::Contained, C4Object::Controller, Data, C4Object::Def, DFA_DIG, DFA_PUSH, C4Object::Enter(), C4Object::EntranceStatus, Finish(), C4Object::GetEntranceArea(), C4Value::getInt(), C4Object::GetProcedure(), C4PropList::GetPropertyInt(), C4Object::GetX(), C4Object::GetY(), C4Def::NoPushEnter, ObjectComStop(), OCF_Entrance, P_Touchable, C4Object::SetCommand(), Target, and C4Action::Target.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Execute()

void C4Command::Execute

(

)

Definition at line 1295 of file C4Command.cpp.

{
 
    // Finished?!
    if (Finished) return;
 
    // Parent object safety
    if (!cObj) { Finish(); return; }
 
    // Delegated command failed
    if (Failures)
    {
        // Retry
        if (Retries>0)
            { Failures=0; Retries--; cObj->AddCommand(C4CMD_Retry,nullptr,0,0,10); return; }
        // Too many failures
        else
            { Finish(); return; }
    }
 
    // Command update
    if (UpdateInterval>0)
    {
        UpdateInterval--;
        if (UpdateInterval==0)
        {
            Finish(true); return;
        }
    }
 
    // Initial command evaluation
    if (InitEvaluation()) return;
 
    // from now on, we are executing this command... and nobody
    // should dare deleting us
    iExec = 1;
 
    // Execute
    switch (Command)
    {
    case C4CMD_Follow: Follow(); break;
    case C4CMD_MoveTo: MoveTo(); break;
    case C4CMD_Enter: Enter(); break;
    case C4CMD_Exit: Exit(); break;
    case C4CMD_Grab: Grab(); break;
    case C4CMD_UnGrab: UnGrab(); break;
    case C4CMD_Throw: Throw(); break;
    case C4CMD_Jump: Jump(); break;
    case C4CMD_Wait: Wait(); break;
    case C4CMD_Get: Get(); break;
    case C4CMD_Put: Put(); break;
    case C4CMD_Drop: Drop(); break;
    case C4CMD_Dig: Dig();  break;
    case C4CMD_Activate:  Activate(); break;
    case C4CMD_PushTo:  PushTo(); break;
    case C4CMD_Transfer: Transfer(); break;
    case C4CMD_Attack: Attack(); break;
    case C4CMD_Buy: Buy(); break;
    case C4CMD_Sell: Sell(); break;
    case C4CMD_Acquire: Acquire(); break;
    case C4CMD_Retry: Retry(); break;
    case C4CMD_Home: Home(); break;
    case C4CMD_Call: Call(); break;
    case C4CMD_Take: Take(); break; // carlo
    case C4CMD_Take2: Take2(); break; // carlo
    default: Finish(); break;
    }
 
    /*  // Remember this command might have already been deleted through calls
      // made during execution. You must not do anything here... */
 
    // check: command must be deleted?
    if (iExec > 1)
        delete this;
    else
        iExec = 0;
 
}

References Acquire(), Activate(), C4Object::AddCommand(), Attack(), Buy(), C4CMD_Acquire, C4CMD_Activate, C4CMD_Attack, C4CMD_Buy, C4CMD_Call, C4CMD_Dig, C4CMD_Drop, C4CMD_Enter, C4CMD_Exit, C4CMD_Follow, C4CMD_Get, C4CMD_Grab, C4CMD_Home, C4CMD_Jump, C4CMD_MoveTo, C4CMD_PushTo, C4CMD_Put, C4CMD_Retry, C4CMD_Sell, C4CMD_Take, C4CMD_Take2, C4CMD_Throw, C4CMD_Transfer, C4CMD_UnGrab, C4CMD_Wait, Call(), cObj, Command, Dig(), Drop(), Enter(), Exit(), Failures, Finish(), Finished, Follow(), Get(), Grab(), Home(), iExec, InitEvaluation(), Jump(), MoveTo(), PushTo(), Put(), Retries, Retry(), Sell(), Take(), Take2(), Throw(), Transfer(), UnGrab(), UpdateInterval, and Wait().

Referenced by C4Object::ExecuteCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

Exit()

void C4Command::Exit ( )

protected

Definition at line 630 of file C4Command.cpp.

{
 
    // Outside: done
    if (!cObj->Contained) { Finish(true); return; }
 
    // Entrance open, leave object
    if (cObj->Contained->EntranceStatus)
    {
        // Exit to container's container
        if (cObj->Contained->Contained)
            { cObj->Enter(cObj->Contained->Contained); Finish(true); return; }
        // Exit to entrance area
        int32_t ex,ey,ewdt,ehgt;
        if (cObj->Contained->OCF & OCF_Entrance)
            if (cObj->Contained->GetEntranceArea(ex,ey,ewdt,ehgt))
                { cObj->Exit(ex+ewdt/2,ey+ehgt+cObj->Shape.GetY()-1); Finish(true); return; }
        // Exit jump out of collection area
        if (cObj->GetPropertyInt(P_Collectible))
            if (cObj->Contained->Def->Collection.Wdt)
            {
                cObj->Exit(cObj->Contained->GetX(),cObj->Contained->GetY()+cObj->Contained->Def->Collection.y-1);
                ObjectComJump(cObj);
                Finish(true); return;
            }
        // Plain exit
        cObj->Exit(cObj->GetX(),cObj->GetY());
        Finish(true); return;
    }
 
    // Entrance closed, activate entrance
    else
    {
        if (!cObj->Contained->ActivateEntrance(cObj->Controller,cObj))
            // Entrance activation failed: fail
            { Finish(); return; }
    }
}

References C4Object::ActivateEntrance(), cObj, C4Def::Collection, C4Object::Contained, C4Object::Controller, C4Object::Def, C4Object::Enter(), C4Object::EntranceStatus, C4Object::Exit(), Finish(), C4Object::GetEntranceArea(), C4PropList::GetPropertyInt(), C4Object::GetX(), C4Object::GetY(), C4Shape::GetY(), ObjectComJump(), C4Object::OCF, OCF_Entrance, P_Collectible, C4Object::Shape, C4Rect::Wdt, and C4Rect::y.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Fail()

void C4Command::Fail ( const char *  szFailMessage = nullptr )

protected

Definition at line 1703 of file C4Command.cpp.

{
    // Check for base command (next unfinished)
    C4Command *pBase;
    for (pBase=Next; pBase; pBase=pBase->Next)  if (!pBase->Finished) break;
 
    bool ExecFail = false;
    switch (BaseMode)
    {
        // silent subcommand
    case C4CMD_Mode_SilentSub:
    {
        // Just count failures in base command
        if (pBase) { pBase->Failures++; return; }
        else ExecFail = true;
        break;
    }
    // verbose subcommand
    case C4CMD_Mode_Sub:
    {
        // Count failures in base command
        if (pBase) { pBase->Failures++; }
        // Execute fail message, if base will fail
        if (!pBase || !pBase->Retries) ExecFail = true;
        break;
    }
    // base command
    case C4CMD_Mode_Base:
    {
        // Just execute fail notice
        ExecFail = true;
        break;
    }
    // silent base command: do nothing
    }
 
    char szCommandName[24 + 1];
    char szObjectName[C4MaxName + 1];
    StdStrBuf str;
 
    if (ExecFail && cObj && (cObj->OCF & OCF_CrewMember))
    {
        // Fail message
        if (szFailMessage)
            str = szFailMessage;
        C4Object * l_Obj = cObj;
        switch (Command)
        {
        case C4CMD_Call:
        {
            // Call fail-function in target object (no message if non-zero)
            int32_t l_Command = Command;
            if (CallFailed()) return;
            // Fail-function not available or returned zero: standard message
            SCopy(LoadResStr(CommandNameID(l_Command)),szCommandName);
            str.Format(LoadResStr("IDS_CON_FAILURE"),szCommandName);
            break;
        }
        case C4CMD_Exit:
            // No message
            break;
        case C4CMD_Dig:
            // No message
            break;
        case C4CMD_Acquire:
            // Already has a fail message
            if (szFailMessage) break;
            // Fail message with name of target type
            SCopy(LoadResStr(CommandNameID(Command)), szCommandName);
            C4Def *pDef; pDef = Data.getDef();
            SCopy(pDef ? pDef->GetName() : LoadResStr("IDS_OBJ_UNKNOWN"), szObjectName);
            str.Format(LoadResStr("IDS_CON_FAILUREOF"), szCommandName, szObjectName);
            break;
        default:
            // Already has a fail message
            if (szFailMessage) break;
            // Standard no-can-do message
            SCopy(LoadResStr(CommandNameID(Command)), szCommandName);
            str.Format(LoadResStr("IDS_CON_FAILURE"), szCommandName);
            break;
        }
        if (l_Obj) if (l_Obj->Status && !l_Obj->Def->SilentCommands)
            {
                // Message (if not empty)
                if (!!str)
                {
                    ::Messages.Append(C4GM_Target, str.getData(), l_Obj, NO_OWNER, 0, 0, C4RGB(0xff, 0xff, 0xff), true);
                }
                // Stop Clonk
                l_Obj->Action.ComDir = COMD_Stop;
                // Clonk-specific fail action/sound
                C4AulParSet pars(C4VString(CommandName(Command)), C4VObj(Target), Tx, C4VInt(Ty), C4VObj(Target2), Data);
                l_Obj->Call(PSF_CommandFailure, &pars);
            }
    }
}

References C4Object::Action, C4GameMessageList::Append(), BaseMode, C4CMD_Acquire, C4CMD_Call, C4CMD_Dig, C4CMD_Exit, C4CMD_Mode_Base, C4CMD_Mode_SilentSub, C4CMD_Mode_Sub, C4GM_Target, C4MaxName, C4RGB, C4VInt(), C4VObj(), C4VString(), C4PropList::Call(), CallFailed(), cObj, COMD_Stop, C4Action::ComDir, Command, CommandName(), CommandNameID(), Data, C4Object::Def, Failures, Finished, StdStrBuf::Format(), StdStrBuf::getData(), C4Value::getDef(), C4PropListStatic::GetName(), LoadResStr(), Messages, Next, NO_OWNER, C4Object::OCF, OCF_CrewMember, PSF_CommandFailure, Retries, SCopy(), C4Def::SilentCommands, C4PropList::Status, Target, Target2, Tx, and Ty.

Referenced by Finish().

Here is the call graph for this function:

Here is the caller graph for this function:

Finish()

void C4Command::Finish ( bool  fSuccess = false, const char *  szFailMessage = nullptr  )

protected

Definition at line 1374 of file C4Command.cpp.

{
    // Mark finished
    Finished=true;
    // Failed
    if (!fSuccess)
        Fail(szFailMessage);
    else
    {
        // successful commands might gain EXP
        int32_t iExpGain = GetExpGain();
        if (iExpGain && cObj) if (cObj->Info)
                for (int32_t i=iExpGain; i; --i)
                    if (!(++cObj->Info->ControlCount%5))
                        cObj->DoExperience(1);
    }
}

References cObj, C4ObjectInfo::ControlCount, C4Object::DoExperience(), Fail(), Finished, GetExpGain(), and C4Object::Info.

Referenced by Acquire(), Activate(), Attack(), Buy(), Call(), Dig(), Drop(), Enter(), Execute(), Exit(), Follow(), Get(), GetTryEnter(), Grab(), Home(), Jump(), MoveTo(), PushTo(), Put(), Sell(), Take(), Take2(), Throw(), Transfer(), and UnGrab().

Here is the call graph for this function:

Here is the caller graph for this function:

FlightControl()

bool C4Command::FlightControl ( )

protected

Definition at line 1471 of file C4Command.cpp.

{
    // Crew members or pathfinder objects only
    if (!((cObj->OCF & OCF_CrewMember) || cObj->Def->Pathfinder)) return false;
 
    // Not while in a disabled action
    C4PropList* pActionDef = cObj->GetAction();
    if (pActionDef)
    {
        if (pActionDef->GetPropertyInt(P_ObjectDisabled)) return false;
    }
 
    // Target angle
    int32_t cx=cObj->GetX(),cy=cObj->GetY();
    int32_t iAngle = Angle(cx,cy,Tx._getInt(),Ty); while (iAngle>180) iAngle-=360;
 
    // Target in flight angle (sector +/- from straight up), beyond minimum distance, and top free
    if (Inside(iAngle, -FlightAngleRange, +FlightAngleRange)
        || Inside(iAngle, -FlightAngleRange, +FlightAngleRange))
        if (Distance(cx,cy,Tx._getInt(),Ty) > 30)
        {
            int32_t iTopFree;
            for (iTopFree=0; (iTopFree<50) && !GBackSolid(cx,cy+cObj->Shape.GetY()-iTopFree); ++iTopFree) {}
            if (iTopFree>=15)
            {
                // Take off
                return cObj->SetActionByName("Fly"); // This is a little primitive... we should have a ObjectActionFly or maybe a command for this...
            }
        }
 
    // No flight control
    return false;
}

References C4Value::_getInt(), Angle(), cObj, C4Object::Def, Distance(), FlightAngleRange, GBackSolid(), C4Object::GetAction(), C4PropList::GetPropertyInt(), C4Object::GetX(), C4Object::GetY(), C4Shape::GetY(), Inside(), C4Object::OCF, OCF_CrewMember, P_ObjectDisabled, C4Def::Pathfinder, C4Object::SetActionByName(), C4Object::Shape, Tx, and Ty.

Referenced by MoveTo().

Here is the call graph for this function:

Here is the caller graph for this function:

Follow()

void C4Command::Follow ( )

protected

Definition at line 512 of file C4Command.cpp.

{
    // No-one to follow
    if (!Target) { Finish(); return; }
 
    // Follow containment
    if (cObj->Contained!=Target->Contained)
    {
        // Only crew members can follow containment
        if (!cObj->Def->CrewMember)
            { Finish(); return; }
        // Exit/enter
        if (cObj->Contained) cObj->AddCommand(C4CMD_Exit,nullptr,0,0,50);
        else cObj->AddCommand(C4CMD_Enter,Target->Contained,0,0,50);
        return;
    }
 
    // Follow target grabbing
    if (Target->GetProcedure()==DFA_PUSH)
    {
        // Grabbing same: copy ComDir
        if (cObj->GetProcedure()==DFA_PUSH)
            if (cObj->Action.Target==Target->Action.Target)
            {
                cObj->Action.ComDir=Target->Action.ComDir;
                return;
            }
        // Else, grab target's grab
        cObj->AddCommand(C4CMD_Grab,Target->Action.Target);
        return;
    }
    else if (cObj->GetProcedure()==DFA_PUSH)
    {
        // Follow ungrabbing
        cObj->AddCommand(C4CMD_UnGrab);
        return;
    }
 
    // If in following range
    if (Inside<int32_t>(cObj->GetX()-Target->GetX(),-FollowRange,+FollowRange)
        && Inside<int32_t>(cObj->GetY()-Target->GetY(),-FollowRange,+FollowRange))
    {
        // Copy target's Action.ComDir
        cObj->Action.ComDir=Target->Action.ComDir;
    }
    else // Else, move to target
    {
        cObj->AddCommand(C4CMD_MoveTo,nullptr,Target->GetX(),Target->GetY(),10);
    }
 
}

References C4Object::Action, C4Object::AddCommand(), C4CMD_Enter, C4CMD_Exit, C4CMD_Grab, C4CMD_MoveTo, C4CMD_UnGrab, cObj, C4Action::ComDir, C4Object::Contained, C4Def::CrewMember, C4Object::Def, DFA_PUSH, Finish(), FollowRange, C4Object::GetProcedure(), C4Object::GetX(), C4Object::GetY(), Target, and C4Action::Target.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Get()

void C4Command::Get ( )

protected

Definition at line 955 of file C4Command.cpp.

{
 
    // Data set and target specified: open get menu & done (old style)
    if (((Data.getInt()==1) || (Data.getInt()==2)) && Target)
    {
        cObj->ActivateMenu((Data.getInt()==1) ? C4MN_Get : C4MN_Contents,0,0,0,Target);
        Finish(true); return;
    }
 
    // Get target specified by container and type
    if (!Target && Target2 && Data)
        if (!(Target = Target2->Contents.Find(Data.getDef())))
            { Finish(); return; }
 
    // No target: failure
    if (!Target) { Finish(); return; }
 
    // Target not carryable: failure
    if (!(Target->OCF & OCF_Carryable))
        { Finish(); return; }
 
    // Target collected
    if (Target->Contained == cObj)
    {
        // Get-count specified: decrease count and continue with next object
        if (Tx._getInt() > 1)
            { Target = nullptr; Tx--; return; }
        // We're done
        else
            { cObj->Action.ComDir=COMD_Stop; Finish(true); return; }
    }
 
    // Grabbing other than target container: let go
    if (cObj->GetProcedure()==DFA_PUSH)
        if (cObj->Action.Target!=Target->Contained)
            { cObj->AddCommand(C4CMD_UnGrab,nullptr,0,0,50); return; }
 
    // Target in solid: dig out
    if (!Target->Contained && (Target->OCF & OCF_InSolid))
    {
        // Check for closest free position
        int32_t iX=Target->GetX(),iY=Target->GetY();
        // Find all-closest dig-out position
        if (!FindClosestFree(iX,iY,-120,+120,-1,-1))
            // None found
            { Finish(); return; }
        // Check good-angle left/right dig-out position
        int32_t iX2=Target->GetX(),iY2=Target->GetY();
        if (FindClosestFree(iX2,iY2,-140,+140,-40,+40))
            // Use good-angle position if it's not way worse
            if ( Distance(Target->GetX(),Target->GetY(),iX2,iY2) < 10*Distance(Target->GetX(),Target->GetY(),iX,iY) )
                { iX=iX2; iY=iY2; }
        // Move to closest free position (if not in dig-direct range)
        if (!Inside(cObj->GetX()-iX,-DigOutPositionRange,+DigOutPositionRange)
            || !Inside(cObj->GetY()-iY,-DigOutPositionRange,+DigOutPositionRange))
            { cObj->AddCommand(C4CMD_MoveTo,nullptr,iX,iY,50); return; }
        // DigTo
        cObj->AddCommand(C4CMD_Dig,nullptr,Target->GetX(),Target->GetY()+4,50); return;
    }
 
    // Digging: stop
    if (cObj->GetProcedure()==DFA_DIG) ObjectComStop(cObj);
 
    // Target contained
    if (Target->Contained)
    {
        // target can't be taken out of containers?
        if (Target->Def->NoGet) return;
        // In same container: grab target
        if (cObj->Contained==Target->Contained)
        {
            GetTryEnter();
            // Done
            return;
        }
 
        // Leave own container
        if (cObj->Contained)
            { cObj->AddCommand(C4CMD_Exit,nullptr,0,0,50); return; }
 
        // Target container has grab get: grab target container
        if (Target->Contained->Def->GrabPutGet & C4D_Grab_Get)
        {
            // Grabbing target container
            if ((cObj->GetProcedure()==DFA_PUSH) && (cObj->Action.Target==Target->Contained))
            {
                GetTryEnter();
                // Done
                return;
            }
            // Grab target container
            cObj->AddCommand(C4CMD_Grab,Target->Contained,0,0,50);
            return;
        }
 
        // Target container has entrance: enter target container
        if (Target->Contained->OCF & OCF_Entrance)
            { cObj->AddCommand(C4CMD_Enter,Target->Contained,0,0,50); return; }
 
        // Can't get to target due to target container: fail
        Finish();
        return;
    }
 
    // Target outside
 
    // Leave own container
    if (cObj->Contained) { cObj->AddCommand(C4CMD_Exit,nullptr,0,0,50); return; }
 
    // Outside
    if (!cObj->Contained)
    {
 
        // Target in collection range
        DWORD ocf = OCF_Normal | OCF_Collection;
        if (cObj->At(Target->GetX(),Target->GetY(),ocf))
        {
            // stop here
            cObj->Action.ComDir=COMD_Stop;
            // try getting the object
            if (GetTryEnter()) return;
        }
 
        // Target not in range
        else
        {
            // Target in jumping range above clonk: try side-move jump
            if (Inside<int32_t>(cObj->GetX()-Target->GetX(),-10,+10))
                if (Inside<int32_t>(cObj->GetY()-Target->GetY(),30,50))
                {
                    int32_t iSideX=1; if (Random(2)) iSideX=-1;
                    iSideX=cObj->GetX()+iSideX*(cObj->GetY()-Target->GetY());
                    if (PathFree(iSideX,cObj->GetY(),Target->GetX(),Target->GetY()))
                    {
                        // Side-move jump
                        cObj->AddCommand(C4CMD_Jump,nullptr,Tx._getInt(),Ty);
                        // FIXME: Drop stuff if full here
                        cObj->AddCommand(C4CMD_MoveTo,nullptr,iSideX,cObj->GetY(),50);
                    }
                }
            // Move to target (random offset for difficult pickups)
            // ...avoid offsets into solid which would lead to high above surface locations!
            cObj->AddCommand(C4CMD_MoveTo,nullptr,Target->GetX()+Random(15)-7,Target->GetY(),25,nullptr);
        }
 
    }
 
}

References C4Value::_getInt(), C4Object::Action, C4Object::ActivateMenu(), C4Object::AddCommand(), C4Object::At(), C4CMD_Dig, C4CMD_Enter, C4CMD_Exit, C4CMD_Grab, C4CMD_Jump, C4CMD_MoveTo, C4CMD_UnGrab, C4D_Grab_Get, C4MN_Contents, C4MN_Get, cObj, COMD_Stop, C4Action::ComDir, C4Object::Contained, C4Object::Contents, Data, C4Object::Def, DFA_DIG, DFA_PUSH, DigOutPositionRange, Distance(), C4ObjectList::Find(), FindClosestFree(), Finish(), C4Value::getDef(), C4Value::getInt(), C4Object::GetProcedure(), GetTryEnter(), C4Object::GetX(), C4Object::GetY(), C4Def::GrabPutGet, Inside(), C4Def::NoGet, ObjectComStop(), C4Object::OCF, OCF_Carryable, OCF_Collection, OCF_Entrance, OCF_InSolid, OCF_Normal, PathFree(), Random(), Target, C4Action::Target, Target2, Tx, and Ty.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

GetExpGain()

int32_t C4Command::GetExpGain ( )

protected

Definition at line 1932 of file C4Command.cpp.

{
    // return exp gained by this command
    switch (Command)
    {
        // internal
    case C4CMD_Wait:
    case C4CMD_Transfer:
    case C4CMD_Retry:
    case C4CMD_Call:
        return 0;
 
        // regular move commands
    case C4CMD_Follow:
    case C4CMD_MoveTo:
    case C4CMD_Enter:
    case C4CMD_Exit:
        return 1;
 
        // simple activities
    case C4CMD_Grab:
    case C4CMD_UnGrab:
    case C4CMD_Throw:
    case C4CMD_Jump:
    case C4CMD_Get:
    case C4CMD_Put:
    case C4CMD_Drop:
    case C4CMD_Activate:
    case C4CMD_PushTo:
    case C4CMD_Dig:
    case C4CMD_Buy:
    case C4CMD_Sell:
    case C4CMD_Take:
    case C4CMD_Take2:
        return 1;
 
        // not that simple
    case C4CMD_Acquire:
    case C4CMD_Home:
        return 2;
 
        // victory!
    case C4CMD_Attack:
        return 15;
    }
    // unknown command
    return 0;
}

References C4CMD_Acquire, C4CMD_Activate, C4CMD_Attack, C4CMD_Buy, C4CMD_Call, C4CMD_Dig, C4CMD_Drop, C4CMD_Enter, C4CMD_Exit, C4CMD_Follow, C4CMD_Get, C4CMD_Grab, C4CMD_Home, C4CMD_Jump, C4CMD_MoveTo, C4CMD_PushTo, C4CMD_Put, C4CMD_Retry, C4CMD_Sell, C4CMD_Take, C4CMD_Take2, C4CMD_Throw, C4CMD_Transfer, C4CMD_UnGrab, C4CMD_Wait, and Command.

Referenced by Finish().

Here is the caller graph for this function:

GetTryEnter()

bool C4Command::GetTryEnter ( )

protected

Definition at line 926 of file C4Command.cpp.

{
    // Target contained and container has RejectContents: fail
    if (Target->Contained && !!Target->Contained->Call(PSF_RejectContents)) { Finish(); return false; }
    // FIXME: Drop stuff if full here
    bool fWasContained = !!Target->Contained;
    // Grab target object
    bool fRejectCollect = false;
    bool fSuccess = !!Target->Enter(cObj, true, true, &fRejectCollect);
    // target is void?
    // well...most likely the new container has done something with it
    // so count it as success
    if (!Target) { Finish(true); return true; }
    // collection rejected by target: make room for more contents
    if (fRejectCollect)
    {
        if (cObj->PutAwayUnusedObject(Target)) return false;
        // Can't get due to RejectCollect: fail
        Finish();
        return false;
    }
    // if not successfully entered for any other reason, fail
    if (!fSuccess) { Finish(); return false; }
    // get-callback for getting out of containers
    if (fWasContained) cObj->Call(PSF_Get, &C4AulParSet(Target));
    // entered
    return true;
}

References C4PropList::Call(), cObj, C4Object::Contained, C4Object::Enter(), Finish(), PSF_Get, PSF_RejectContents, C4Object::PutAwayUnusedObject(), and Target.

Referenced by Get().

Here is the call graph for this function:

Here is the caller graph for this function:

Grab()

void C4Command::Grab ( )

protected

Definition at line 669 of file C4Command.cpp.

{
    DWORD ocf;
    // Command fulfilled
    if (cObj->GetProcedure()==DFA_PUSH)
        if (cObj->Action.Target==Target)
            { Finish(true); return; }
    // Digging: stop
    if (cObj->GetProcedure()==DFA_DIG) ObjectComStop(cObj);
    // Grabbing: let go
    if (cObj->GetProcedure()==DFA_PUSH)
        { cObj->AddCommand(C4CMD_UnGrab,nullptr,0,0,50); return; }
    // No target
    if (!Target) { Finish(); return; }
    // At target object: grab
    ocf=OCF_All;
    if (!cObj->Contained && Target->At(cObj->GetX(),cObj->GetY(),ocf))
    {
        // Scaling or hangling: let go
        if ((cObj->GetProcedure()==DFA_SCALE) || (cObj->GetProcedure()==DFA_HANGLE))
            ObjectComLetGo(cObj,(cObj->Action.Dir==DIR_Left) ? +1 : -1);
        // Grab
        cObj->Action.ComDir=COMD_Stop;
        ObjectComGrab(cObj,Target);
    }
    // Else, move to object
    else
    {
        cObj->AddCommand(C4CMD_MoveTo,nullptr,Target->GetX()+Tx._getInt(),Target->GetY()+Ty,50);
    }
}

References C4Value::_getInt(), C4Object::Action, C4Object::AddCommand(), C4Object::At(), C4CMD_MoveTo, C4CMD_UnGrab, cObj, COMD_Stop, C4Action::ComDir, C4Object::Contained, DFA_DIG, DFA_HANGLE, DFA_PUSH, DFA_SCALE, C4Action::Dir, DIR_Left, Finish(), C4Object::GetProcedure(), C4Object::GetX(), C4Object::GetY(), ObjectComGrab(), ObjectComLetGo(), ObjectComStop(), OCF_All, Target, C4Action::Target, Tx, and Ty.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Home()

void C4Command::Home ( )

protected

Definition at line 1805 of file C4Command.cpp.

{
    Finish();
}

References Finish().

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

InitEvaluation()

bool C4Command::InitEvaluation ( )

protected

Definition at line 1392 of file C4Command.cpp.

{
    // Already evaluated
    if (Evaluated) return false;
    // Set evaluation flag
    Evaluated=true;
    // Evaluate
    switch (Command)
    {
        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    case C4CMD_MoveTo:
    {
        // Target coordinates by Target
        if (Target) { Tx+=Target->GetX(); Ty+=Target->GetY(); Target=nullptr; }
        // Adjust coordinates
        int32_t iTx = Tx._getInt();
        if (~Data.getInt() & C4CMD_MoveTo_NoPosAdjust) AdjustMoveToTarget(iTx,Ty,FreeMoveTo(cObj),cObj->Shape.Hgt);
        Tx.SetInt(iTx);
        return true;
    }
        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    case C4CMD_PushTo:
    {
        // Adjust coordinates
        int32_t iTx = Tx._getInt();
        AdjustMoveToTarget(iTx,Ty,FreeMoveTo(cObj),cObj->Shape.Hgt);
        Tx.SetInt(iTx);
        return true;
    }
        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    case C4CMD_Exit:
        // Cancel attach
        ObjectComCancelAttach(cObj);
        return true;
        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    case C4CMD_Jump:
    {
        if (Tx._getInt())
        {
            if (Tx._getInt()<cObj->GetX()) cObj->SetDir(DIR_Left);
            if (Tx._getInt()>cObj->GetX()) cObj->SetDir(DIR_Right);
        }
        ObjectComJump(cObj);
        return true;
    }
        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    case C4CMD_Wait:
        // Update interval by Data
        if (!!Data) UpdateInterval=Data.getInt();
        // Else update interval by Tx
        else if (Tx._getInt()) UpdateInterval=Tx._getInt();
        return true;
        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    case C4CMD_Acquire:
        // update default search range
        if (!Tx._getInt()) Tx.SetInt(500);
        if (!Ty) Ty=250;
        return true;
        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    }
    // Need not be evaluated
    return false;
}

References C4Value::_getInt(), AdjustMoveToTarget(), C4CMD_Acquire, C4CMD_Exit, C4CMD_Jump, C4CMD_MoveTo, C4CMD_MoveTo_NoPosAdjust, C4CMD_PushTo, C4CMD_Wait, cObj, Command, Data, DIR_Left, DIR_Right, Evaluated, FreeMoveTo(), C4Value::getInt(), C4Object::GetX(), C4Object::GetY(), C4Rect::Hgt, ObjectComCancelAttach(), ObjectComJump(), C4Object::SetDir(), C4Value::SetInt(), C4Object::Shape, Target, Tx, Ty, and UpdateInterval.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Jump()

void C4Command::Jump ( )

protected

Definition at line 898 of file C4Command.cpp.

{
    // Already in air?
    if (cObj->GetProcedure()==DFA_FLIGHT)
    {
        // Check whether target position is given
        if (Tx._getInt())
        {
            if (cObj->GetX()<Tx._getInt()) cObj->Action.ComDir=COMD_Right;
            else if (cObj->GetX()>Tx._getInt()) cObj->Action.ComDir=COMD_Left;
            else cObj->Action.ComDir=COMD_Stop;
        }
    }
    else
    {
        cObj->Action.ComDir=COMD_Stop;
        // Done
        Finish(true);
        return;
    }
}

References C4Value::_getInt(), C4Object::Action, cObj, COMD_Left, COMD_Right, COMD_Stop, C4Action::ComDir, DFA_FLIGHT, Finish(), C4Object::GetProcedure(), C4Object::GetX(), and Tx.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

JumpControl()

bool C4Command::JumpControl ( )

protected

Definition at line 1505 of file C4Command.cpp.

{
 
    // Crew members or pathfinder objects only
    if (! ((cObj->OCF & OCF_CrewMember) || cObj->Def->Pathfinder) ) return false;
 
    // Target angle
    int32_t cx=cObj->GetX(),cy=cObj->GetY();
    int32_t iAngle = Angle(cx,cy,Tx._getInt(),Ty); while (iAngle>180) iAngle-=360;
 
    // Diagonal free jump (if in angle range, minimum distance, and top free)
    if (Inside(iAngle-JumpAngle,-JumpAngleRange,+JumpAngleRange)
        || Inside(iAngle+JumpAngle,-JumpAngleRange,+JumpAngleRange))
        if (PathFree(cx,cy,Tx._getInt(),Ty))
            if (Distance(cx,cy,Tx._getInt(),Ty)>30)
            {
                int32_t iTopFree;
                for (iTopFree=0; (iTopFree<50) && !GBackSolid(cx,cy+cObj->Shape.GetY()-iTopFree); ++iTopFree) {}
                if (iTopFree>=15)
                {
                    cObj->AddCommand(C4CMD_Jump,nullptr,Tx,Ty); return true;
                }
            }
 
    // High angle side move - jump (2x range)
    if (Inside<int32_t>(iAngle-JumpHighAngle,-3*JumpAngleRange,+3*JumpAngleRange))
        // Vertical range
        if (Inside<int32_t>(cy-Ty,10,40))
        {
            int32_t iSide=SolidOnWhichSide(Tx._getInt(),Ty); // take jump height of side move position into consideration...!
            int32_t iDist=5*Abs(cy-Ty)/6;
            int32_t iSideX=cx-iDist*iSide,iSideY=cy; AdjustMoveToTarget(iSideX,iSideY,false,0);
            // Side move target in range
            if (Inside<int32_t>(iSideY-cy,-20,+20))
            {
                // Path free from side move target to jump target
                if (PathFree(iSideX,iSideY,Tx._getInt(),Ty))
                {
                    cObj->AddCommand(C4CMD_Jump,nullptr,Tx,Ty);
                    cObj->AddCommand(C4CMD_MoveTo,nullptr,iSideX,iSideY,50);
                    return true;
                }
            }
        }
 
    // Low side contact jump
    // Only jump before almost running off a cliff
    int32_t iLowSideRange=5;
    if (!(GBackDensity(cx,cy+cObj->Shape.Hgt/2) >= cObj->Shape.ContactDensity))
    {
        if (cObj->t_contact & CNAT_Right)
            if (Inside(iAngle-JumpLowAngle,-iLowSideRange*JumpAngleRange,+iLowSideRange*JumpAngleRange))
            {
                cObj->AddCommand(C4CMD_Jump,nullptr,Tx,Ty); return true;
            }
        if (cObj->t_contact & CNAT_Left)
            if (Inside(iAngle+JumpLowAngle,-iLowSideRange*JumpAngleRange,+iLowSideRange*JumpAngleRange))
            {
                cObj->AddCommand(C4CMD_Jump,nullptr,Tx,Ty); return true;
            }
    }
 
    // No jump control
    return false;
}

References C4Value::_getInt(), Abs(), C4Object::AddCommand(), AdjustMoveToTarget(), Angle(), C4CMD_Jump, C4CMD_MoveTo, CNAT_Left, CNAT_Right, cObj, C4Shape::ContactDensity, C4Object::Def, Distance(), GBackDensity(), GBackSolid(), C4Object::GetX(), C4Object::GetY(), C4Shape::GetY(), C4Rect::Hgt, Inside(), JumpAngle, JumpAngleRange, JumpHighAngle, JumpLowAngle, C4Object::OCF, OCF_CrewMember, C4Def::Pathfinder, PathFree(), C4Object::Shape, SolidOnWhichSide(), C4Object::t_contact, Tx, and Ty.

Referenced by MoveTo().

Here is the call graph for this function:

Here is the caller graph for this function:

MoveTo()

void C4Command::MoveTo ( )

protected

Definition at line 257 of file C4Command.cpp.

{
    // Determine move-to range
    int32_t iMoveToRange = MoveToRange;
    if (cObj->Def->MoveToRange > 0) iMoveToRange = cObj->Def->MoveToRange;
 
    // Current object position
    int32_t cx,cy; cx=cObj->GetX(); cy=cObj->GetY();
    bool fWaypoint=false;
    if (Next && (Next->Command==C4CMD_MoveTo)) fWaypoint=true;
 
    // Contained: exit
    if (cObj->Contained)
        { cObj->AddCommand(C4CMD_Exit,nullptr,0,0,50); return; }
 
    // Check path (crew members or specific only)
    if ((cObj->OCF & OCF_CrewMember) || cObj->Def->Pathfinder)
        if (!PathChecked)
            // Not too far
            if (Distance(cx,cy,Tx._getInt(),Ty)<MaxPathRange)
                // Not too close
                if (!(Inside(cx-Tx._getInt(),-PathRange,+PathRange) && Inside(cy-Ty,-PathRange,+PathRange)))
                {
                    // Path not free: find path
                    if (!PathFree(cx,cy,Tx._getInt(),Ty))
                    {
                        Game.PathFinder.EnableTransferZones(!cObj->Def->NoTransferZones);
                        Game.PathFinder.SetLevel(cObj->Def->Pathfinder);
                        if (!Game.PathFinder.Find( cObj->GetX(),cObj->GetY(),
                                                   Tx._getInt(),Ty,
                                                   ObjectAddWaypoint(cObj)))
                            { /* Path not found: react? */ PathChecked=true; /* recheck delay */ }
                        return;
                    }
                    // Path free: recheck delay
                    else
                        PathChecked=true;
                }
    // Path recheck
    if (!::Game.iTick35) PathChecked=false;
 
    // Pushing grab only or not desired: let go (pulling, too?)
    if (cObj->GetProcedure()==DFA_PUSH)
        if (cObj->Action.Target)
            if (cObj->Action.Target->GetPropertyInt(P_Touchable) == 2 || !(Data.getInt() & C4CMD_MoveTo_PushTarget))
            {
                // Re-evaluate this command because vehicle control might have blocked evaluation
                Evaluated=false;
                cObj->AddCommand(C4CMD_UnGrab,nullptr,0,0,50); return;
            }
 
    // Special by procedure
    switch (cObj->GetProcedure())
    {
        // Push/pull
    case DFA_PUSH: case DFA_PULL:
        // Use target object's position if on final waypoint
        if (!fWaypoint)
            if (cObj->Action.Target)
                { cx=cObj->Action.Target->GetX(); cy=cObj->Action.Target->GetY(); }
        break;
        // dig: stop
    case DFA_DIG:
        ObjectComStop(cObj);
        break;
    }
 
    // Target range
    int32_t iTargetRange = iMoveToRange;
    int32_t iRangeFactorTop=1, iRangeFactorBottom=1, iRangeFactorSide=1;
 
    // Crew members/pathfinder specific target range
    if (cObj->OCF & OCF_CrewMember) // || cObj->Def->Pathfinder ? (Sven2)
    {
        // Range by size
        iTargetRange=cObj->Shape.Wdt/2;
        // Easier range if waypoint
        if (fWaypoint)
            if (cObj->GetProcedure()!=DFA_SCALE)
                { iRangeFactorTop=3; iRangeFactorSide=3; iRangeFactorBottom=2; }
    }
 
    // Target reached (success)
    if (Inside(cx-Tx._getInt(),-iRangeFactorSide*iTargetRange,+iRangeFactorSide*iTargetRange)
        && Inside(cy-Ty,-iRangeFactorBottom*iTargetRange,+iRangeFactorTop*iTargetRange))
    {
        cObj->Action.ComDir=COMD_Stop;
        Finish(true); return;
    }
 
    // Idles can't move to
    if (!cObj->GetAction())
        { Finish(); return; }
 
    // Action
    switch (cObj->GetProcedure())
    {
        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    case DFA_WALK:
        // Head to target
        if (cx<Tx._getInt()-iTargetRange) cObj->Action.ComDir=COMD_Right;
        if (cx>Tx._getInt()+iTargetRange) cObj->Action.ComDir=COMD_Left;
        // Flight control
        if (FlightControl()) return;
        // Jump control
        if (JumpControl()) return;
        break;
        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    case DFA_PUSH: case DFA_PULL:
        // Head to target
        if (cx<Tx._getInt()-iTargetRange) cObj->Action.ComDir=COMD_Right;
        if (cx>Tx._getInt()+iTargetRange) cObj->Action.ComDir=COMD_Left;
        break;
        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    case DFA_SCALE:
        // Head to target
        if (cy>Ty+iTargetRange) cObj->Action.ComDir=COMD_Up;
        if (cy<Ty-iTargetRange) cObj->Action.ComDir=COMD_Down;
        // Let-Go Control
        if (cObj->Action.Dir==DIR_Left)
        {
            // Target direction
            if ((Tx._getInt()>cx+LetGoRange1) && (Inside(cy-Ty,-LetGoRange2,+LetGoRange2)))
                { ObjectComLetGo(cObj,+1); return; }
            // Contact (not if just started)
            if (cObj->Action.Time>2)
                if (cObj->t_contact/* & CNAT_Left*/)
                    { ObjectComLetGo(cObj,+1); return; }
        }
        if (cObj->Action.Dir==DIR_Right)
        {
            // Target direction
            if ((Tx._getInt()<cx-LetGoRange1) && (Inside(cy-Ty,-LetGoRange2,+LetGoRange2)))
                { ObjectComLetGo(cObj,-1); return; }
            // Contact (not if just started)
            if (cObj->Action.Time>2)
                if (cObj->t_contact/* & CNAT_Right*/)
                    { ObjectComLetGo(cObj,-1); return; }
        }
        break;
        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    case DFA_SWIM:
        // Head to target
        if (::Game.iTick2)
        {
            if (cx<Tx._getInt()-iTargetRange) cObj->Action.ComDir=COMD_Right;
            if (cx>Tx._getInt()+iTargetRange) cObj->Action.ComDir=COMD_Left;
        }
        else
        {
            if (cy<Ty) cObj->Action.ComDir=COMD_Down;
            if (cy>Ty) cObj->Action.ComDir=COMD_Up;
        }
        break;
        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    case DFA_HANGLE:
        // Head to target
        if (cx<Tx._getInt()-iTargetRange) cObj->Action.ComDir=COMD_Right;
        if (cx>Tx._getInt()+iTargetRange) cObj->Action.ComDir=COMD_Left;
        // Let-Go Control
        if (Abs(Angle(cx,cy,Tx._getInt(),Ty))>LetGoHangleAngle)
            ObjectComLetGo(cObj,0);
        break;
        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    case DFA_FLOAT:
    {
        C4Real dx = itofix(Tx._getInt()) - cObj->fix_x, dy = itofix(Ty) - cObj->fix_y;
        // normalize
        C4Real dScale = C4REAL100(cObj->GetAction()->GetPropertyInt(P_Speed)) / std::max(Abs(dx), Abs(dy));
        dx *= dScale; dy *= dScale;
        // difference to momentum
        dx -= cObj->xdir; dy -= cObj->ydir;
        // steer
        if (Abs(dx)+Abs(dy) < C4REAL100(20)) cObj->Action.ComDir = COMD_Stop;
        else if (Abs(dy) * 3 <  dx) cObj->Action.ComDir = COMD_Right;
        else if (Abs(dy) * 3 < -dx) cObj->Action.ComDir = COMD_Left;
        else if (Abs(dx) * 3 <  dy) cObj->Action.ComDir = COMD_Down;
        else if (Abs(dx) * 3 < -dy) cObj->Action.ComDir = COMD_Up;
        else if (dx > 0 && dy > 0)   cObj->Action.ComDir = COMD_DownRight;
        else if (dx < 0 && dy > 0)   cObj->Action.ComDir = COMD_DownLeft;
        else if (dx > 0 && dy < 0)   cObj->Action.ComDir = COMD_UpRight;
        else                        cObj->Action.ComDir = COMD_UpLeft;
    }
    break;
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    case DFA_FLIGHT:
        // Try to move into right direction
        if (cx<Tx._getInt()-iTargetRange) cObj->Action.ComDir=COMD_Right;
        if (cx>Tx._getInt()+iTargetRange) cObj->Action.ComDir=COMD_Left;
        // Flight control
        if (FlightControl()) return;
        break;
        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    }
 
}

References C4Value::_getInt(), Abs(), C4Object::Action, C4Object::AddCommand(), Angle(), C4CMD_Exit, C4CMD_MoveTo, C4CMD_MoveTo_PushTarget, C4CMD_UnGrab, C4REAL100(), cObj, COMD_Down, COMD_DownLeft, COMD_DownRight, COMD_Left, COMD_Right, COMD_Stop, COMD_Up, COMD_UpLeft, COMD_UpRight, C4Action::ComDir, Command, C4Object::Contained, Data, C4Object::Def, DFA_DIG, DFA_FLIGHT, DFA_FLOAT, DFA_HANGLE, DFA_PULL, DFA_PUSH, DFA_SCALE, DFA_SWIM, DFA_WALK, C4Action::Dir, DIR_Left, DIR_Right, Distance(), C4PathFinder::EnableTransferZones(), Evaluated, C4PathFinder::Find(), Finish(), C4Object::fix_x, C4Object::fix_y, FlightControl(), Game, C4Object::GetAction(), C4Value::getInt(), C4Object::GetProcedure(), C4PropList::GetPropertyInt(), C4Object::GetX(), C4Object::GetY(), Inside(), C4Game::iTick2, C4Game::iTick35, itofix(), JumpControl(), LetGoHangleAngle, LetGoRange1, LetGoRange2, MaxPathRange, MoveToRange, C4Def::MoveToRange, Next, C4Def::NoTransferZones, ObjectComLetGo(), ObjectComStop(), C4Object::OCF, OCF_CrewMember, P_Speed, P_Touchable, PathChecked, C4Game::PathFinder, C4Def::Pathfinder, PathFree(), PathRange, C4PathFinder::SetLevel(), C4Object::Shape, C4Object::t_contact, C4Action::Target, C4Action::Time, Tx, Ty, C4Rect::Wdt, C4Object::xdir, and C4Object::ydir.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

PushTo()

void C4Command::PushTo ( )

protected

Definition at line 701 of file C4Command.cpp.

{
    // Target check
    if (!Target) { Finish(); return; }
 
    // Target is target self: fail
    if (Target==Target2) { Finish(); return; }
 
    // Command fulfilled
    if (Target2)
    {
        // Object in correct target container: success
        if (Target->Contained==Target2)
            { Finish(true); return; }
    }
    else
    {
        // Object at target position: success
        if (Inside(Target->GetX()-Tx._getInt(),-PushToRange,+PushToRange))
            if (Inside(Target->GetY()-Ty,-PushToRange,+PushToRange))
            {
                cObj->Action.ComDir=COMD_Stop;
                cObj->AddCommand(C4CMD_UnGrab);
                cObj->AddCommand(C4CMD_Wait,nullptr,0,0,10);
                Finish(true); return;
            }
    }
 
    // Digging: stop
    if (cObj->GetProcedure()==DFA_DIG) ObjectComStop(cObj);
 
    // Target contained: activate
    if (Target->Contained)
        { cObj->AddCommand(C4CMD_Activate,Target,0,0,40); return; }
 
    // Grab target
    if (!((cObj->GetProcedure()==DFA_PUSH) && (cObj->Action.Target==Target)))
        { cObj->AddCommand(C4CMD_Grab,Target,0,0,40); return; }
 
    // Move to target position / enter target object
    if (Target2)
        { cObj->AddCommand(C4CMD_Enter,Target2,0,0,40, nullptr, true, C4Value(C4CMD_Enter_PushTarget)); return; }
    else
        { cObj->AddCommand(C4CMD_MoveTo,nullptr,Tx,Ty,40, nullptr, true, C4Value(C4CMD_MoveTo_PushTarget)); return; }
 
}

References C4Value::_getInt(), C4Object::Action, C4Object::AddCommand(), C4CMD_Activate, C4CMD_Enter, C4CMD_Enter_PushTarget, C4CMD_Grab, C4CMD_MoveTo, C4CMD_MoveTo_PushTarget, C4CMD_UnGrab, C4CMD_Wait, cObj, COMD_Stop, C4Action::ComDir, C4Object::Contained, DFA_DIG, DFA_PUSH, Finish(), C4Object::GetProcedure(), C4Object::GetX(), C4Object::GetY(), Inside(), ObjectComStop(), PushToRange, Target, C4Action::Target, Target2, Tx, and Ty.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Put()

void C4Command::Put ( )

protected

Definition at line 1173 of file C4Command.cpp.

{
    // No target container: failure
    if (!Target) { Finish(); return; }
 
    // Thing to put specified by type
    if (!Target2 && Data)
        if (!(Target2 = cObj->Contents.Find(Data.getDef())))
            { Finish(); return; }
 
    // No thing to put specified
    if (!Target2)
        // Assume first contents object
        if (!(Target2 = cObj->Contents.GetObject()))
            // No contents object to put - most likely we did have a target but it was deleted,
            // e.g. by AutoSellContents in a base. New behaviour: if there is nothing to put, we
            // now consider the command succesfully completed.
            { Finish(true); return; }
 
    // Thing is in target
    if (Target2->Contained == Target)
    {
        // Put-count specified: decrease count and continue with next object
        if (Tx._getInt() > 1)
            { Target2 = nullptr; Tx--; return; }
        // We're done
        else
            { Finish(true); return; }
    }
 
    // Thing to put not in contents: get object
    if (!cObj->Contents.GetLink(Target2))
    {
        // Object is nearby and traveling: wait
        if (!Target2->Contained)
            if (Distance(cObj->GetX(),cObj->GetY(),Target2->GetX(),Target2->GetY())<80)
                if (Target2->OCF & OCF_HitSpeed1)
                    return;
        // Go get it
        cObj->AddCommand(C4CMD_Get,Target2,0,0,40); return;
    }
 
    // Target is contained: can't do it
    if (Target->Contained)
        { Finish(); return; }
 
    // Digging: stop
    if (cObj->GetProcedure()==DFA_DIG) ObjectComStop(cObj);
 
    // Grabbing other than target: let go
    C4Object *pGrabbing=nullptr;
    if (cObj->GetProcedure()==DFA_PUSH)
        pGrabbing = cObj->Action.Target;
    if (pGrabbing && (pGrabbing!=Target))
        { cObj->AddCommand(C4CMD_UnGrab,nullptr,0,0,50); return; }
 
    // Inside target container
    if (cObj->Contained == Target)
    {
        // Try to put
        if (!ObjectComPut(cObj,Target,Target2))
            Finish(); // Putting failed
        return;
    }
 
    // Leave own container
    if (cObj->Contained)
        { cObj->AddCommand(C4CMD_Exit,nullptr,0,0,50); return; }
 
    // Target has collection: throw in if not fragile, not grabbing target and throwing position found
    if (Target->OCF & OCF_Collection)
        if (!Target2->Def->Fragile)
            if (pGrabbing!=Target)
            {
                int32_t iTx = Target->GetX() + Target->Def->Collection.x + Target->Def->Collection.Wdt/2;
                int32_t iTy = Target->GetY() + Target->Def->Collection.y + Target->Def->Collection.Hgt/2;
                C4Real pthrow=C4REAL100(cObj->GetPropertyInt(P_ThrowSpeed));
                int32_t iHeight = cObj->Shape.Hgt;
                int32_t iPosX,iPosY;
                int32_t iObjDist = Distance(cObj->GetX(),cObj->GetY(),Target->GetX(),Target->GetY());
                if ( (FindThrowingPosition(iTx,iTy,pthrow,-pthrow,iHeight,iPosX,iPosY) && (Distance(iPosX,iPosY,cObj->GetX(),cObj->GetY()) < iObjDist))
                     || (FindThrowingPosition(iTx,iTy,pthrow*-1,-pthrow,iHeight,iPosX,iPosY) && (Distance(iPosX,iPosY,cObj->GetX(),cObj->GetY()) < iObjDist)) )
                {
                    // Throw
                    cObj->AddCommand(C4CMD_Throw,Target2,iTx,iTy,5);
                    return;
                }
            }
 
    // Target has C4D_Grab_Put: grab target and put
    if (Target->Def->GrabPutGet & C4D_Grab_Put)
    {
        // Grabbing target container
        if (pGrabbing==Target)
        {
            // Try to put
            if (!ObjectComPut(cObj,Target,Target2))
                // Putting failed
                { Finish(); return; }
            // Let go (if we grabbed the target because of this command)
            if (Ty) cObj->AddCommand(C4CMD_UnGrab,nullptr,0,0);
            return;
        }
        // Grab target and let go after putting
        cObj->AddCommand(C4CMD_Grab,Target,0,0,50);
        Ty = 1;
        return;
    }
 
    // Target can be entered: enter target
    if (Target->OCF & OCF_Entrance)
        { cObj->AddCommand(C4CMD_Enter,Target,0,0,50); return; }
 
}

References C4Value::_getInt(), C4Object::Action, C4Object::AddCommand(), C4CMD_Enter, C4CMD_Exit, C4CMD_Get, C4CMD_Grab, C4CMD_Throw, C4CMD_UnGrab, C4D_Grab_Put, C4REAL100(), cObj, C4Def::Collection, C4Object::Contained, C4Object::Contents, Data, C4Object::Def, DFA_DIG, DFA_PUSH, Distance(), C4ObjectList::Find(), FindThrowingPosition(), Finish(), C4Def::Fragile, C4Value::getDef(), C4ObjectList::GetLink(), C4ObjectList::GetObject(), C4Object::GetProcedure(), C4PropList::GetPropertyInt(), C4Object::GetX(), C4Object::GetY(), C4Def::GrabPutGet, C4Rect::Hgt, ObjectComPut(), ObjectComStop(), C4Object::OCF, OCF_Collection, OCF_Entrance, OCF_HitSpeed1, P_ThrowSpeed, C4Object::Shape, Target, C4Action::Target, Target2, Tx, Ty, C4Rect::Wdt, C4Rect::x, and C4Rect::y.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Retry()

void C4Command::Retry ( )

protected

Definition at line 1800 of file C4Command.cpp.

{
 
}

Referenced by Execute().

Here is the caller graph for this function:

Sell()

void C4Command::Sell ( )

protected

Definition at line 1650 of file C4Command.cpp.

{
    Finish();
}

References Finish().

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Set()

void C4Command::Set	(	int32_t	iCommand,
		C4Object *	pObj,
		C4Object *	pTarget,
		C4Value	iTx,
		int32_t	iTy,
		C4Object *	pTarget2,
		C4Value	iData,
		int32_t	iUpdateInterval,
		bool	fEvaluated,
		int32_t	iRetries,
		C4String *	szText,
		int32_t	iBaseMode
	)

Definition at line 1810 of file C4Command.cpp.

{
    // Reset
    Clear(); Default();
    // Set
    Command=iCommand;
    cObj=pObj;
    Target=pTarget;
    Tx=nTx; Ty=iTy;
    if (Command != C4CMD_Call && !Tx.CheckConversion(C4V_Int))
        Tx.SetInt(0);
    Target2=pTarget2;
    Data=iData;
    UpdateInterval=iUpdateInterval;
    Evaluated=fEvaluated;
    Retries=iRetries;
    Text = szText;
    if (Text) Text->IncRef();
    BaseMode=iBaseMode;
}

References BaseMode, C4CMD_Call, C4V_Int, C4Value::CheckConversion(), Clear(), cObj, Command, Data, Default(), Evaluated, C4RefCnt::IncRef(), Retries, C4Value::SetInt(), Target, Target2, Text, Tx, Ty, and UpdateInterval.

Referenced by C4Object::AddCommand().

Here is the call graph for this function:

Here is the caller graph for this function:

Take()

void C4Command::Take ( )

protected

Definition at line 829 of file C4Command.cpp.

{
    ObjectComTake(cObj);
    Finish(true);
}

References cObj, Finish(), and ObjectComTake().

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Take2()

void C4Command::Take2 ( )

protected

Definition at line 835 of file C4Command.cpp.

{
    ObjectComTake2(cObj);
    Finish(true);
}

References cObj, Finish(), and ObjectComTake2().

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Throw()

void C4Command::Throw ( )

protected

Definition at line 755 of file C4Command.cpp.

{
 
    // Digging: stop
    if (cObj->GetProcedure()==DFA_DIG) ObjectComStop(cObj);
 
    // Throw specific object not in contents: get object
    if (Target)
        if (!cObj->Contents.GetLink(Target))
        {
            cObj->AddCommand(C4CMD_Get,Target,0,0,40);
            return;
        }
 
    // Determine move-to range
    int32_t iMoveToRange = MoveToRange;
    if (cObj->Def->MoveToRange > 0) iMoveToRange = cObj->Def->MoveToRange;
 
    // Target coordinates are not default 0/0: targeted throw
    if ((Tx._getInt()!=0) || (Ty!=0))
    {
 
        // Grabbing: let go
        if (cObj->GetProcedure()==DFA_PUSH)
            { cObj->AddCommand(C4CMD_UnGrab,nullptr,0,0,50); return; }
 
        // Preferred throwing direction
        int32_t iDir=+1; if (cObj->GetX() > Tx._getInt()) iDir=-1;
 
        // Find throwing position
        int32_t iTx,iTy;
        C4Real pthrow=C4REAL100(cObj->GetPropertyInt(P_ThrowSpeed));
        int32_t iHeight = cObj->Shape.Hgt;
        if (!FindThrowingPosition(Tx._getInt(),Ty,pthrow*iDir,-pthrow,iHeight,iTx,iTy))
            if (!FindThrowingPosition(Tx._getInt(),Ty,pthrow*iDir*-1,-pthrow,iHeight,iTx,iTy))
                // No throwing position: fail
                { Finish(); return; }
 
        // At throwing position: face target and throw
        if (Inside<int32_t>(cObj->GetX() - iTx, -iMoveToRange, +iMoveToRange) && Inside<int32_t>(cObj->GetY()-iTy,-15,+15))
        {
            if (cObj->GetX() < Tx._getInt()) cObj->SetDir(DIR_Right); else cObj->SetDir(DIR_Left);
            cObj->Action.ComDir=COMD_Stop;
            if (ObjectComThrow(cObj,Target))
                Finish(true); // Throw successfull: done, else continue
            return;
        }
 
        // Move to target position
        cObj->AddCommand(C4CMD_MoveTo,nullptr,iTx,iTy,20);
 
        return;
    }
 
    // Contained: put or take
    if (cObj->Contained)
    {
        ObjectComPutTake(cObj,cObj->Contained,Target);
        Finish(true); return;
    }
 
    // Pushing: put or take
    if (cObj->GetProcedure()==DFA_PUSH)
    {
        if (cObj->Action.Target)
            ObjectComPutTake(cObj,cObj->Action.Target,Target);
        Finish(true); return;
    }
 
    // Outside: Throw
    ObjectComThrow(cObj,Target);
    Finish(true);
}

References C4Value::_getInt(), C4Object::Action, C4Object::AddCommand(), C4CMD_Get, C4CMD_MoveTo, C4CMD_UnGrab, C4REAL100(), cObj, COMD_Stop, C4Action::ComDir, C4Object::Contained, C4Object::Contents, C4Object::Def, DFA_DIG, DFA_PUSH, DIR_Left, DIR_Right, FindThrowingPosition(), Finish(), C4ObjectList::GetLink(), C4Object::GetProcedure(), C4PropList::GetPropertyInt(), C4Object::GetX(), C4Object::GetY(), C4Rect::Hgt, MoveToRange, C4Def::MoveToRange, ObjectComPutTake(), ObjectComStop(), ObjectComThrow(), P_ThrowSpeed, C4Object::SetDir(), C4Object::Shape, Target, C4Action::Target, Tx, and Ty.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Transfer()

void C4Command::Transfer ( )

protected

Definition at line 1571 of file C4Command.cpp.

{
 
    // No target: failure
    if (!Target) { Finish(); return; }
 
    // Find transfer zone
    C4TransferZone *pZone;
    int32_t iEntryX,iEntryY;
    if (!(pZone=Game.TransferZones.Find(Target))) { Finish(); return; }
 
    // Not at or in transfer zone: move to entry point
    if (!Inside<int32_t>(cObj->GetX()-pZone->X,-5,pZone->Wdt-1+5))
    {
        if (!pZone->GetEntryPoint(iEntryX,iEntryY,cObj->GetX(),cObj->GetY())) { Finish(); return; }
        cObj->AddCommand(C4CMD_MoveTo,nullptr,iEntryX,iEntryY,25);
        return;
    }
 
    // Call target transfer script
    if (!::Game.iTick5)
    {
        if (!Target->Call(PSF_ControlTransfer, &C4AulParSet(cObj, Tx, Ty)).getBool())
            // Transfer not handled by target: done
            { Finish(true); return; }
    }
 
}

References C4Object::AddCommand(), C4CMD_MoveTo, C4PropList::Call(), cObj, C4TransferZones::Find(), Finish(), Game, C4TransferZone::GetEntryPoint(), C4Object::GetX(), C4Object::GetY(), C4Game::iTick5, PSF_ControlTransfer, Target, C4Game::TransferZones, Tx, Ty, C4TransferZone::Wdt, and C4TransferZone::X.

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

UnGrab()

void C4Command::UnGrab ( )

protected

Definition at line 748 of file C4Command.cpp.

{
    ObjectComUnGrab(cObj);
    cObj->Action.ComDir=COMD_Stop;
    Finish(true);
}

References C4Object::Action, cObj, COMD_Stop, C4Action::ComDir, Finish(), and ObjectComUnGrab().

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Wait()

void C4Command::Wait ( )

protected

Definition at line 920 of file C4Command.cpp.

{
    // Digging: stop
    if (cObj->GetProcedure()==DFA_DIG) ObjectComStop(cObj);
}

References cObj, DFA_DIG, C4Object::GetProcedure(), and ObjectComStop().

Referenced by Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

BaseMode

int32_t C4Command::BaseMode

Definition at line 92 of file C4Command.h.

Referenced by Clear(), CompileFunc(), Default(), Fail(), and Set().

cObj

C4Object* C4Command::cObj

Definition at line 80 of file C4Command.h.

Referenced by Acquire(), Activate(), Attack(), Call(), CallFailed(), Clear(), ClearPointers(), C4Object::CompileFunc(), Default(), Dig(), Drop(), Enter(), Execute(), Exit(), Fail(), Finish(), FlightControl(), Follow(), Get(), GetTryEnter(), Grab(), InitEvaluation(), Jump(), JumpControl(), MoveTo(), PushTo(), Put(), Set(), Take(), Take2(), Throw(), Transfer(), UnGrab(), and Wait().

Command

int32_t C4Command::Command

Definition at line 81 of file C4Command.h.

Referenced by Activate(), Clear(), CompileFunc(), Default(), C4Object::Draw(), Execute(), C4Object::ExecuteCommand(), Fail(), GetExpGain(), InitEvaluation(), MoveTo(), ObjectComStopDig(), ObjectAddWaypoint::operator()(), and Set().

Data

C4Value C4Command::Data

Definition at line 85 of file C4Command.h.

Referenced by Acquire(), Activate(), CompileFunc(), Default(), Dig(), C4Object::Draw(), Enter(), C4Object::ExecuteCommand(), Fail(), Get(), InitEvaluation(), MoveTo(), ObjectAddWaypoint::operator()(), Put(), and Set().

Evaluated

int32_t C4Command::Evaluated

Definition at line 87 of file C4Command.h.

Referenced by Clear(), CompileFunc(), Default(), InitEvaluation(), MoveTo(), and Set().

Failures

int32_t C4Command::Failures

Definition at line 88 of file C4Command.h.

Referenced by CompileFunc(), Default(), Execute(), and Fail().

Finished

int32_t C4Command::Finished

Definition at line 87 of file C4Command.h.

Referenced by CompileFunc(), Default(), C4Object::Draw(), Execute(), C4Object::ExecuteCommand(), Fail(), and Finish().

iExec

int32_t C4Command::iExec

Definition at line 91 of file C4Command.h.

Referenced by C4Object::ClearCommand(), C4Object::ClearCommands(), Default(), and Execute().

Next

C4Command* C4Command::Next

Definition at line 90 of file C4Command.h.

Referenced by C4Object::AddCommand(), C4Object::Clear(), C4Object::ClearCommand(), C4Object::ClearCommands(), C4Object::ClearPointers(), C4Object::CompileFunc(), Default(), C4Object::Denumerate(), C4Object::Draw(), Fail(), C4Object::FindCommand(), GrabLost(), and MoveTo().

PathChecked

int32_t C4Command::PathChecked

Definition at line 87 of file C4Command.h.

Referenced by Clear(), CompileFunc(), Default(), and MoveTo().

Permit

int32_t C4Command::Permit

Definition at line 88 of file C4Command.h.

Referenced by CompileFunc(), and Default().

Retries

int32_t C4Command::Retries

Definition at line 88 of file C4Command.h.

Referenced by CompileFunc(), Default(), Execute(), Fail(), and Set().

Target

C4ObjectPtr C4Command::Target

Definition at line 84 of file C4Command.h.

Referenced by Acquire(), Activate(), Attack(), Call(), CallFailed(), Clear(), ClearPointers(), CompileFunc(), Default(), Denumerate(), C4Object::Draw(), Drop(), Enter(), C4Object::ExecuteCommand(), Fail(), Follow(), Get(), GetTryEnter(), Grab(), InitEvaluation(), PushTo(), Put(), Set(), Throw(), and Transfer().

Target2

C4ObjectPtr C4Command::Target2

Definition at line 84 of file C4Command.h.

Referenced by Acquire(), Activate(), Call(), CallFailed(), Clear(), ClearPointers(), CompileFunc(), Default(), Denumerate(), C4Object::Draw(), C4Object::ExecuteCommand(), Fail(), Get(), PushTo(), Put(), and Set().

Text

C4String* C4Command::Text

Definition at line 89 of file C4Command.h.

Referenced by Call(), CallFailed(), Clear(), CompileFunc(), Default(), C4Object::Draw(), and Set().

Tx

C4Value C4Command::Tx

Definition at line 82 of file C4Command.h.

Referenced by Acquire(), Activate(), Call(), CallFailed(), Clear(), CompileFunc(), Default(), Denumerate(), Dig(), C4Object::Draw(), Drop(), C4Object::ExecuteCommand(), Fail(), FlightControl(), Get(), Grab(), InitEvaluation(), Jump(), JumpControl(), MoveTo(), PushTo(), Put(), Set(), Throw(), and Transfer().

Ty

int32_t C4Command::Ty

Definition at line 83 of file C4Command.h.

Referenced by Acquire(), Call(), CallFailed(), Clear(), CompileFunc(), Default(), Dig(), C4Object::Draw(), Drop(), C4Object::ExecuteCommand(), Fail(), FlightControl(), Get(), Grab(), InitEvaluation(), JumpControl(), MoveTo(), PushTo(), Put(), Set(), Throw(), and Transfer().

UpdateInterval

int32_t C4Command::UpdateInterval

Definition at line 86 of file C4Command.h.

Referenced by Clear(), CompileFunc(), Default(), Execute(), InitEvaluation(), and Set().

---

The documentation for this class was generated from the following files:

• C4Command.h
• C4Command.cpp