Pkx Editing Functions - FlagBrew/PKSM-Scripts GitHub Wiki

Retrieving PKXs

void party_get_pkx(char* data, int slot);

Read Pkm data from party into a variable

char* data: pointer to an existing variable to write the decrypted Pokémon data to
int slot: 0-indexed slot within the party to read the Pokémon from

void sav_get_pkx(char* data, int box, int slot);

Read Pkm data into a variable

char* data: pointer to an existing variable to write the Pokémon data to
int slot: 0-indexed slot within the box to read the Pokémon from
int box: 0-indexed box number the Pokémon should be read from
NOTE: requires sav_box_decrypt to have already been used

char* bank_get_pkx(enum Generation* type, int box, int slot);

Returns data of the Pokémon in the provided box and slot of the currently active bank

enum Generation* type: pointer to a variable to hold the generation of the Pokémon read from bank
int box: 0-indexed box number the Pokémon should be read from
int slot: 0-indexed slot within the box to read the Pokémon from
The returned char* needs to be manually freed

Injecting PKXs

void party_inject_pkx(char* data, enum Generation type, int slot);

Storing pkm data from a variable into the party

char* data: pointer to an existing variable holding decrypted Pokémon data to be injected
enum Generation type: which generation the data comes from, so that it can be properly written
int slot: 0-indexed slot within the party to inject to

void sav_inject_pkx(char* data, enum Generation type, int box, int slot, int doTradeEdits);

Storing pkm data from a variable into PC boxes

char* data: pointer to an existing variable holding decrypted Pokémon data to be injected
enum Generation type: which generation the data comes from, so that it can be properly written
int box: 0-indexed box number the Pokémon should be injected into
int slot: 0-indexed slot within the box to inject to
int doTradeEdits: whether PKSM should apply appropriate trade logic (1) or not (0)

void bank_inject_pkx(char* data, enum Generation type, int box, int slot);

Storing pkm data from a variable into a PKSM bank

char* data: pointer to an existing variable holding decrypted Pokémon data to be injected
enum Generation type: which generation the data comes from, so that it can be properly written
int box: 0-indexed box number the Pokémon should be injected into
int slot: 0-indexed slot within the box to inject to

void pkx_generate(char* data, int species);

This wipes the current data in the array, then initializes it with the default values that PKSM would provide if you were to generate the specified species from the GUI.

Editing

void pkx_set_value(char* data, enum Generation gen, enum PKX_Field field, ...);

// example usage
char *pkm = malloc(pkx_box_size(GEN_SEVEN));    // allocate memory for a G7 boxed mon
pkx_generate(pkm, 1);                           // make it a new Bulbasaur
pkx_set_value(pkm, GEN_SEVEN, SHINY, 1);        // make it shiny
pkx_set_value(pkm, GEN_SEVEN, OT_NAME, "PKSM"); // make name of its OT PKSM
pkx_set_value(pkm, GEN_SEVEN, MOVE, 0, 100);    // make its first move Teleport

A variadic function that takes arguments with differing types based on the PKX_Field passed in.

char* data: decrypted Pokémon data to set a new value on
enum Generation gen: generation of data
enum PKX_Field field: See below for what fields can be set. The requested arguments are normally single integers, with a few exceptions:
- OT_NAME: Requests a single UTF-8 encoded, null terminated string
- TID: requests a single int but only uses the lower 16 bits for the TID. This means that the range of settable TIDs is 0 to 65535. Trying to set a Generation 7+ TID greater than 65535 may result in a different displayed TID
- SID: requests a single int but uses the lower 16 bits for the SID, meaning the range is 0 to 65535. Setting a Generation 7+ format SID may result in also changing the displayed TID
- NICKNAME: Requests a single UTF-8 encoded, null terminated string
- MOVE: Requests two integers. The first is the index of the move you wish to change (0-3), the second is the value that you wish to set it to.
- PP: Requests two integers. The first is the index of the move you want to change (0-3), the second is the value that you wish to set it to.
- PP_UPS: Requests two integers. The first is the index of the move you want to change (0-3), the second is the value that you wish to set it to.
- POKERUS: Requests two integers. The first is the Pokérus strain, the second is the amount of days left before Pokérus is no longer spreadable
- MET_DAY: Requests a single int from 1-31
- MET_MONTH: Requests a single int from 1-12
- MET_YEAR: Requests a single int from 2000-2255
- EGG_DAY: Requests a single int from 0-31
- EGG_MONTH: Requests a single int from 0-12
- EGG_YEAR: Requests a single int from 2000-2255

