Post: [C++/SPRX] PS3 Library (Still In Progress)
Options
07-17-2014, 09:05 PM
#1
Sticky
Mary J Wannnnna
You must login or register to view this content.
Big thanks to Bad Luck Brian for teaching me some stuff!
The following 7 users say thank you to Sticky for this useful post:
The following user thanked TheModedHacker for this useful post:
07-17-2014, 09:15 PM
#3
seb5594
Proud Former Admin
Dude, why are u make a Lib for SPRX? It's really unneeded. All read/write things can be done in just one line. Anyways here i corrected your code...
Originally posted by Sticky
int ReadInt32(int Address)
{
return *(int*)Address;
}
int ReadInt32(int Address)
{
return *(int*)Address;
}
Originally posted by Sticky
float ReadFloat(int Address)
{
float Value = *(int*)Address;
return Value;
}
float ReadFloat(int Address)
{
return (float*)Address;
}
Originally posted by Sticky
void WriteByte(int Address, const char Input)
{
*(char*)Address = Input;
}
void WriteByte(int Address, unsigned char Input)
{
*(unsigned char*)Address = Input;
}
Originally posted by Sticky
char ReadByte(int Address)
{
char Value = *(int*)Address;
return Value;
}
unsigned char ReadByte(int Address)
{
return *(unsigned char*)Address;
}
The following 9 users say thank you to seb5594 for this useful post:
07-17-2014, 09:30 PM
#4
Sticky
Mary J Wannnnna
Originally posted by seb5594
Dude, why are u make a Lib for SPRX? It's really unneeded. All read/write things can be done in just one line. Anyways here i corrected your code...
int ReadInt32(int Address)
{
return *(int*)Address;
}
float ReadFloat(int Address)
{
return (float*)Address;
}
void WriteByte(int Address, unsigned char Input)
{
*(unsigned char*)Address = Input;
}
unsigned char ReadByte(int Address)
{
return *(unsigned char*)Address;
}
Fixed stuff
07-18-2014, 12:38 AM
#5
Absolute Zero
Do your homework, fool.
Originally posted by seb5594
Dude, why are u make a Lib for SPRX? It's really unneeded. All read/write things can be done in just one line. Anyways here i corrected your code...
int ReadInt32(int Address)
{
return *(int*)Address;
}
float ReadFloat(int Address)
{
return (float*)Address;
}
void WriteByte(int Address, unsigned char Input)
{
*(unsigned char*)Address = Input;
}
unsigned char ReadByte(int Address)
{
return *(unsigned char*)Address;
}
Hardly anything changed in your coding, tf makes it better than his?
07-18-2014, 01:19 AM
#6
Black Panther
Guest
07-18-2014, 02:21 AM
#7
Kurt
Banned
Originally posted by Sticky
Hey guys I am here today to bring you my partial PS3 Library for SPRX modding. I am still learning myself too so if you have something I don't feel free to post it below! Also I will be updating this will more stuff as I figure it out! Hope this helps you out...
You must login or register to view this content.
Big thanks to Bad Luck Brian for teaching me some stuff!
You must login or register to view this content.
Big thanks to Bad Luck Brian for teaching me some stuff!
Your ReadString is a little messed up.
07-18-2014, 05:00 AM
#9
ItsLollo1000
Little One
07-18-2014, 06:36 AM
#10
Bitwise
Mario!
You must login or register to view this content.
Then you could do stuff such as
EDIT:
Oh, you might aswell use my data handler aswell then XD
data.cpp:
data.h:
e.g. on how to use;
Then you could do stuff such as
Vector3 vec;
for(int i = 0, f = 25; i < 3; i++, f += 10)
{
(&x)[i] = (25.0 + (float)i);
}
vec.SetVector3(playerState(clientIndex) + 0x1C);
EDIT:
Oh, you might aswell use my data handler aswell then XD
data.cpp:
#include<string>
#include<stdlib.h>
#include<stdarg.h>
#include <math.h>
#define LEFT 0
#define RIGHT 1
#include "data.h"
/*
How to use:
Include the .cpp & .h into your project, and in your main file do this;
#include "data.h"
Data my_name_here();
And then you can use it like so;
my_name_here().WriteInt16(0x000264E, 10);
*/
/* Setting Shiet Up */
//Basic
void Data::WriteInt16(int address, __int16 value) { *(short*)(address) = value; DbgPrint("\tAddress %08X set to value %04X\n", address, value); }
void Data::WriteUInt16(int address, unsigned __int16 value) { *(unsigned short*)(address) = value; DbgPrint("\tAddress %08X set to value %04X\n", address, value); }
void Data::WriteInt32(int address, __int32 value) { *(int*)(address) = value; DbgPrint("\tAddress %08X set to value %08X\n", address, value); }
void Data::WriteUInt32(int address, unsigned __int32 value) { *(unsigned int*)(address) = value; DbgPrint("\tAddress %08X set to value %08X\n", address, value); }
void Data::WriteInt64(int address, __int64 value) { *(__int64*)(address) = value; DbgPrint("\tAddress %08X set to value %016X\n", address, value); }
void Data::WriteUInt64(int address, unsigned __int64 value) { *(unsigned __int64*)(address) = value; DbgPrint("\tAddress %08X set to value %016X\n", address, value); }
void Data::WriteFloat(int address, float value) { *(float*)(address) = value; DbgPrint("\tAddress %08X set to value %f\n", address, value); }
void Data::WriteString(int address, char*value) { strncpy((char*)(address), value, strlen((char*)(address)-1)); DbgPrint("\tAddress %08X has been set to value %s\n", address, value);}
void Data::WriteBoolean(int address, bool value) { *(bool*)(address) = value; DbgPrint("\tAddress %08X has been set to %s", address, (value ? "true" : "false"));}
void Data::WriteByte(int address, byte value) { *(byte*)(address) = value; DbgPrint("\tAddress %08X has been set to %X", address, value); }
__int16 Data::ReadInt16(int address) { return *(short*)(address); DbgPrint("\tAddress %08X Holds %04X\n", address, *(short*)(address)); }
unsigned __int16 Data::ReadUInt16(int address) { return *(unsigned short*)(address); DbgPrint("\tAddress %08X Holds %04X\n", address, *(unsigned short*)(address)); }
__int32 Data::ReadInt32(int address) { return *(int*)(address); DbgPrint("\tAddress %08X Holds %08X\n", address, *(int*)(address)); }
unsigned __int32 Data::ReadUInt32(int address) { return *(unsigned int*)(address); DbgPrint("\tAddress %08X Holds %08X\n", address, *(unsigned int*)(address)); }
__int64 Data::ReadInt64(int address) { return *(unsigned __int64*)(address); DbgPrint("\tAddress %08X Holds %016X\n", address, *(unsigned __int64*)(address)); }
float* Data::ReadFloat(int address) { return (float*)(address); DbgPrint("\tAddress %08X Holds %f\n", address, *(float*)(address)); }
char*Data::ReadString(int address) { return (char*)(address); DbgPrint("\tAddress %08X Holds %s\n", address, (char*)(address)); }
bool Data::ReadBoolean(int address) { return *(bool*)(address); DbgPrint("\tAddress %08X Holds %s", address, (*(bool*)(address) ? "true" : "false")); }
byte Data::ReadByte(int address) { return *(byte*)(address); DbgPrint("\tAddress %08X Holds %X\n", address, *(byte*)(address)); }
//Bitwise
void Data::WriteInt16_Shifted(int address, int flag, int bits) { if(flag == 0) *(short*)(address) <<= bits; else *(short*)(address) >>= bits; }
void Data::WriteUInt16_Shifted(int address, int flag, int bits) { if(flag == 0) *(unsigned short*)(address) <<= bits; else *(unsigned short*)(address) >>= bits; }
void Data::WriteInt32_Shifted(int address, int flag, int bits) { if(flag == 0) *(int*)(address) <<= bits; else *(int*)(address) >>= bits; }
void Data::WriteUInt32_Shifted(int address, int flag, int bits) { if(flag == 0) *(unsigned int*)(address) <<= bits; else *(unsigned int*)(address) >>= bits; }
void Data::WriteInt64_Shifted(int address, int flag, int bits) { if(flag == 0) *(__int64*)(address) <<= bits; else *(__int64*)(address) >>= bits; }
void Data::WriteUInt64_Shifted(int address, int flag, int bits) { if(flag == 0) *(unsigned __int64*)(address) <<= bits; else *(unsigned __int64*)(address) >>= bits; }
void Data::WriteInt16_ShiftedEx(int address, int flag, int bits, short value) { int adr; if(flag == 0){ adr = ((address) << bits);} else{ adr = ((address) >> bits);} *(short*)adr = value; }
void Data::WriteUInt16_ShiftedEx(int address, int flag, int bits, unsigned short value) { int adr; if(flag == 0){ adr = ((address) << bits);} else{ adr = ((address) >> bits);} *(unsigned short*)adr = value; }
void Data::WriteInt32_ShiftedEx(int address, int flag, int bits, int value) { int adr; if(flag == 0){ adr = ((address) << bits);} else{ adr = ((address) >> bits);} *(int*)adr = value; }
void Data::WriteUInt32_ShiftedEx(int address, int flag, int bits, unsigned int value) { int adr; if(flag == 0){ adr = ((address) << bits);} else{ adr = ((address) >> bits);} *(unsigned int*)adr = value; }
void Data::WriteInt64_ShiftedEx(int address, int flag, int bits, __int64 value) { int adr; if(flag == 0){ adr = ((address) << bits);} else{ adr = ((address) >> bits);} *(__int64*)adr = value; }
void Data::WriteUInt64_ShiftedEx(int address, int flag, int bits, unsigned __int64 value) { int adr; if(flag == 0){ adr = ((address) << bits);} else{ adr = ((address) >> bits);} *(unsigned __int64*)adr = value; }
__int16 Data::ReadInt16_Shifted(int address, int flag, int bits) { if(flag==0) { return (*(short*)(address) << bits); } else { return (*(short*)(address) >> bits); } }
unsigned __int16 Data::ReadUInt16_Shifted(int address, int flag, int bits) { if(flag==0) { return (*(unsigned short*)(address) << bits); } else { return (*(unsigned short*)(address) >> bits); } }
__int32 Data::ReadInt32_Shifted(int address, int flag, int bits) { if(flag==0) { return (*(int*)(address) << bits); } else { return (*(int*)(address) >> bits); } }
unsigned __int32 Data::ReadUInt32_Shifted(int address, int flag, int bits) { if(flag==0) { return (*(unsigned int*)(address) << bits); } else { return (*(unsigned int*)(address) >> bits); } }
__int64 Data::ReadInt64_Shifted(int address, int flag, int bits) { if(flag==0) { return (*(__int64*)(address) << bits); } else { return (*(__int64*)(address) >> bits); } }
unsigned __int64 Data::ReadUInt64_Shifted(int address, int flag, int bits) { if(flag==0) { return (*(unsigned __int64*)(address) << bits); } else { return (*(unsigned __int64*)(address) >> bits); } }
void Data::WriteInt16_ORd(int address, __int16 value) { *(short*)(address) |= value; }
void Data::WriteUInt16_ORd(int address, unsigned __int16 value) { *(unsigned short*)(address) |= value; }
void Data::WriteInt32_ORd(int address, __int32 value) { *(int*)(address) |= value; }
void Data::WriteUInt32_ORd(int address, unsigned __int32 value) { *(unsigned int*)(address) |= value; }
void Data::WriteInt64_ORd(int address, __int64 value) { *(__int64*)(address) |= value; }
void Data::WriteUInt64_ORd(int address, unsigned __int64 value) { *(unsigned __int64*)(address) |= value; }
__int16 Data::ReadInt16_ORd(int address, __int16 value) { return (*(short*)(address) | value); }
unsigned __int16 Data::ReadUInt16_ORd(int address, unsigned __int16 value) { return (*(unsigned short*)(address) | value); }
__int32 Data::ReadInt32_ORd(int address, __int32 value) { return (*(int*)(address) | value); }
unsigned __int32 Data::ReadUInt32_ORd(int address, unsigned __int32 value) { return (*(unsigned int*)(address) | value); }
__int64 Data::ReadInt64_ORd(int address, __int64 value) { return (*(__int64*)(address) | value); }
unsigned __int64 Data::ReadUInt64_ORd(int address, unsigned __int64 value) { return (*(unsigned __int64*)(address) | value); }
void Data::WriteInt16_AND(int address, __int16 value) { *(short*)(address) &= value; }
void Data::WriteUInt16_AND(int address, unsigned __int16 value) { *(unsigned short*)(address) &= value; }
void Data::WriteInt32_AND(int address, __int32 value) { *(int*)(address) &= value; }
void Data::WriteUInt32_AND(int address, unsigned __int32 value) { *(unsigned int*)(address) &= value; }
void Data::WriteInt64_AND(int address, __int64 value) { *(__int64*)(address) &= value; }
void Data::WriteUInt64_AND(int address, unsigned __int64 value) { *(unsigned __int64*)(address) &= value; }
void Data::WriteBoolean_XOR(int address, bool value) { *(bool*)(address) ^= value; }
void Data::WriteInt16_XOR(int address, __int16 value) { *(short*)(address) ^= value; }
void Data::WriteUInt16_XOR(int address, unsigned __int16 value) { *(unsigned short*)(address) ^= value; }
void Data::WriteInt32_XOR(int address, __int32 value) { *(int*)(address) ^= value; }
void Data::WriteUInt32_XOR(int address, unsigned __int32 value) { *(unsigned int*)(address) ^= value; }
void Data::WriteInt64_XOR(int address, __int64 value) { *(__int64*)(address) ^= value; }
void Data::WriteUInt64_XOR(int address, unsigned __int64 value) { *(unsigned __int64*)(address) ^= value; }
__int16 Data::ReadInt16_XOR(int address, __int16 value) { return (*(short*)(address) ^ value); }
unsigned __int16 Data::ReadUInt16_XOR(int address, unsigned __int16 value) { return (*(unsigned short*)(address) ^ value); }
__int32 Data::ReadInt32_XOR(int address, __int32 value) { return (*(int*)(address) ^ value); }
unsigned __int32 Data::ReadUInt32_XOR(int address, unsigned __int32 value) { return (*(unsigned int*)(address) ^ value); }
__int64 Data::ReadInt64_XOR(int address, __int64 value) { return (*(__int64*)(address) ^ value); }
unsigned __int64 Data::ReadUInt64_XOR(int address, unsigned __int64 value) { return (*(unsigned __int64*)(address) ^ value); }
bool Data::checkInt16(int address, __int16 value) { return (bool)(*(short*)(address) & value); }
bool Data::checkUInt16(int address, unsigned __int16 value) { return (bool)(*(unsigned short*)(address) & value); }
bool Data::checkInt32(int address, __int32 value) { return (bool)(*(int*)(address) & value); }
bool Data::checkUInt32(int address, unsigned __int32 value) { return (bool)(*(unsigned int*)(address) & value); }
bool Data::checkInt64(int address, __int64 value) { return (bool)(*(__int64*)(address) & value); }
bool Data::checkUInt64(int address, unsigned __int64 value) { return (bool)(*(unsigned __int64*)(address) & value); }
short Data::ReadInt16_NOT(int address) { short val = *(short*)(address); return ~val; }
int Data::ReadInt32_NOT(int address) { int val = *(int*)(address); return ~val; }
__int64 Data::ReadInt64_NOT(int address) { __int64 val = *(__int64*)(address); return ~val; }
short Data::Int16_NOT(short val) { return ~val; }
int Data::Int32_NOT(int val) { return ~val; }
__int64 Data::Int64_NOT(__int64 val) { return ~val; }
//PowerPC
void Data::Address_NOP(int address) { *(int*)(address) = 0x60000000; }
void Data::Address_BranchUncon(int address) { *(short*)(address) = 0x4800; }
void Data::Address_BranchIf(int address) { *(unsigned char*)(address) = 0x41; }
void Data::Address_CheckIf(int address, int*value) { int* lol = (int*)(address); if(*value >= 0x10 && *value < 0x100) { lol[6] = value[0]; lol[7] = value[1]; } else if(*value < 0x10 && *value < 0x100) { lol[7] = *value; } }
__int32 Data::ConvertStringToInt(char*value) { char buffer[0x100]; sprintf(buffer, value); for(int i = 0; i < strlen(value)+1; i++) if(strcmp((char*)value[i], " ") == 0) { value[i] = ' '; } return atoi(value); }
__int64 Data::ConvertStringToLong(char*value) { char buffer[0x100]; sprintf(buffer, value); for(int i = 0; i < strlen(value)+1; i++) if(strcmp((char*)value[i], " ") == 0) { value[i] = ' '; } return atol(value); }
bool Data::Compare(float*v1, float*v2) { for(int i = 0; i < 3; i++) return (fabs(v1[i]-v2[i]) > 0.001); }
float Data:
istanceSq(float*v1,float*v2)
{
float difference[3]; float len;
subVec(v1,v2,difference);
for(int i = 0; i < 3; i++)
len += (difference[i]*difference[i]);
return sqrt(len);
}
}
void Data::Origin2Angles(float*origin,float*angles)
{
float yaw, pitch;
if(!origin[1] && !origin[0])
{
yaw = 0;
if(origin[2] > 0) pitch = 90;
else pitch = 270;
}
else
{
if(origin[0]) { yaw = (atan2(origin[1],origin[0]) * 180 / 3.14159265358979323846); }
else if (origin[1]>0) yaw=90;
else yaw = 270;
if (yaw < 0) yaw += 360;
pitch = (atan2(origin[2], (float)sqrt(origin[0]*origin[0] + origin[1]*origin[1])) * 180 / 3.14159265358979323846);
if(pitch<0) pitch += 360;
}
angles[0] = -pitch; angles[1] = yaw; angles[2] = 0;
}
char* buffer = new char[0x1000];
char* Data::va(char*format,...)
{
va_list params;char*returnn;
va_start(params,format);
vsprintf(buffer, format, params);
va_end(params);
returnn = buffer;
delete[] buffer;
return returnn;
}
#define INT 0
#define FLOAT 1
#define LONGLONG 2
#define BOOL 3
#define BYTE 4
#define STRING 5
#define DOUBLE 6
#define SHORT 7
void Data::dumpStructure(int entry_point, int size, unsigned char dataType, int bytes)//E.G. dumpStructure(0x832F1200, 0x3700, INT, 4); | dumpStructure(0x832F1200, 0x3700, BOOL, 1);
{
for(int i = 0; i != size; i += bytes)//2 - short/wide char | 4 - int/float/long/string/wide char(pointed) | 8 - long long/double | 1 - byte/bool
{
if(dataType & INT) printf("%08X = %08X\n", i,*(int*)(entry_point + i));
if(dataType & FLOAT) printf("%08X = %f\n", i, *(float*)(entry_point + i));
if(dataType & SHORT) printf("%08X = %04X\n", i, *(short*)(entry_point + i));
if(dataType & LONGLONG) printf("%08X = %016X\n", i, *(__int64*)(entry_point + i));
if(dataType & BOOL) printf("%08X = %s\n", i, (*(bool*)(entry_point + i) ? "TRUE" : "FALSE"));
if(dataType & BYTE) printf("%08X = %X\n", i, *(unsigned char*)(entry_point + i));
if(dataType & STRING) printf("%08X = %s\n", i, (char*)(entry_point + i));
if(dataType & DOUBLE) printf("%08X = %d\n", i, *(double*)(entry_point + i));
}
}
void Data::AnglesToForward(float*angles, float*dest)
{
float angle, cy, sy, sp = sin(angles[1]);
angles = angles[0] * (3.14159265358979323846 *2 / 360);
sy = sin(angle);
True
dest[0] = cos(angles[1])*cos(angles[0]);
dest[1] = cos(angles[1])*sin(angles[0]);
dest[2] = -sp;
}
void Data::subVec(float*v1,float*v2,float*dest)
{
for(int i = 0; i < 3; i-++)
dest[i] = (v1[i] - v2[i]);
}
void Data::mulVec(float*v1,float*v2,float*dest)
{
for(int i = 0; i < 3; i++)
dest[i] = (v1[i] * v2[i]);
}
void Data::divVec(float*v1,float*v2,float*dest)
{
for(int i = 0; i < 3; i++)
dest[i] = (v1[i] / v2[i]);
}
void Data::addVec(float*v1,float*v2,float*dest)
{
for(int i = 0; i < 3; i++)
dest[i] = (v1[i] + v2[i]);
}
void Data::cpyVec(float*v1,float*dest)
{
memcpy(dest, v1, 0xC);
}
data.h:
typedef unsigned char byte;//8bits, 1 byte
extern "C" void DbgPrint(const char*format,...);
/*
*********************************************************
* Data Handler v2.2.0 *
* *
* Written by: Bitwise *
* *
* Date Written: 16/04/14 (04/16/14) *
* *
* #BasierendGott *
* *
*********************************************************
*/
typedef enum { X, Y, Z}vec3XYZ;
typedef enum { YAW, PITCH, ROLL }vec3YPR;
class Data
{
public:
Data();
~Data();
//Basic
void WriteInt16(int address, __int16 value);
void WriteInt32(int address, __int32 value);
void WriteInt64(int address, __int64 value);
void WriteUInt16(int address, unsigned __int16 value);
void WriteUInt32(int address, unsigned __int32 value);
void WriteUInt64(int address, unsigned __int64 value);
void WriteFloat(int address, float value);
void WriteString(int address, char*value);
void WriteBoolean(int address, bool value);
void WriteByte(int address, byte value);
__int16 ReadInt16(int address);
__int32 ReadInt32(int address);
__int64 ReadInt64(int address);
unsigned __int16 ReadUInt16(int address);
unsigned __int32 ReadUInt32(int address);
unsigned __int64 ReadUInt64(int address);
float* ReadFloat(int address);
char* ReadString(int address);
bool ReadBoolean(int address);
byte ReadByte(int address);
//Bitwise
#pragma region Shift
void WriteInt16_Shifted(int address, int flag, int bits);
void WriteUInt16_Shifted(int address, int flag, int bits);
void WriteInt32_Shifted(int address, int flag, int bits);
void WriteUInt32_Shifted(int address, int flag, int bits);
void WriteInt64_Shifted(int address, int flag, int bits);
void WriteUInt64_Shifted(int address, int flag, int bits);
void WriteInt16_ShiftedEx(int address, int flag, int bits, __int16 value);//Keep between 1-15
void WriteInt32_ShiftedEx(int address, int flag, int bits, __int32 value); //Keep between 1-31
void WriteInt64_ShiftedEx(int address, int flag, int bits, __int64 value); //Keep between 1-63
void WriteUInt16_ShiftedEx(int address, int flag, int bits, unsigned __int16 value); //Keep between 1-63
void WriteUInt32_ShiftedEx(int address, int flag, int bits, unsigned __int32 value); //Keep between 1-63
void WriteUInt64_ShiftedEx(int address, int flag, int bits, unsigned __int64 value); //Keep between 1-63
__int16 ReadInt16_Shifted(int address, int flag, int bits);
unsigned __int16 ReadUInt16_Shifted(int address, int flag, int bits);
__int32 ReadInt32_Shifted(int address, int flag, int bits);
unsigned __int32 ReadUInt32_Shifted(int address, int flag, int bits);
__int64 ReadInt64_Shifted(int address, int flag, int bits);
unsigned __int64 ReadUInt64_Shifted(int address, int flag, int bits);
#pragma endregion
#pragma region Set
//The following is used to trigger bits within an address to do something (E.g. Data::WriteInt16_ORd(0x82017328, 0x539)
void WriteInt16_ORd(int address, __int16 value);
void WriteUInt16_ORd(int address, unsigned __int16 value);
void WriteInt32_ORd(int address, __int32 value);
void WriteUInt32_ORd(int address, unsigned __int32 value);
void WriteInt64_ORd(int address, __int64 value);
void WriteUInt64_ORd(int address, unsigned __int64 value);
__int16 ReadInt16_ORd(int address, __int16 value);
unsigned __int16 ReadUInt16_ORd(int address, unsigned __int16 value);
__int32 ReadInt32_ORd(int address, __int32 value);
unsigned __int32 ReadUInt32_ORd(int address, unsigned __int32 value);
__int64 ReadInt64_ORd(int address, __int64 value);
unsigned __int64 ReadUInt64_ORd(int address, unsigned __int64 value);
#pragma endregion
#pragma region Clear
//The following is used to terminate bits within an address to disable something. (E.g. Data::WriteInt16_AND(0x82017328, ~0x539); Note: You must use NOT(~) to clear the value. This reverse's the bits.)
void WriteInt16_AND(int address, __int16 value);//Can be used to just AND a value, or terminate something with not
void WriteUInt16_AND(int address, unsigned __int16 value);//Can be used to just AND a value, or terminate something with not
void WriteInt32_AND(int address, __int32 value);
void WriteUInt32_AND(int address, unsigned __int32 value);
void WriteInt64_AND(int address, __int64 value);
void WriteUInt64_AND(int address, unsigned __int64 value);
#pragma endregion
#pragma region Toggle
//The following is used to toggle bits within an address (E.g. Data::WriteInt16_XOR(0x82017328, 0x539)
void WriteBoolean_XOR(int address, bool value);
void WriteInt16_XOR(int address, __int16 value);
void WriteUInt16_XOR(int address, unsigned __int16 value);
void WriteInt32_XOR(int address, __int32 value);
void WriteUInt32_XOR(int address, unsigned __int32 value);
void WriteInt64_XOR(int address, __int64 value);
void WriteUInt64_XOR(int address, unsigned __int64 value);
__int16 ReadInt16_XOR(int address, __int16 value); //Note, when reading it...When you call it once, it will return the flipped bits, call it again...returns the original bits; Js
unsigned __int16 ReadUInt16_XOR(int address, unsigned __int16 value); //Note, when reading it...When you call it once, it will return the flipped bits, call it again...returns the original bits; Js
__int32 ReadInt32_XOR(int address, __int32 value);
unsigned __int32 ReadUInt32_XOR(int address, unsigned __int32 value);
__int64 ReadInt64_XOR(int address, __int64 value);
unsigned __int64 ReadUInt64_XOR(int address, unsigned __int64 value);
#pragma endregion
#pragma region Check
//The following returns either true or false, if the address equals the value given (E.g. Data::checkInt16(0x82017328, 0x539); Returns true if the address is holding 0x539)
bool checkInt16(int address, __int16 value);
bool checkUInt16(int address, unsigned __int16 value);
bool checkInt32(int address, __int32 value);
bool checkUInt32(int address, unsigned __int32 value);
bool checkInt64(int address, __int64 value);
bool checkUInt64(int address, unsigned __int64 value);
#pragma endregion
#pragma region Flip
//The following flips bits. If a bit is 0 it will flip it and return 1, same the other way around. NOTE( Only signed datatypes are supported since flipping the bit will return a neg result )
//addr
short ReadInt16_NOT(int address);
int ReadInt32_NOT(int address);
__int64 ReadInt64_NOT(int address);
//val
short Int16_NOT(short val);
int Int32_NOT(int val);
__int64 Int64_NOT(__int64 val);
#pragma endregion
//PowerPC
void Address_NOP(int address);
#pragma region Branching
void Address_BranchUncon(int address);//unconditional
void Address_BranchIf(int address);//if equal to (==)
void Address_BranchIfNot(int address); //if not equal to (!=)
#pragma endregion
void Address_CheckIf(int address, int*value);//This is only used to alter the value of a cmpwi instruction
//Random
__int32 ConvertStringToInt(char*value);
__int64 ConvertStringToLong(char*value);
#pragma region Vector3
float Distance(float*v1,float*v2);
void subVec(float*v1,float*v2,float*dest);
void mulVec(float*v1,float*v2,float*dest);
void divVec(float*v1,float*v2,float*dest);
void addVec(float*v1,float*v2,float*dest);
void AnglesToFoward(float*angles,float*dest);
void cpyVec(float*v1,float*dest);
bool Compare(float*v1,float*v2);
void Origin2Angles(float*origin,float*angles);
void Angles2Origin(float*angles,float*origin);
#pragma endregion
char*va(char*format,...);
void dumpStructure(int entry_point, int size, unsigned char dataType, int bytes);
};
e.g. on how to use;
Data data();
int thing = data().ReadInt32(0x12340000);
data().WriteInt32(0x1234, (thing+25));
The following 2 users say thank you to Bitwise for this useful post:
Copyright © 2026, NextGenUpdate.
All Rights Reserved.
