Ares
Public Types | Public Member Functions | Static Public Attributes

SW_PsychicDominator Class Reference

#include <src/Misc/SWTypes/Dominator.h>

Inheritance diagram for SW_PsychicDominator:
NewSWType

List of all members.

Public Types

typedef
PsychicDominatorStateMachine 
TStateMachine

Public Member Functions

 SW_PsychicDominator ()
virtual ~SW_PsychicDominator ()
virtual const char * GetTypeString ()
virtual void LoadFromINI (SWTypeExt::ExtData *pData, SuperWeaponTypeClass *pSW, CCINIClass *pINI)
virtual void Initialize (SWTypeExt::ExtData *pData, SuperWeaponTypeClass *pSW)
virtual bool AbortFire (SuperClass *pSW, bool IsPlayer)
virtual bool Launch (SuperClass *pThis, CellStruct *pCoords, byte IsPlayer)
virtual bool HandlesType (int type)
virtual SuperWeaponFlags::Value Flags ()
void newStateMachine (CellStruct XY, SuperClass *pSuper)

Static Public Attributes

static SuperClass * CurrentPsyDom

Member Typedef Documentation


Constructor & Destructor Documentation

SW_PsychicDominator::SW_PsychicDominator ( ) [inline]
                                      : NewSWType()
                        { };
virtual SW_PsychicDominator::~SW_PsychicDominator ( ) [inline, virtual]
                        { };

Member Function Documentation

bool SW_PsychicDominator::AbortFire ( SuperClass *  pSW,
bool  IsPlayer 
) [virtual]

Reimplemented from NewSWType.

                                                                  {
        // be one with Yuri! and only one.
        if(PsyDom::Active()) {
                if(IsPlayer) {
                        SWTypeExt::ExtData *pData = SWTypeExt::ExtMap.Find(pSW->Type);
                        pData->PrintMessage(pData->Message_Abort, pSW->Owner);
                }
                return true;
        }
        return false;
}
SuperWeaponFlags::Value SW_PsychicDominator::Flags ( ) [virtual]

Reimplemented from NewSWType.

virtual const char* SW_PsychicDominator::GetTypeString ( ) [inline, virtual]

Reimplemented from NewSWType.

                        { return NULL; }
bool SW_PsychicDominator::HandlesType ( int  type) [virtual]

Reimplemented from NewSWType.

{
        return (type == SuperWeaponType::PsychicDominator);
}
void SW_PsychicDominator::Initialize ( SWTypeExt::ExtData pData,
SuperWeaponTypeClass *  pSW 
) [virtual]

Reimplemented from NewSWType.

{
        // Defaults to PsychicDominator values
        pData->SW_WidthOrRange = (float)RulesClass::Instance->DominatorCaptureRange;
        pData->SW_Damage = RulesClass::Instance->DominatorDamage;
        pData->SW_Warhead = &RulesClass::Instance->DominatorWarhead;
        pData->SW_ActivationSound = RulesClass::Instance->PsychicDominatorActivateSound;

        pData->Dominator_FirstAnimHeight = 750;
        pData->Dominator_SecondAnimHeight = 0;
        pData->Dominator_FirstAnim = &RulesClass::Instance->DominatorFirstAnim;
        pData->Dominator_SecondAnim = &RulesClass::Instance->DominatorSecondAnim;
        pData->Dominator_ControlAnim = &RulesClass::Instance->PermaControlledAnimationType;
        pData->Dominator_FireAtPercentage = RulesClass::Instance->DominatorFireAtPercentage;
        pData->Dominator_Ripple = true;
        pData->Dominator_Capture = true;
        pData->Dominator_CaptureMindControlled = true;
        pData->Dominator_CapturePermaMindControlled = true;
        pData->Dominator_CaptureImmuneToPsionics = false;
        pData->Dominator_PermanentCapture = true;

        pData->EVA_Detected = VoxClass::FindIndex("EVA_PsychicDominatorDetected");
        pData->EVA_Ready = VoxClass::FindIndex("EVA_PsychicDominatorReady");
        pData->EVA_Activated = VoxClass::FindIndex("EVA_PsychicDominatorActivated");

        AresCRT::strCopy(pData->Message_Abort, "Msg:DominatorActive", 0x20);

        pData->Lighting_Ambient = &ScenarioClass::Instance->DominatorAmbient;
        pData->Lighting_Red = &ScenarioClass::Instance->DominatorRed;
        pData->Lighting_Green = &ScenarioClass::Instance->DominatorGreen;
        pData->Lighting_Blue = &ScenarioClass::Instance->DominatorBlue;

        pData->SW_AITargetingType = SuperWeaponAITargetingMode::PsychicDominator;
        pData->SW_AffectsTarget = SuperWeaponTarget::Infantry | SuperWeaponTarget::Unit;
        pData->SW_Cursor = MouseCursor::First[MouseCursorType::PsychicDominator];
}
bool SW_PsychicDominator::Launch ( SuperClass *  pThis,
CellStruct *  pCoords,
byte  IsPlayer 
) [virtual]

Implements NewSWType.

{
        if(pThis->IsCharged) {
                // we do not use PsyDom::Start() here. instead, we set a global state and
                // let the state machine take care of everything.
                SW_PsychicDominator::CurrentPsyDom = pThis;
                this->newStateMachine(*pCoords, pThis);
        }

        return true;
}
void SW_PsychicDominator::LoadFromINI ( SWTypeExt::ExtData pData,
SuperWeaponTypeClass *  pSW,
CCINIClass *  pINI 
) [virtual]

Reimplemented from NewSWType.

{
        const char * section = pSW->ID;

        if(!pINI->GetSection(section)) {
                return;
        }

        INI_EX exINI(pINI);
        pData->Dominator_FirstAnimHeight.Read(&exINI, section, "Dominator.FirstAnimHeight");
        pData->Dominator_SecondAnimHeight.Read(&exINI, section, "Dominator.SecondAnimHeight");;
        pData->Dominator_FirstAnim.Parse(&exINI, section, "Dominator.FirstAnim");
        pData->Dominator_SecondAnim.Parse(&exINI, section, "Dominator.SecondAnim");
        pData->Dominator_ControlAnim.Parse(&exINI, section, "Dominator.ControlAnim");;
        pData->Dominator_FireAtPercentage.Read(&exINI, section, "Dominator.FireAtPercentage");
        pData->Dominator_Capture.Read(&exINI, section, "Dominator.Capture");
        pData->Dominator_Ripple.Read(&exINI, section, "Dominator.Ripple");
        pData->Dominator_CaptureMindControlled.Read(&exINI, section, "Dominator.CaptureMindControlled");
        pData->Dominator_CapturePermaMindControlled.Read(&exINI, section, "Dominator.CapturePermaMindControlled");
        pData->Dominator_CaptureImmuneToPsionics.Read(&exINI, section, "Dominator.CaptureImmuneToPsionics");
        pData->Dominator_PermanentCapture.Read(&exINI, section, "Dominator.PermanentCapture");
}
void SW_PsychicDominator::newStateMachine ( CellStruct  XY,
SuperClass *  pSuper 
) [inline]
                                                                        {
                        new TStateMachine(XY, pSuper, this);
                }

Member Data Documentation

SuperClass * SW_PsychicDominator::CurrentPsyDom [static]

The documentation for this class was generated from the following files:
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Defines