Ares
Defines | Functions

Hooks.Wave.cpp File Reference

#include "Body.h"
#include "../Techno/Body.h"

Defines

#define upcolor(c)

Functions

 DEFINE_HOOK (6FF5F5, TechnoClass_Fire, 6)
 DEFINE_HOOK (75E963, WaveClass_CTOR, 6)
 DEFINE_HOOK (763226, WaveClass_DTOR, 6)
 DEFINE_HOOK (760F50, WaveClass_Update, 6)
 DEFINE_HOOK (760BC2, WaveClass_Draw2, 9)
 DEFINE_HOOK (760DE2, WaveClass_Draw3, 9)
 DEFINE_HOOK (75EE57, WaveClass_Draw_Sonic, 7)
 DEFINE_HOOK (7601FB, WaveClass_Draw_Magnetron, 0B)
 DEFINE_HOOK (760286, WaveClass_Draw_Magnetron2, 5)
 DEFINE_HOOK (762C5C, WaveClass_Update_Wave, 6)
 DEFINE_HOOK (75F38F, WaveClass_DamageCell, 6)
 DEFINE_HOOK (7601C7, WaveClass_Draw_Purple, 8)

Define Documentation

#define upcolor (   c)
Value:
int _ ## c = initial. c + (Intensity * CurrentColor-> c ) / 256; \
        _ ## c = std::min(_ ## c, 255); \
        modified. c = (BYTE)_ ## c;

Function Documentation

