FANDOM


Algorithm detailsEdit

This section mostly covers a discussion on the algorithms used to calculate AADPT and to find cycles and preambles.

Basic AADPT calculationEdit

The basic AADPT calculation is fairly simple.

It can be broken down into a few sections:

  • Pre-loop stuff (reset abilities, setup variables)
  • The loop
    • Reducing cooldowns
    • Finding the next ability
    • Incrementing the counters
  • Post-loop error checking and returning
Psuedocode
FUNCTION (bar)  //bar is an array of Ability objects
  DEFINE time=0, incr=0, damage=0, stunned=0, next, broke=false
  WHILE time < simulation_ticks  //from settings, number of ticks to run for
    reduce cooldown on all abilities by incr (but not below 0)
	reduce stunned by incr (but not below 0)
	
    SET next = null  //reset next
	FOREACH ability IN bar
	  IF ability is off-cooldown
	    SET next = ability
		break
	IF next is null
	  SET broke = true  //the bar doesn't work
	  break
	  
	//activate ability
	put next on cooldown
	SET incr = duration of next
	INCREMENT time BY incr
	
	IF stunned > 0 AND next is a stunbuffed ability
	  INCREMENT damage BY stun damage of next
	ELSE
	  INCREMENT damage BY damage of next
	
	IF stuns are are enabled AND next stuns
	  SET stunned = stun duration of next
	  
  IF not broke
    RETURN damage/time
	
  RETURN not working error

Obviously, extra parts are needed to, for example, make sure every ability is reset before starting, and to turn an array of ability names (strings) into an array of Ability objects.

CycleEdit

Finding the cycle is more complex, and consists of several sections.

A basic overview is as follows:

  • Simulate revolution to generate a long string of integers
  • Find the cycle in this string
    • Reorder the cycle to a more logical representation
  • Check for a preamble
    • If there is one, find it
  • Calculate the AADPT of the cycle
    • and the preamble, if there is one
Simulating revolution

This is essentially the same as the above, but instead of capturing damage, we capture the index of the ability in the bar into a string. It also makes note of how many abilities are used more than twice (if an ability is only used once or twice, it is in the preamble).

Finding the cycle and preamble
FUNCTION (v)  //string of integers
  DEFINE c="", l = length of v, i
  WHILE cycle not found && l >= 2*i
    INCREMENT i BY 1
	SET c = last i characters of v
	IF all abilities have been used AND the [last 2i characters of v] are [c repeated]
	  SET hascycle = true
	  
  IF no cycle was found
    RETURN error
	
  IF [c repeated] contains the first [length of c] integers
    SET haspreamble = false
	SET c = first [length of c] characters of v  //reorder
  ELSE
    SET haspreamble = true
	SET jind = first occurence of c in v
	SET c2 = copy of c
	FOR the length of c2
	  rotate c2 by 1 character
	  SET jind2 = first occurence of c2 in v
	  IF jind2 not found
	    RETURN error
	  IF jind2 < jind
	    INCREMENT ms BY difference of jind2 and jind
		SET jind = jind2
		
    SET preamble = first jind characters of v
	IF ms > 0
	  rotate c by ms characters
Calculate AADPT

Very similar to calculating it normally, but only loops for the length of the cycle and preamble

FUNCTION (bar)  //bar is an array of Ability objects
  DEFINE time=0, incr=0, damage=0, s=""
  FOR length of cycle
    SET ability = ability correspnding to character i
	INCREMENT time BY duration
	
	IF ability is currently stunbuffed
	  INCREMENT damage BY stun damage of ability
	  INCREMENT s BY ability name +'*'
	ELSE
	  INCREMENT damage BY damage of ability
	  INCREMENT s BY ability name
	  
  IF haspreamble
    FOR length of preamble
      SET ability = ability correspnding to character i
	  INCREMENT time BY duration
	
	  IF ability is currently stunbuffed
	    INCREMENT damage BY stun damage of ability
	    INCREMENT s BY ability name +'*'
	  ELSE
	    INCREMENT damage BY damage of ability
	    INCREMENT s BY ability name

Finding the optimal barsEdit

These algorithms are easily adapted to a form that is easily ran repeatedly to find an optimal bar for a given list of abilities.

There's two ways to check bars:

  • Repeatedly randomise the list and calculate, a specific number of times
    While it doesn't guarantee finding the true optimal bar, it usually does, and doing this limits the time required (since it is randomised a specific, predetermined number of times)
  • Check every permutation of the list and calculate
    This will always find the true optimal bar, but the more available abilities there are, the longer it will take -e.g. 9 abilities gives 9! = 362880 permutations. This can take a long time to check, especially on lower-end computers. However, many situations don't need that many abilities so the issue doesn't arrive, making this the preferred method.

The optimal bars given on revolution were calculated using this method.

Ad blocker interference detected!


Wikia is a free-to-use site that makes money from advertising. We have a modified experience for viewers using ad blockers

Wikia is not accessible if you’ve made further modifications. Remove the custom ad blocker rule(s) and the page will load as expected.