unsigned int pkx_get_value(char* data, enum Generation gen, enum PKX_Field field, ...);

// example usage
char *pkm = malloc(pkx_box_size(GEN_SEVEN));              // allocate memory for a G7 boxed Pokémon
sav_get_pkx(pkm, 0, 0);                                   // get Pokémon from box 1, slot 1
int shiny = pkx_get_value(pkm, GEN_SEVEN, SHINY);         // is it shiny?
char *otName = pkx_get_value(pkm, GEN_SEVEN, NICKNAME);   // get its nickname
int move3 = pkx_get_value(pkm, GEN_SEVEN, MOVE, 2);       // get its third move
char pkrs = (char)pkx_get_value(pkm, GEN_SEVEN, POKERUS); // get Pokérus value
char pkrsDaysLeft = pkrs & 0xF;                           // split pkrs into days remaining
char pkrsStrain = pkrs >> 4;                              // and strain

Another variadic function. This will get values out of a PKX_Field, returning the results as an unsigned integer, which, if not what you want already, can be casted to the correct type.

char* data: decrypted Pokémon data to read from
enum Generation gen: generation of data
enum PKX_Field field: See below for what fields can be retrieved. Most fields do not request an argument. Notable caveats and arguments are:
- OT_NAME: Returns a UTF-8 encoded, null terminated string. This must be manually freed.
- TID: returns an int containing the 16-bit TID. This may result in a different value than the displayed value when working with Generation 7+ TIDs
- SID: returns an int containing the 16-bit SID. This may result in a different value than the displayed value when working with Generation 7+ SIDs
- NICKNAME: Returns a UTF-8 encoded, null terminated string. This must be manually freed.
- POKERUS: Returns both the strain and the amount of days left as a single byte. The high nybble is the strain, the low nybble is the amount of days left
- MOVE: Requests a single integer argument and returns the corresponding move ID. Zero means no move is present in that move slot.
- PP: Requests a single integer argument and returns the corresponding move's PP.
- PP_UPS: Requests a single integer argument and returns the corresponding move's amount of PP Ups used.
- MET_DAY: Returns a single int from 1-31
- MET_MONTH: Returns a single int from 1-12
- MET_YEAR: Returns a single int from 2000-2255
- EGG_DAY: Returns a single int from 0-31
- EGG_MONTH: Returns a single int from 0-12
- EGG_YEAR: Returns a single int from 2000-2255

enum PKX_Field {
    OT_NAME,
    TID,
    SID,
    SHINY,
    LANGUAGE,
    MET_LOCATION,
    MOVE,
    BALL,
    LEVEL,
    GENDER,
    ABILITY,
    IV_HP,
    IV_ATK,
    IV_DEF,
    IV_SPATK,
    IV_SPDEF,
    IV_SPEED,
    NICKNAME,
    ITEM,
    POKERUS,
    EGG_DAY,
    EGG_MONTH,
    EGG_YEAR,
    MET_DAY,
    MET_MONTH,
    MET_YEAR,
    FORM,
    EV_HP,
    EV_ATK,
    EV_DEF,
    EV_SPATK,
    EV_SPDEF,
    EV_SPEED,
    SPECIES,
    PID,
    NATURE,
    FATEFUL,
    PP,
    PP_UPS,
    EGG,
    NICKNAMED,
    EGG_LOCATION,
    MET_LEVEL,
    OT_GENDER,
    ORIGINAL_GAME
};

PKX Metadata

int pkx_box_size(enum Generation gen);
int pkx_party_size(enum Generation gen);

Gets the box or party size of a single Pokémon structure for the given format. Mainly meant for easy allocation of char arrays for storing Pokémon data

int pkx_is_valid(char* data, enum Generation gen)

A boolean utility function to see if decrypted Pokémon data (such as that received from party_get_pkx) actually contains a Pokémon.

char* data: decrypted Pokémon data to check
enum Generation gen: generation of data
returns 1 if has a non-zero species value, otherwise 0

PKX Encryption

void pkx_decrypt(char* data, enum Generation type, int isParty);
void pkx_encrypt(char* data, enum Generation type, int isParty);

For encrypting or decrypting PKX data, usually when working with .pk* or .ek* files

char* data: pointer to an existing variable with Pokémon data to encrypt/decrypt
enum Generation type: which generation the data comes from, so that it can be properly decrypted/encrypted
int isParty: Whether the passed data is box-sized (0) or party-sized (1).
both perform their work in place