One thing I always felt could be improved in the original xcom is the basic
mechanics of firing. The approach of vanilla (open)xcom is based on a
pencil&paper style to-hit system, mixed in with a little simulationism.
I'll sketch the openxcom mechanics, which seem to be a faithful replication of
the original mechanics. See Projectile::applyAccuracy in
src/BattleScape/Projectile.cpp for details.
When you fire a shot at an enemy, a d100 is rolled; if it comes up less than
your accuracy score, which is a function only of the stats of the shooter and
of the weapon, then you "hit", otherwise you "miss". If you "hit", then the
shot is fired almost directly at the target - with a little random error if
your dice roll was only just low enough to "hit" - while if you "miss" it's
fired with quite a bit of random error, the exact amount of which again
depending on how bad your roll was.
We know how this feels in play - if you shoot (or are shot at) all the way
across the map with 50% accuracy (the number shown when you choose to make a
shot), about half your shots will be way off while most of the other half will
be unnervingly deadly accurate, with also a few near-misses.
This system is fine and neat in many ways, but it has a couple of downsides.
The first is that range is mostly ignored. If you get a decent roll, you're
guaranteed to hit whatever the distance. Distance still has some small effect,
because with a closer target more of the "misses" will actually randomly hit
anyway, but the effect is quite subtle (c.f.
https://www.ufopaedia.org/index.php?title=Firing_Accuracy_Testing).
UFOExtender's "range-based accuracy", an option included in openxcom, deals
with this in an artificial way by directly changing the accuracy score
according to range. It doesn't affect aimed shots, though.
The second problem is that cover isn't nearly as effective as you'd expect,
for exactly the same reasons as with distance. A decent roll means the shot
will hit, ignoring both cover and distance. Again, cover has some small effect
anyway, but not nearly as much as you might think.
All this makes the game less tactically interesting than it could be.
So, this has been bugging me for the last decade or so. Now, finally, with
openxcom we have the opportunity to fix it!
So I suggest we add a new option (off by default, of course) to replace the
vanilla mechanics with something new.
WarBoy says
(
https://github.com/SupSuper/OpenXcom/pull/860#issuecomment-46503455)
that he'll consider this *if* there's some consensus on exactly what the
optional replacement should be; so I'm starting this thread in the hopes of
getting such a consensus.
My suggestion would be to throw away the d100, and *just* add some random
error to each shot, with the amount of noise determined by the accuracy and
nothing else. Then range and cover will have their natural effects - getting a
shot dead-on is very unlikely, so the closer and more exposed the target, the
greater your chance of hitting. Just like in real life. (Disclaimer: I do not
advocate shooting aliens (or anything else) in real life).
I think it's nice to still have the accuracy score mean something concrete, so
I suggest the noise be set such that the chances of hitting a tile at 20
tiles' distance is given by the accuracy. (More concretely, that the error in
horizontal angle be normally distributed with a standard deviation set such
that this holds, with then a separate error in the vertical direction.)
I've implemented this
https://github.com/SupSuper/OpenXcom/pull/860and have been playing with it; to me, it seems to work rather well. It changes
the game quite a bit, and I think it makes it more interesting.
The only problems I see are firstly that getting a strong unit to throw a
grenade is often more effective at longish ranges than sniping, because
throwing accuracy is always high and missing a bit doesn't matter so much, and
secondly that the increased effectiveness of cover sometimes makes it annoying
that it can be difficult to tell what cover there is along a firepath.
So... any thoughts on this, whether on the specifics of the model I
implemented, or on entirely alternative models, or on why I'm utterly wrong
and the vanilla model is entirely unimprovable?