First, I love the ability to set custom card scales. This is really, really cool. However, I have a few questions and suggestions.

Question #1:

How does the ramp work? I can't figure it out. Changing the ramp amount just increases the increment value, and changing the ramp value doesn't seem to do anything at all. Am I missing something, or is it broken?

Suggestion #1:

Can you increase the max reset value to at least 200?

Suggestion #2:

It would be nice to also have a plateau value as an alternative to the reset. For example, instead of going 5,10,15,20,25,5,10... it would go 5,10,15,20,25,25,25...

You can do that:

Start Value 5
Increment 5
Reset 0
Ramp 25
Ramp Increment 0

Edit:  Nope, that won't work.  Good in theory, however.

Kjeld wrote: How does the ramp work? I can't figure it out. Changing the ramp amount just increases the increment value, and changing the ramp value doesn't seem to do anything at all. Am I missing something, or is it broken?

I think I finally figured this out.  The idea is to allow two different ramps and to switch to the second ramp after a certain time.  The initial ramp is controlled by the Start Value and the Increment value.  Once you reach the Ramp Value, the new increment value is (Increment + Ramp Amount), in other words, Ramp Amount is the increase in the increment.

If Ramp Amount was allowed to be a negative value, you could have a plateau by making Ramp Amount = -Increment.

I'd be inclined to replace Ramp Amount with Second Increment, which I think would be a little easier to figure out.

Hmm, interesting. In that case, I would suggest introducing a "smooth" ramp as well, where the rate of increase goes up over time. It would be nice to specify a scale that went something like, 1,2,3,4,5,6,8,10,12...,18,21,24,27...36,40, etc.

Or like 5,10,20,35,60,100,5,10,20...

Just ideas, not critical, though.

hi guys - now's a good time to change these settings before anyone really uses them as otherwise any settings changes would need to be retrofitted to existing boards.

As you've worked out RB, the increment goes up by rampAmount + incrementAmount after rampValue is exceeded.

The problem is having enough settings to have any possible escalation type... it's quite tricky. Happy to implement whatever you can come up with...

Is there an easy way to add a scale that allows me to stop increasing the cards at some point: 1, 2, 3, 4, ...,20, 20, 20... I really want that one.

I could easily allow the Rampup amount to be negative, then Red Baron's suggestion for doing this would work.

Or I could add a card limit value.

Okay, I came up with a card value C function that does what I think it should do, which is:

• Implement all the standard card options.
• Allow plateaus.
• Allow scaling card sets by the number of players in the game (as discussed in another topic).

The standard Risk card option (4,6,8,10,12,15,20,25...) requires three slopes, so I designed for three slopes, though two would probably be enough for most people.  I'll first define several variables:

n = card set being cashed (n=1 for first card set)
y0 = value of initial card set (when n=1)
s0 = initial slope (increment) value
x1 = value of n at which to end first slope (x1=0 if no second slope)
s1 = slope value after x1
x2 = value of n at which to end second slope (x2=0 if no third slope)
s2 = slope value after x2
R = value of n at which to start the cycle over (R=0 for no cycling)
N = number of players in the game (N=0 if scaling by players not used)

The function is:

int value(int n, int y0, int s0, int x1, int s1, int x2, int s2, int R, int N) {
    // Let's count from zero to keep things simple
    float x = n - 1;
    x1 = x1 - 1;
    x2 = x2 - 1;
    
    // Scale cards by the number of players (N=0 for no scaling)
    if (N > 0) x = (4*x)/N;
    
    // Cycle values after R card sets (R=0 for no cycling)
    if (R > 0) x = fmod(x, R);
    
    // Select one of three slopes depending on x1 and x2 values
    if ((x1 == 0) || (x <= x1)) {
        // First slope
        return (int)(y0 + x * s0);
    }
    else if ((x2 == 0) || (x <= x2)) {
        // Second slope
        return (int)(y0 + x1 * s0 + (x - x1) * s1);
    }
    else {
        // Third slope
        return (int)(y0 + x1 * s0 + (x2 - x1) * s1 + (x - x2) * s2);
    }
}

I haven't fully tested it, but I think this will work.

can you cycle the cards so they continue to rise?
eg. 2,4,6,8,10,4,6,8,10,12,6,8,10,12,14,8,10,12,14,16,10,12,14,16,18 etc....