`AddSource`

**Note**: most likely this technique is not needed for simple games. So, it's not mandatory for jr-devs.

The `AddSource`

can be chosen in the Flag column of the Achievement Editor

When a condition has the `AddSource`

flag, the value on that memory address is added to the accumulator. When a condition is reached that does not modify the accumulator, the accumulator is added to value of the address on that condition before the comparison is made, and the accumulator will be reset to 0. It may sound a bit confusing, but the example below will clarify how this works:

#### Simple example

ID | Flag | Type | Size | Memory | Cmp | Type | Size | Mem/Val | Hits |
---|---|---|---|---|---|---|---|---|---|

1 | AddSource | Mem | 8-bit | 0x8010 | |||||

2 | Mem | 8-bit | 0x8020 | > | Value | 0x04 | 0 (0) |

In this example the value in `0x8010`

will be added to the value in `0x8020`

and the comparison will check is if this sum is greater than four.

If the value in `0x8010`

is `1`

and the value in `0x8020`

is `2`

, the comparison will be `1 + 2 > 4`

, or `3 > 4`

.

Trying to summarize the explanation in an image:

#### Chaining

You can use the `AddSource`

flag to sum more addresses, like in the example below:

ID | Flag | Type | Size | Memory | Cmp | Type | Size | Mem/Val | Hits |
---|---|---|---|---|---|---|---|---|---|

1 | AddSource | Mem | 8-bit | 0x8010 | |||||

2 | AddSource | Mem | 8-bit | 0x8011 | |||||

3 | Mem | 8-bit | 0x8020 | > | Value | 0x04 | 0 (0) |

This represents `value(0x8010) + value(0x8011) + value(0x8020) > 4`

.

#### Independence

The accumulator is reset after its used, so you can have multiple `AddSource`

chains in one trigger without having to worry about them interfering with each other.

ID | Flag | Type | Size | Memory | Cmp | Type | Size | Mem/Val | Hits |
---|---|---|---|---|---|---|---|---|---|

1 | AddSource | Mem | 8-bit | 0x8010 | |||||

2 | Mem | 8-bit | 0x8020 | > | Value | 0x04 | 0 (0) | ||

3 | AddSource | Mem | 8-bit | 0x8030 | |||||

4 | Mem | 8-bit | 0x8040 | < | Value | 0x80 | 0 (0) |

This represents `value(0x8010) + value(0x8020) > 4 AND value(0x8030) + value(0x8040) < 0x80`

.

#### Overflow

The accumulator and all logic being performed is limited to 32-bits. If the total value exceeds 0xFFFFFFFF, there will be an overflow and only the 32 least significant bits will be used in the comparison.

ID | Flag | Type | Size | Memory | Cmp | Type | Size | Mem/Val | Hits |
---|---|---|---|---|---|---|---|---|---|

1 | AddSource | Mem | 32-bit | 0x8010 | |||||

2 | Mem | 32-bit | 0x8020 | > | Value | 0x30000000 | 0 (0) |

If 0x8010 is 0xC0000000 and 0x8020 is 0x54321ABC, then the total will be 0x114321ABC, which is more than 32-bits and will be truncated to 0x14321ABC, which is not more then 0x30000000, so the logic will evaluate false.

### Using Modifiers

Additionally, you can use AddSource to modify a value. By clicking on the "Cmp" column, a dropdown will open with various math and logical operators. This allows you to modify the value before adding it to the accumulator.

`*`

: Multiply the left side by the right side.

`AddSource 8-bit Mem 0x8010 * Value 0x14`

would read the 8-bit value from $8010, multiply it by 20 (0x14 hex) and then add that to the accumulator.

`/`

: Divide the left side by the right side.

`AddSource 8-bit Mem 0x8010 / Value 0x14`

would read the 8-bit value from $8010, divide by 20 (rounding down) and then add that to the accumulator.- Note: If the divisor (right side) is zero, the result will be treated as a value of 0.

`%`

Modulus operator: Divide the left side by the right side and return the remainder of the division.

`AddSource 8-bit Mem 0x8010 % Value 0x14`

would read the 8-bit value from $8010, divide by 20, and then add the remainder of that division to the accumulator. For example, if $8010 held a value of 43, the result of the modulus operation would be 3, which will be added to the accumulator.- Note: If the divisor (right side) is zero, the result will be treated as a value of 0.

`+`

: Add the left side and the right side.

`AddSource 8-bit Mem 0x8010 + Value 0x14`

would read the 8-bit value from $8010, add 20 to it and then add that to the accumulator.

`-`

: Subtract the right side from the left side.

`AddSource 8-bit Mem 0x8010 - Value 0x14`

would read the 8-bit value from $8010, subtract 20 from it and then add that to the accumulator.

`&`

: Bitwise-mask the left side with the right side.

`AddSource 8-bit Mem 0x8010 & Value 0x3f`

would read the 8-bit value from $8010, discard bits 6 and 7 (0x3f is 00111111 in binary) and then add that to the accumulator.

`^`

: Bitwise-XOR the left side with the right side

`AddSource 8-bit Mem 0x8010 ^ Mem 0x8011`

would read the 8-bit values from $8010 and $8011, and result in a value where the resulting bits would be 1 if the same bit in the two operands differed, or 0 if the same bit in the two operands matched. This result would be added to the accumulator.

You can use memory references on the right side as well. `AddSource 8-bit Mem 0x8010 * 8-bit Mem 0x8011`

would read the two 8-bit values, multiply them together, and add that to the accumulator.

VERSION NOTICE

Addition, subtraction, and modulus operators are slated for the version 1.4 RA_Integration milestone. Processing support will be available in the version 11.4 rcheevos milestone.

### Interaction with floats

The accumulator is typed based on the first thing added to it. If the first `AddSource`

/`SubSource`

of a chain is an integer, the accumulator will be an integer and any floats added to the accumulator will be floored before they're added to the accumulator. If the first `AddSource`

/`SubSource`

of a chain is a float, the accumulator will be a float and any integers added to the accumulator will be converted to floats before they're added to the accumulator.

Note that when the accumulator is added to the final condition, the type of the final condition is used. So if the final condition is float and the accumulator is an integer, the accumulator will be converted to a float before it's added to the final condition.

To force all floats in an `AddSource`

chain to be floored, you need an extra first and last condition:

ID | Flag | Type | Size | Memory | Cmp | Type | Size | Mem/Val | Hits |
---|---|---|---|---|---|---|---|---|---|

1 | AddSource | Value | 0 | ||||||

2 | AddSource | Mem | Float | 0x1000 | |||||

3 | AddSource | Mem | Float | 0x1004 | |||||

4 | AddSource | Mem | Float | 0x1008 | |||||

5 | Value | 0 | > | Value | 12 | 0 (0) |

Line 1 primes the accumulator as an integer, so lines 2-4 will be floored before they're added to the accumulator. Line 5 ensures the final value is an integer before doing the comparison. Without line 1, lines 2-4 would be accumulated as floats. Without line 5, the accumulator would be added to the last float without it being floored.