Looking for a good design pattern for this set of objects.

Question

I originally asked this question on programmers.stackexchange.com, because I figured the answers would be too subjective for stackoverflow. However, in the comments Muad'Dib pointed this out:

this would probably be a better fit for StackOverflow ... This is a direct programming problem-related question and discusses programming solutions. One solution may be equal to another where the choice between them is subjective, but the discussion of the overall problem itself is not as some solutions are clearly not applicable. So this question does have one or a few good answers, whereas questions such as "Which is the best text editor?" does not...

So, after pondering the situation a little more (and looking at a few patterns that don't seem to fit), here is my dilemma:

The Set Up

I'm designing a simple combat strategy game.

1. Two combatants attack each other for a certain amount of time.
2. The winner is the one with the most health after the time is up.
3. There is no direct intervention by the players during the fight. Players define some strategies for their combatant before the fight, and the "AI" (term used loosely) determines what the combatants will do.
4. The fight consists of an arbitrary timer that "ticks" seconds, and a combatants' attack speed (among other things) determines how often they do something.
5. Besides the combatant objects, there is also a "weather" object that can have some random environmental effects on the combatant's abilities.
6. The whole thing just loops through each second, environmental effects and attacks are determined and executed, it's all logged, and the log is displayed to the user afterward as a play-by-play.

The Problem

I'm not sure what design pattern would best allow me to accomplish the above. I'm looking for a pattern that will allow me to increase the complexity of the "fight" down the road. Probably by adding more objects to the fight (more combatants, maybe a new environment object, etc.)

At first I thought the Observer pattern would work. I would have a fight object that represents the "observee/subject". It tracks a timer, and as the timer increments, it updates all of the participant observer objects. However, a lot of a defender combatants' parameters can affect actions of an attacker combatant, so the "observers" in that scenario need to be aware of each other, so I'm not sure if it's the right approach.

Finally, I'm not trying to nail a design pattern perfectly. Maybe there is no "best fit." I'm just looking for a solid base to build upon.

Answer 1

Trying to find a single 'right' design pattern for a fairly detailed situation is a fruitless search. Design patterns address certain common low-level situations that arise in a specific programming language or languages - there isn't necessarily a specific one existing for every possible situation you might find, nor are you necessarily only going to use a single one to solve your problem.

In particular this situation is not really what design patterns are there for - design patterns primarily concern the static relationship between classes and objects, whereas what you are talking about here is inherently algorithmic in nature. Design patterns provide ways in which you can implement algorithms, but aren't really algorithms in themselves.

This should be quite straightforward. You have a while loop that runs for the specified duration. Each iteration represents one second of elapsed time, and in that iteration it would call a method or methods on every relevant object involved in the fight - the combatants, the weather, etc. (How many methods and which ones is a game design question and not (yet) a programming question.) These objects can come from a fight object that holds the entire context if you like.

There is no real need for the observer pattern here, and in fact it will seriously complicate the matter by changing it from an easily understandable iterative process to an event-driven one. A combatant can query another combatant directly if access is required to various properties.

Answer 2

If you really wanted to use a pattern here I would consider a command pattern. For example you can just que up a string of commands "fight moves" to execute over a period a time. You would also be able to easily cancel commands based on what the opponent is doing quite easily and generically. You can easilly add to moves/ strategies to this as your develop your game down the road.

But this isnt a pattern for the entire game, it's more a solution for one aspect of it.