This will force the game to replace the value at an address.

Replace the X values with the address you want to replace a value in.
Replace the Y values with the value you want to put in said address

Example

04000004 00000001

This will force the game to always make address 0x80000004 have the value of "0x1"

This will replace an assembly instruction. For the sake of simplicity, I will not go into detail about the different types of instructions. Those are explained in further detail below.

The X values specify the address you want to execute the instruction at.
The Y values specify the instruction that will be executed at said address.

This type of code requires 2 registers.

  # Assume that you want to replace the value at the address 0x8000FFFF
  # First, you need to load it into a register.
  # Let's load it into Register 0 as an example.

  lis       r0, 0x8000
  ori       r0, r0, 0xFFFF

  # Register 0 now holds the address 0x8000FFFF

  # Next, you need to load the value you want to replace at the address      you loaded into register 0

  # Assume that the value you want to replace at 0x8000FFFF is "0x5" 

  li r1, 0x5

 # Register 0 now holds the address 0x8000FFFF

 # Finally, you have to store the value into the address

 # This instruction below basically tells the code "Whatever value is in     register 1 will be stored into the address held in register 0"

  stw r1, 0x0(r0)

The value at address 0x8000FFFF is now "0x5"

EXAMPLE:

li r0, 1
b function2

function2:
li r0, 2

# After the execution of the li instruction, the code will execute the "b" instruction, this will cause the code to jump to "function2" and start executing every instruction in that function

 This is equivalent to a "goto" statement.

This instruction type requires the mflr and mtlr instruction types, I haven't been able to simplify the explanation for how those 2 instruction work yet.

Example will be added as soon as I can simplify this.

# The value of "X" in the li instruction is the amount of times your code will loop

li r0, 4
mtctr r0

# Register 0 now countains the amount of times the code will loop, which in this case is "4"

# Now for the actual code.

function:
addi r1, r1, 0x1
bdnz function

b loop_has_stopped

To put it simply, if you don't make one of these, the game you're making a code for will crash if you try and replace a value in Registers 0 - 4.

It's going to take a while for me to be able to simplfy the whole process of it.

So for now, here is kiwi515's explanation of it
 

# Update r1 (By subtracting 0x80, we now effectively "own" 0x80 bytes)
stwu sp, -0x80 (sp)

# Backup r3 through r31 into this new area
stmw r3, 0x8 (sp)

# Do whatever with the registers here

# Restore the backups to r3 through r31
lmw r3, 0x8 (sp)

# Update r1 (By adding 0x80, we effectively "give back" the memory that we once owned)
addi sp, sp, 0x80 

Oh man, It was an absolute mindfuck trying to understand how these worked. I had to do a ton of testing.

I'm 90% sure this is wrong, but these are the results I got while testing these instructions in dolphin. 

These instructions work in a very oddly specific way.
 

AND
AND means "If both values are true (equal), the result is true".

AND takes the values from Register B and C and compares them, the result of the operation is put in Register A

EXAMPLE:

# Assume that Register 0 and Register 1 both hold the value "3"

and r2, r0, r1
cmpwi r2, 3
beq function2

# This code will compare the values of Registers 0 and 1 to see if they are both equal to 3, in this case they are, so the code jumps to "function2"

• If both the values are the same, the resulting value is the same as the intial value
   
• If one value is different than the other, the resulting value is
  0 (false)

OR
OR means "If at least one value is true (equal), the result is true.

OR takes the values from Register B and C and compares them, the result of the operation is put in Register A

EXAMPLE:

# Assume that Register 0 holds the value "2" and Register 1 holds the value "3"

or r2, r0, r1
cmpwi r2, 3
beq function2
cmpwi r2, 5
beq function2

# You might be wondering why the resulting register is being checked for the value "5".

# If only one of the values is "true", the resulting value is made up of both values added together, which in this case would be "5"

# The code checks to see if either 1 value was "true" (if r2 = 0x5),
or if both of them were (if r2 = 0x3). If one of those conditions are met, the code jumps to "function2"
 

• If both the values are the same, the resulting value is the intial value
   
• If 1 value is different, the resulting value is the sum of both values added together

XOR
XOR means "Only one value can be true, otherwise the result is false".

XOR takes the values from Register B and C and compares them, the result of the operation is put in Register A

EXAMPLE:

# Assume that Register 0 holds the value "2" and Register 1 holds the value "3"

xor r2, r0, r1
cmpwi r2, 5
beq function2

# Assume that you want your code to jump to "function2" if only 1 of the values in Register 0 and Register 1 is "true"

# I can't think of a good way to explain this.....

# Basically, the xor instruction adds both values from both registers together if one of them is different from the other.

# Let's assume that in this context, you wanted to check to see if Register 0 or Register 1 held the value "2", as the code above shows.

# Register 0 holds the value "2", and Register 1 holds the value "3"

# The resulting value is "5", and the operation result was "true"

# Do you know why the result was true?

#Because "2" was one of the values that was needed to make the result value.

That's the best way I can possibly explain it.

• If both the values are the same, the resulting value is 0 (false)
   
• If 1 value is different, the resulting value is the sum of both values added together