DEFINE_HOOK ( 6FF5F5  ,
TechnoClass_Fire  ,
 
)
{
        GET(WeaponTypeClass *, Source, EBX);
        GET(TechnoClass *, Owner, ESI);
        GET(TechnoClass *, Target, EDI);

        WeaponTypeExt::ExtData *pData = WeaponTypeExt::ExtMap.Find(Source);

        RET_UNLESS(Source->IsMagBeam || Source->IsSonic || pData->Wave_IsLaser || pData->Wave_IsBigLaser);

        GET_BASE(byte, idxWeapon, 0xC);

        TechnoExt::ExtMap.Find(Owner)->idxSlot_Wave = idxWeapon;

        RET_UNLESS(pData->Wave_IsLaser || pData->Wave_IsBigLaser);

        LEA_STACK(CoordStruct *, xyzSrc, 0x44);
        LEA_STACK(CoordStruct *, xyzTgt, 0x88);

        WaveClass *Wave;
        GAME_ALLOC(WaveClass, Wave, xyzSrc, xyzTgt, Owner, pData->Wave_IsBigLaser ? 2 : 1, Target);

        WeaponTypeExt::WaveExt[Wave] = pData;
        Owner->Wave = Wave;
        return 0x6FF650;
}
DEFINE_HOOK ( 7601C7  ,
WaveClass_Draw_Purple  ,
 
)
{
        GET(int, Q, EDX);
        if(Q > 0x15F90) {
                Q = 0x15F90;
        }
        R->EDX(Q);
        return 0;
}
DEFINE_HOOK ( 75F38F  ,
WaveClass_DamageCell  ,
 
)
{
        GET(WaveClass *, Wave, EBP);
        WeaponTypeExt::ExtData *pData = WeaponTypeExt::WaveExt[Wave];
        R->EDI(R->EAX());
        R->EBX(pData->AttachedToObject);
        return 0x75F39D;
}
DEFINE_HOOK ( 762C5C  ,
WaveClass_Update_Wave  ,
 
)
{
        GET(WaveClass *, Wave, ESI);
        TechnoClass *Firer = Wave->Owner;
        TechnoClass *Target = Wave->Target;
        if(!Target || !Firer) {
                return 0x762D57;
        }

        RET_UNLESS(WeaponTypeExt::WaveExt.find(Wave) != WeaponTypeExt::WaveExt.end());
        WeaponTypeExt::ExtData *pData = WeaponTypeExt::WaveExt[Wave];
        int weaponIdx = TechnoExt::ExtMap.Find(Firer)->idxSlot_Wave;

        CoordStruct xyzSrc, xyzTgt, xyzDummy = {0, 0, 0};
        Firer->GetFLH(&xyzSrc, weaponIdx, xyzDummy);
        Target->GetCoords__(&xyzTgt); // not GetCoords() !

        char idx = WeaponTypeExt:: AbsIDtoIdx(Target->WhatAmI());

        bool reversed = pData->Wave_Reverse[idx];

        if(Wave->Type == wave_Magnetron) {
                reversed
                        ? Wave->Draw_Magnetic(&xyzTgt, &xyzSrc)
                        : Wave->Draw_Magnetic(&xyzSrc, &xyzTgt);
        } else {
                reversed
                        ? Wave->Draw_NonMagnetic(&xyzTgt, &xyzSrc)
                        : Wave->Draw_NonMagnetic(&xyzSrc, &xyzTgt);
        }

        return 0x762D57;
}
DEFINE_HOOK ( 760286  ,
WaveClass_Draw_Magnetron2  ,
 
)
{
        return 0x7602D3;
}
DEFINE_HOOK ( 7601FB  ,
WaveClass_Draw_Magnetron  ,
0B   
)
{
        GET_STACK(WaveClass *, Wave, 0x8);
        GET(DWORD, src, EBX);
        GET(DWORD, offset, ECX);
        DWORD offs = src + offset * 2;

        return (WeaponTypeExt::ModifyWaveColor((WORD *)offs, (WORD *)src, R->EBP(), Wave))
                ? 0x760285
                : 0
        ;
}
DEFINE_HOOK ( 75EE57  ,
WaveClass_Draw_Sonic  ,
 
)
{
        GET_STACK(WaveClass *, Wave, 0x4);
        GET(DWORD, src, EDI);
        GET(DWORD, offset, ECX);
        DWORD offs = src + offset * 2;

        return (WeaponTypeExt::ModifyWaveColor((WORD *)offs, (WORD *)src, R->ESI(), Wave))
                ? 0x75EF1C
                : 0
        ;
}
DEFINE_HOOK ( 760DE2  ,
WaveClass_Draw3  ,
 
)
{
        GET(WaveClass *, Wave, EBX);
        GET(WORD *, dest, EDI);

        return (WeaponTypeExt::ModifyWaveColor(dest, dest, Wave->LaserIntensity, Wave))
                ? 0x760ECB
                : 0
        ;
}
DEFINE_HOOK ( 760BC2  ,
WaveClass_Draw2  ,
 
)
{
        GET(WaveClass *, Wave, EBX);
        GET(WORD *, dest, EBP);

        return (WeaponTypeExt::ModifyWaveColor(dest, dest, Wave->LaserIntensity, Wave))
                ? 0x760CAF
                : 0
        ;
}
DEFINE_HOOK ( 760F50  ,
WaveClass_Update  ,
 
)
{
        GET(WaveClass *, pThis, ECX);

        WeaponTypeExt::ExtData *pData = WeaponTypeExt::WaveExt[pThis];
        const WeaponTypeClass *Weap = pData->AttachedToObject;

        RET_UNLESS(Weap);

        int Intensity;

        if(Weap->AmbientDamage) {
                CoordStruct coords;
//              Debug::Log("Damaging Cells for weapon %X (Intensity = %d)\n", pData, pThis->WaveIntensity);
                for(int i = 0; i < pThis->Cells.Count; ++i) {
                        CellClass *Cell = pThis->Cells.GetItem(i);
//                      Debug::Log("\t(%hd,%hd)\n", Cell->MapCoords.X, Cell->MapCoords.Y);
                        pThis->DamageArea(Cell->Get3DCoords3(&coords));
                }
//              Debug::Log("Done damaging %X\n", pData);
        }

        switch(pThis->Type) {
                case wave_Sonic:
                        pThis->Update_Wave();
                        Intensity = pThis->WaveIntensity;
                        --Intensity;
                        pThis->WaveIntensity = Intensity;
                        if(Intensity < 0) {
                                pThis->UnInit();
                        } else {
                                SET_REG32(ECX, pThis);
                                CALL(0x5F3E70); // ObjectClass::Update
                        }
                        break;
                case wave_BigLaser:
                case wave_Laser:
                        Intensity = pThis->LaserIntensity;
                        Intensity -= 6;
                        pThis->LaserIntensity = Intensity;
                        if(Intensity < 32) {
                                pThis->UnInit();
                        }
                        break;
                case wave_Magnetron:
                        pThis->Update_Wave();
                        Intensity = pThis->WaveIntensity;
                        --Intensity;
                        pThis->WaveIntensity = Intensity;
                        if(Intensity < 0) {
                                pThis->UnInit();
                        } else {
                                SET_REG32(ECX, pThis);
                                CALL(0x5F3E70); // ObjectClass::Update
                        }
                        break;
        }

        return 0x76101A;
}
DEFINE_HOOK ( 763226  ,
WaveClass_DTOR  ,
 
)
{
        GET(WaveClass *, Wave, EDI);
        hash_waveExt::iterator i = WeaponTypeExt::WaveExt.find(Wave);
        if(i != WeaponTypeExt::WaveExt.end()) {
                WeaponTypeExt::WaveExt.erase(i);
        }

        return 0;
}
DEFINE_HOOK ( 75E963  ,
WaveClass_CTOR  ,
 
)
{
        GET(WaveClass *, Wave, ESI);
        GET(DWORD, Type, ECX);
        if(Type == wave_Laser || Type == wave_BigLaser) {
                return 0;
        }
        GET(WeaponTypeClass *, Weapon, EBX);

        if(Weapon) {
                WeaponTypeExt::ExtData *pData = WeaponTypeExt::ExtMap.Find(Weapon);
                WeaponTypeExt::WaveExt[Wave] = pData;
        }
        return 0;
}
 All Classes Files Functions Variables Typedefs Enumerations Enumerator Defines