I just started working on the actual functions that calculate projectile attacks and effects. In ArmCom 1 this was heavily based on Advanced Squad Leader’s To Hit and To Kill tables, but greatly simplified and modified for my purposes. The core of the system generates random numbers that simulate rolling two six-sided dice (2D6), generating a result between 2 and 12, which is then modified up or down depending on different conditions, and compared to a target score to determine success or failure. It’s a strong system, much better than using a single D6 since the results tend to cluster around the middle of the range, with extreme results being much more unlikely. This means that the system can assign unlikely events to the edges (critical hits, weapons malfunction).
Since ArmCom 2 uses a map of tiles each representing roughly 10 meters a side, I first tried to shoehorn an ASL-style line of sight (LoS) hindrance system into the game, assigning values such as 0.2 to each tile, adding up all the modifiers along a given LoS and rounding them off to produce a final modifier. This turned out to not be very effective or elegant. Additionally, there are a lot of cases where I would like to add more exact modifiers than simply +1 or -1. Since ArmCom 2 is a computer game, it can handle the types of complex calculations and random number generation that would bog down a physical board game. So I decided to get rid of the 2D6 system altogether and move to something new.
The new system is, at its core, a percentile system. Different actions are assigned a base difficulty on a scale from 0-100. Modifiers that stem from the entity doing the action, such as better skill, equipment, positions, etc., modify this number to produce a target score. The game then produces a random number between 0-100, applies modifiers to this ‘roll’ based on the target of the action (LoS hinderance, terrain, skill level of the target) and then compares the modified roll to the target score. If the roll is equal to or lower than the target score then (in general) the action is a success, and different target range bands can also be produced for different degrees of success (forcing a pin test on a target versus destroying it outright, for example).
The magic in this system happens with the random number generator, which uses a Gaussian Distribution that works on the same principle as a 2D6 roll: producing a random result that more often stays in the middle of the extremes. This means that the final odds of success are more predictable, but still retain the possibility of surprise. It also allows for a bewildering array of modifiers and calculations to be applied to the ‘roll’, none of which the player has to calculate for themselves, but which still represent the effect of different game conditions on the likelihood of the outcome. The general effect of game conditions will always be knowable to the player (eg. which types of conditions increase the chance to hit) and the exact calculations can always be inspected via the message console, but the player doesn’t have to manually figure everything out to actually do the action.
The result so far seems to be a very robust and flexible system, one that will have to be fine-tuned through playtesting. So far, however, I’m very pleased with the jump from 2D6 to a Gaussian RNG, although I won’t be giving up dice for tabletop wargaming any time soon.