I am developing a small, turn-based game with spaceships. The user-controlled spaceship has two modes, let's call them offense and defense mode. The user can freely switch between modes. There are three types of enemy-ships. Whenever the user's ship meets one or more enemy-ships, a fight calculation should take place, which can have exactly two outcomes: either the user's ship wins (and does not carry away any damage), or the game is over. Encounters are kinda, but not completely random so one can expect a certain enemy and change the mode accordingly.

For reference, multiple enemy encouters at once might happen, and as a rough idea, the userShip usually is expected to lose if it has to fight 2-5 enemies. Like 2 are too much, if the active fight mode is disadvantageous, whereas the userShip can win against up to four ships, if the mode is advantageous. For encounters with multiple enemy types, the numbers shall be somewhere in between.

My requirements for the combat system are:

  • completely deterministic
  • one mode must not be clearly superior to the other mode. Ideally, one mode is advantageous against a certain enemy type, while the other mode is advantageous against another enemy type (not sure what to do about the third enemy type though)
  • must be somehow scaleable, i.e. there should be three difficulty settings which shall be taken into account.
  • ships have three attributes: Attack, Defense, Speed (however, this isn't set in stone and could be changed at will)

My best idea so far:

  1. assign each ship type base stats (Attack/Defense/Speed, floating point numbers):

userShip: (10/10/10) enemy 1: (5/10/15) enemy 2: (15/5/10) enemy 3: (10/15/5)

  1. create a modifier-table that multiplicates the userShip baseStats with a multiplicator depending on a) userShip-mode and b) enemyShip-type.

  2. have the combat system compare each of the three stats (if multiple enemies involved, their combined strength), and depending on the difficulty setting, the userShip wins if the difference of at least 2 of the 3 attributes is smaller than . That way, I would have the scalability.

However... I was unable to design the modifier table in a way that the modifiers actually make a noticeable difference AND the user has an incentive to switch between modes when he expects a certain enemy in the next turn.

The biggest problem is the nature of the binary combat outcome. This makes it that the floating point multiplicators neglegible most of the time.

Also, I feel like I have way too many parameters (fight mode, attack, defense, speed, difficulty-setting, modifier) for such a simple calculation, but I cannot really remove any other than the modifier, and they all should be at least a little bit relevant for the combat outcome.

Also, I'm not sure how to deal with the third ship type, as there only are two modes. If the mode does not matter at all, that's poor design I think. I could add a third mode for the userShip, however that would introduce even more parameters for the combat. Unsure about that.

Any ideas how to design a combat system under these conditions?

  • \$\begingroup\$ I think a multiplicator is likely the easiest way to go. But the question is rather broad and vague, so it's hard to come to concrete conclusions. \$\endgroup\$
    – Steven
    Commented Mar 29, 2018 at 6:24

1 Answer 1


Your core combat mechanics seem to be very simplistic. If I understood you correctly, all the player does is pick one of two strategies and hope for the best. There is not much room for skill improvement with so little interactivity. So you might want to look for other aspects of your game where you can tweak the difficulty.

Some suggestions without touching your core combat mechanics:

  • Random encounter design: You said "Encounters are kinda, but not completely random". So this is where you could tweak using a difficulty modifier. The higher the difficulty, the higher the average difficulty of encounters. You could also tweak the frequency of encounters.
  • Information available to the player: On lower difficulties, give them all the information they need and warn them when they make a poor decision. On higher difficulties, give them very little information and expect them to make the right decision based on experience.
  • Strength of the AI: Does the AI also choose a mode? If so, program the AI to make poor decisions on lower difficulties and more smart decisions on higher difficulties.
  • Margin for error: Tweak what happens if the player loses a combat. It might be an instant game over on the highest difficulty but only a slap on the wrist on the lowest.
  • Resource management: Does the player accumulate any resources which make them stronger over the course of the game? Then give them less resources or increase the prices when playing on higher difficulties.

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .