void PlayerColour::serializeObject(void)
{
if (getGameVersion() < genie::GV_AoKA)
serialize(Name, NAME_SIZE);
if (getGameVersion() < genie::GV_AoKA)
{
int16_t ID_short = ID;
serialize<int16_t>(ID_short);
ID = ID_short;
int16_t unk_short = Unknown1;
serialize<int16_t>(unk_short);
Unknown1 = unk_short;
uint8_t col_byte = Colour;
serialize<uint8_t>(col_byte);
Colour = col_byte;
uint8_t unk_byte = Unknown2;
serialize<uint8_t>(unk_byte);
Unknown2 = unk_byte;
}
else
{
serialize<int32_t>(ID);
serialize<int32_t>(Palette);
serialize<int32_t>(Colour);
serialize<int32_t>(Unknown1);
serialize<int32_t>(Unknown2);
serialize<int32_t>(MinimapColour);
serialize<int32_t>(Unknown3);
serialize<int32_t>(Unknown4);
serialize<int32_t>(StatisticsText);
}
}
void Creatable::serializeObject(void)
{
serializeSub<ResourceCost, RESOURCECOSTS_SIZE>(ResourceCosts);
serialize<int16_t>(TrainTime);
serialize<int16_t>(TrainLocationID);
serialize<int8_t>(ButtonID);
if (getGameVersion() >= genie::GV_AoKA)
{
serialize<int32_t>(Unknown26);
serialize<int32_t>(Unknown27);
serialize<int8_t>(MissileGraphicDelay);
if (getGameVersion() >= genie::GV_AoK)
{
serialize<int8_t>(HeroMode);
serialize<int16_t>(GarrisonGraphic);
}
serialize<float>(AttackMissileDuplicationAmount1);
serialize<int8_t>(AttackMissileDuplicationAmount2);
serialize<float, AMDBUNKNOWN_SIZE>(AttackMissileDuplicationSpawning);
serialize<int32_t>(AttackMissileDuplicationUnit);
serialize<int32_t>(AttackMissileDuplicationGraphic);
serialize<int8_t>(Unknown29);
}
serialize<int16_t>(DisplayedPierceArmour);
}
void PlayerColour::serializeObject(void)
{
if (getGameVersion() < genie::GV_AoKA)
serialize<std::string>(Name, NAME_SIZE);
serialize<int32_t>(ID); // int16 + int16 in RoR (2nd part being 0)
if (getGameVersion() < genie::GV_AoKA)
{
int16_t col_short = Colour;
serialize<int16_t>(col_short); // int8 + int8 (2nd part being 1 or 2)
Colour = col_short;
}
else
{
serialize<int32_t>(Palette);
serialize<int32_t>(Colour);
serialize<int32_t>(Unknown1);
serialize<int32_t>(Unknown2);
serialize<int32_t>(MinimapColour);
serialize<int32_t>(Unknown3);
serialize<int32_t>(Unknown4);
serialize<int32_t>(StatisticsText);
}
}
void Projectile::serializeObject(void )
{
serialize<char>(Unknown20);
if (getGameVersion() >= genie::GV_TC)
serialize<char>(Unknown20_1);
serializeSize<uint16_t>(AttackCount, Attacks.size());
serializeSub<unit::AttackOrArmor>(Attacks, AttackCount);
serializeSize<uint16_t>(ArmourCount, Armours.size());
serializeSub<unit::AttackOrArmor>(Armours, ArmourCount);
serialize<int16_t>(Unknown21);
serialize<float>(MaxRange);
serialize<float>(BlastRadius);
serialize<float>(ReloadTime1);
serialize<int16_t>(ProjectileUnitID);
serialize<int16_t>(AccuracyPercent);
serialize<char>(TowerMode);
serialize<int16_t>(Delay); //TODO: missle graphic delay
serialize<float>(GraphicDisplacement, getGraphicDisplacementSize());
serialize<char>(Unknown23); //TODO: AoE/RoR blast level
serialize<float>(MinRange);
if (getGameVersion() >= genie::GV_AoK)
serialize<float>(GarrisonRecoveryRate);
serialize<int16_t>(AttackGraphic);
serialize<int16_t>(DisplayedMeleeArmour);
serialize<int16_t>(DisplayedAttack);
serialize<float>(DisplayedRange);
serialize<float>(ReloadTime2);
}
//------------------------------------------------------------------------------
uint16_t TechTreeAge::getZeroesSize()
{
if (getGameVersion() >= genie::GV_AoK)
{
if (getGameVersion() >= genie::GV_SWGB)
return 99;
else
return 49;
}
else
return 0;
}
//------------------------------------------------------------------------------
void Terrain::serializeObject(void)
{
serialize<int8_t>(Enabled);
serialize<int8_t>(Random);
serialize(Name, getNameSize());
serialize(Name2, getNameSize());
if (getGameVersion() >= genie::GV_AoEB)
serialize<int32_t>(SLP);
serialize<int32_t>(Unknown3);
serialize<int32_t>(SoundID);
if (getGameVersion() >= genie::GV_AoKB)
{
serialize<int32_t>(BlendPriority);
serialize<int32_t>(BlendType);
}
serialize<uint8_t>(Colors, 3);
serializePair<uint8_t>(CliffColors);
serialize<int8_t>(PassableTerrain);
serialize<int8_t>(ImpassableTerrain);
serialize<int8_t>(IsAnimated);
serialize<int16_t>(AnimationFrames);
serialize<int16_t>(PauseFames);
serialize<float>(Interval);
serialize<float>(PauseBetweenLoops);
serialize<int16_t>(Frame);
serialize<int16_t>(DrawFrame);
serialize<float>(AnimateLast);
serialize<int8_t>(FrameChanged);
serialize<int8_t>(Drawn);
serializeSub<FrameData>(ElevationGraphics, TILE_TYPE_COUNT);
serialize<int16_t>(TerrainToDraw);
serializePair<int16_t>(TerrainDimensions);
if (isOperation(OP_READ))
serialize<int16_t>(Borders, getTerrainCount(getGameVersion()));
else
serialize<int16_t>(Borders, Borders.size());
serialize<int16_t>(TerrainUnitID, TERRAIN_UNITS_SIZE);
serialize<int16_t>(TerrainUnitDensity, TERRAIN_UNITS_SIZE);
serialize<int8_t>(TerrainUnitPriority, TERRAIN_UNITS_SIZE);
serialize<int16_t>(NumberOfTerrainUnitsUsed);
if (getGameVersion() < genie::GV_SWGB)
serialize<int16_t>(Unknown1);
}
//------------------------------------------------------------------------------
void TechTree::serializeObject(void)
{
serializeSize<uint8_t>(age_count_, TechTreeAges.size());
serializeSize<uint8_t>(total_building_count_, BuildingConnections.size());
if (getGameVersion() >= genie::GV_SWGB)
serializeSize<uint16_t>(total_unit_count_, UnitConnections.size());
else
{
uint8_t tbc = total_unit_count_;
serializeSize<uint8_t>(tbc, UnitConnections.size());
total_unit_count_ = tbc;
}
serializeSize<uint8_t>(total_research_count_, ResearchConnections.size());
serializeSub<TechTreeAge>(TechTreeAges, age_count_);
serialize<int32_t>(Unknown2);
serializeSub<BuildingConnection>(BuildingConnections, total_building_count_);
serializeSub<UnitConnection>(UnitConnections, total_unit_count_);
serializeSub<ResearchConnection>(ResearchConnections, total_research_count_);
}
//------------------------------------------------------------------------------
unsigned short ResearchConnection::getUnknown2bSize()
{
if (getGameVersion() >= genie::GV_SWGB)
return 18;
else
return 8;
}
//------------------------------------------------------------------------------
unsigned short UnitConnection::getUnknown2bSize()
{
if (getGameVersion() >= genie::GV_SWGB)
return 17;
else
return 7;
}
//------------------------------------------------------------------------------
unsigned short BuildingConnection::getUnknown2aSize()
{
if (getGameVersion() >= genie::GV_SWGB)
return 18;
else
return 8;
}
//------------------------------------------------------------------------------
uint32_t ResearchConnection::getUnknown2aSize()
{
if (getGameVersion() >= genie::GV_SWGB)
return 19;
else
return 9;
}
//------------------------------------------------------------------------------
uint32_t UnitConnection::getUnknown2aSize()
{
if (getGameVersion() >= genie::GV_SWGB)
return 18;
else
return 8;
}
//------------------------------------------------------------------------------
uint32_t BuildingConnection::getUnknown2bSize()
{
if (getGameVersion() >= genie::GV_SWGB)
return 17;
else
return 7;
}
unsigned short Graphic::getName2Size()
{
if (getGameVersion() <= genie::GV_TC)
return NAME_SIZE2;
else
return NAME_SIZE_SWGB;
}
//------------------------------------------------------------------------------
unsigned short TechTreeAge::getZeroesSize()
{
if (getGameVersion() >= genie::GV_SWGB)
return 99;
else
return 49;
}
void DeadFish::serializeObject(void)
{
serialize<int16_t>(WalkingGraphic);
serialize<float>(RotationSpeed);
serialize<int8_t>(Unknown11);
serialize<int16_t>(TrackingUnit);
serialize<int8_t>(TrackingUnitUsed);
serialize<float>(TrackingUnitDensity);
if (getGameVersion() >= genie::GV_AoK)
serialize<float>(Unknown12);
serialize<int8_t>(Unknown16);
if (getGameVersion() >= genie::GV_AoK)
serialize<int8_t, UNKNOWN16B_SIZE>(Unknown16B);
}
BOOL APIENTRY DllMain(HMODULE hInstance, DWORD reason, LPVOID lpReserved) {
Logger logger(LOGFILE);
// ReSharper disable once CppDefaultCaseNotHandledInSwitchStatement
switch (reason) {
case DLL_PROCESS_ATTACH: {
scriptRegister(hInstance, ScriptMain);
keyboardHandlerRegister(OnKeyboardMessage);
logger.Clear();
logger.Write("GTAVManualTransmission v4.1.3");
logger.Write(eGameVersionToString(getGameVersion()));
logger.Write("Script loaded");
break;
}
case DLL_PROCESS_DETACH: {
logger.Write("Init shutdown");
bool successI = MemoryPatcher::RestoreInstructions();
if (successI) {
logger.Write("Shut down script successfully");
}
else {
if (!successI)
logger.Write("Shut down script with instructions not restored");
}
scriptUnregister(hInstance);
keyboardHandlerUnregister(OnKeyboardMessage);
break;
}
}
return TRUE;
}
short SoundItem::getFileNameSize()
{
if (getGameVersion() <= genie::GV_TC)
return 13;
else
return 27;
}
//------------------------------------------------------------------------------
unsigned short Terrain::getNameSize()
{
if (getGameVersion() >= genie::GV_SWGB)
return 17;
else
return 13;
}
float VehicleExtensions::GetThrottleP(Vehicle handle)
{
uint64_t address = mem.GetAddressOfEntity(handle);
int offset = (getGameVersion() > 3 ? 0x8B4 : 0x8A4);
return *reinterpret_cast<float *>(address + offset);
}
void VehicleExtensions::SetThrottle(Vehicle handle, float value)
{
uint64_t address = mem.GetAddressOfEntity(handle);
int offset = (getGameVersion() > 3 ? 0x7E4 : 0x7D4);
*reinterpret_cast<float *>(address + offset) = value;
}
uint32_t VehicleExtensions::GetGears(Vehicle handle)
{
const uint64_t address = mem.GetAddressOfEntity(handle);
int offset = (getGameVersion() > 3 ? 0x7A0 : 0x790);
return address == 0 ? 0 : *reinterpret_cast<const uint32_t *>(address + offset);
}
float VehicleExtensions::GetTurbo(Vehicle handle)
{
const uint64_t address = mem.GetAddressOfEntity(handle);
int offset = (getGameVersion() > 3 ? 0x7F8 : 0x7D8);
return address == 0 ? 0 : *reinterpret_cast<const float *>(address + offset);
}
void VehicleExtensions::SetCurrentRPM(Vehicle handle, float value)
{
const uint64_t address = mem.GetAddressOfEntity(handle);
int offset = (getGameVersion() > 3 ? 0x7D4 : 0x7C4);
*reinterpret_cast<float *>(address + offset) = value;
}
float VehicleExtensions::GetCurrentRPM(Vehicle handle)
{
const uint64_t address = mem.GetAddressOfEntity(handle);
int offset = (getGameVersion() > 3 ? 0x7D4 : 0x7C4);
return address == 0 ? 0.0f : *reinterpret_cast<const float *>(address + offset);
}
void VehicleExtensions::SetGears(Vehicle handle, uint32_t value)
{
const uint64_t address = mem.GetAddressOfEntity(handle);
int offset = (getGameVersion() > 3 ? 0x7A0 : 0x790);
*reinterpret_cast<uint32_t *>(address + offset) = value;
}
GameVersion Game::Version::get()
{
if (sGameVersion == GameVersion::Unknown)
{
sGameVersion = static_cast<GameVersion>(getGameVersion() + 1);
}
return sGameVersion;
}
//------------------------------------------------------------------------------
void TerrainRestriction::serializeObject(void)
{
serialize<float>(PassableBuildableDmgMultiplier, Terrain_Count_);
if (getGameVersion() >= genie::GV_AoKA)
{
serializeSub<TerrainPassGraphic>(TerrainPassGraphics, Terrain_Count_);
}
}
void Projectile::serializeObject(void)
{
if (getGameVersion() < genie::GV_TC)
{
uint8_t defarmor_byte = DefaultArmor;
serialize<uint8_t>(defarmor_byte);
DefaultArmor = defarmor_byte;
}
else
{
serialize<int16_t>(DefaultArmor);
}
serializeSize<uint16_t>(AttackCount, Attacks.size());
serializeSub<unit::AttackOrArmor>(Attacks, AttackCount);
serializeSize<uint16_t>(ArmourCount, Armours.size());
serializeSub<unit::AttackOrArmor>(Armours, ArmourCount);
serialize<int16_t>(Unknown21);
serialize<float>(MaxRange);
serialize<float>(BlastRadius);
serialize<float>(ReloadTime1);
serialize<int16_t>(ProjectileUnitID);
serialize<int16_t>(AccuracyPercent);
serialize<int8_t>(TowerMode);
serialize<int16_t>(Delay); //TODO: missle graphic delay
serialize<float, GRAPHICDISPLACEMENT_SIZE>(GraphicDisplacement);
serialize<int8_t>(BlastLevel);
serialize<float>(MinRange);
if (getGameVersion() >= genie::GV_AoK)
serialize<float>(GarrisonRecoveryRate);
serialize<int16_t>(AttackGraphic);
serialize<int16_t>(DisplayedMeleeArmour);
serialize<int16_t>(DisplayedAttack);
serialize<float>(DisplayedRange);
serialize<float>(ReloadTime2);
}
void SoundItem::serializeObject(void )
{
serialize<std::string>(FileName, getFileNameSize());
serialize<int32_t>(ResourceID);
serialize<int16_t>(Probability);
if (getGameVersion() >= genie::GV_AoK)
{
serialize<int16_t>(Civ);
serialize<int16_t>(Unknown1);
}
}
