s32 EnTk_ChooseReward(EnTk* this) {
    f32 luck;
    s32 reward;

    luck = Rand_ZeroOne();

    // 40% chance of Green Rupee
    // 30% chance of Blue Rupee
    // 20% chance of Red Rupee
    // 10% chance of Purple Rupee/Piece of Heart
    if (luck < 0.4f) {
        reward = 0;
    } else if (luck < 0.7) {
        reward = 1;
    } else if (luck < 0.9) {
        reward = 2;
    } else {
        reward = 3;
    }

    // This code looks at how many times you've already received a particular reward. If it's below
    // a certain threshold, you just get the expected reward and increment the counter.
    // But if it's reached the threshold, the reward is chosen by the next section of code.
    // Thresholds:
    // Green Rupee: 8x
    // Blue Rupee:  4x
    // Red Rupee:   2x
    // Purple Rupee/Piece of Heart: 1x
    switch (reward) {
        case 0:
            if (this->rewardCount[0] < 8) {
                this->rewardCount[0] += 1;
                return reward;
            }
            break;
        case 1:
            if (this->rewardCount[1] < 4) {
                this->rewardCount[1] += 1;
                return reward;
            }
            break;
        case 2:
            if (this->rewardCount[2] < 2) {
                this->rewardCount[2] += 1;
                return reward;
            }
            break;
        case 3:
            if (this->rewardCount[3] < 1) {
                this->rewardCount[3] += 1;
                return reward;
            }
            break;
    }

    // You can think of this code like a champagne glass tower cascade, where the higher (in this case, lower value)
    // glasses must fill up before the champagne can flow to the next layer. It checks each of the above
    // rewards in ascending order of value. If the above-mentioned threshold for an item has already been met,
    // it skips to the next item. If the threshold hasn't been met, it increments the count and grants that reward.
    // This has two effects:
    // 	1.  You are guaranteed to get the purple rupee (or Piece of Heart, the first time)
    // 	    by the (8 + 4 + 2 + 1) = 15th try.
    // 	2a. It actually punishes "early" good luck—e.g., if you roll a random number that would grant you a Red Rupee
    //       three times in a row, you'll end up with a Green Rupee the third time thanks to that waterfall design. 
    // 	    So in the case where you hit the mercy rule, you will always have received exactly 8 Green Rupees,
    //       4 Blue Rupees, and 2 Red Rupees before getting the top reward.
    // 	2b. More generally, the reward counters are only reset after you've collected 15 rewards—so even if you get
    // 	    the top reward on the first roll, you'd need to get the aforementioned collection of 14 Rupees before
    //       you could possibly get it again.
    if (this->rewardCount[0] < 8) {
        this->rewardCount[0] += 1;
        reward = 0;
    } else if (this->rewardCount[1] < 4) {
        this->rewardCount[1] += 1;
        reward = 1;
    } else if (this->rewardCount[2] < 2) {
        this->rewardCount[2] += 1;
        reward = 2;
    } else if (this->rewardCount[3] < 1) {
        this->rewardCount[3] += 1;
        reward = 3;
    } else {
        reward = 0;
        this->rewardCount[0] = 1;
        this->rewardCount[1] = 0;
        this->rewardCount[2] = 0;
        this->rewardCount[3] = 0;
    }

    return reward;
}