I've been playing on and off with a software design approach that facilitates the creation of a model of the ESO combat engine. Essentially a parallel implementation of the core engine.

Clearly it is very difficult to build a highly scalable, yet rigorous to specification, engine. However, by not having to deal with massive real-time scaling performance, I believe one should be able to put together a relatively bug free, compact, clear, rigorous implementation of the combat rules. A great deal of it is out there reversed engineered and documented in postings and spreadsheets.

The Phase 1 target is to implement the core engine as follows:

1. Implement a script system for configuring a build.
2. Implement a script system for defining skills and passives and their effects.
3. Implement all existing classes, enchants, skills, attacks, buffs, debuffs and passives in the script notation.
4. A compiler & interpreter which takes the scripts and builds a combat engine based on the declarative definitions.
5. A script engine for scripting rotations.
6. A simulation engine capable of playing a scripted build and rotation against a scripted build and rotation.
7. A output log of every substantive event in a simulation run.
8. Analysis utilities to summarize the statistics from the simulation run's log.

Phase 1 - Direct goals achieved would include:

1. Definitive, irrefutable evidence that a given build-rotation is better than a different build-rotation against a particular defined "static" dummy build. The effectiveness of a build is a function of the target, however, for a static defined target, for any two builds, the expectation over many simulations should show one build-rotation is better than or equal to another build-rotation.
2. Naive support for two build-rotation scripts to fight head-to-head.
3. MvN static simulations in a single run. i.e. Given M different builds (e.g. identical builds differing only in sharpened, precise or nirnhoned weapons) and N different targets, glass target, tank target, shielding target, high crit resist target, high resistance target see how each build-rotation did against each of the target types in a single run.

Phase 1 - Secondary side effect goals achieved include:

1. Definitively find and document bugs in ESO's core combat calculations and skill implementations.
2. Act as some sort of reference for "correct" behavior.
3. Act as a source of quantified data for many of the debates on combat, bugs, corner cases and builds.
4. Act as a source of quantified data regarding "balance".

Note that the Engine built for Phase I is one built to execute what it is supposed to do (the specification) and NOT what the current ESO engine does (reproduce the bugs). There should be some useful milestones capabilities along the way to completing Phase I.

Phase II

IF Phase I is completed successfully, the engine would be flexible enough to model in a simplified fashion the following:

1. AS-IS model - A model of the current behavior of the current ESO release, bugs and all.
2. SHOULD-BE model - The Phase I model, an implementation based on the specification (notes, documentation etc).
3. COULD-BE model - Hypothetical variation engines that address imbalances, modified skill lines, alternative approaches etc.
4. EXTENDED model - Play with designing a new "class" with passives and an associated skill lines defined via the DSL script.

Personally I'm only interested at the moment in modified engines that address the egregious and growing imbalance issues.

Phase III

With a (simplified) core combat engine implemented a subsequent, simple, keyboard event driven (a la the PC version) implementation with overhead view 2-d "stick figures" fighting would be possible. Even given the design priority of correct over real time massive scalable, I think "real time" combat between 3v3 or even 5v5 across a network will be possible with minimal compromise.[1]

[1] In the sense the engine is deterministic in it's behavior for combat events that happen-before and at-the-same-time.