         @view.draw ctx
 
 
-      doStepSimpleRule: (step_size) ->
-          for i in [0...step_size]
-            @gol.transform @rule.rules[@rule_phase]
-            @rule_phase = mod (@rule_phase + 1), @rule.size()
-            @onStep @rule_phase
-          @generation += step_size
-
-      doStepRuleset: (step_size) ->
-        phase = @ruleset_phase
-        ruleset = @ruleset
+      doStepImpl: (rule, step_size) ->
+        phase = @rule_phase
         for i in [0...step_size]
-          @gol.transform ruleset.rules[phase]
-          @ruleset_phase = phase = (phase+1) % ruleset.length
+          @gol.transform rule.rules[phase]
+          @rule_phase = phase = (phase+1) % rule.size()
           @onStep phase
         @generation += step_size
         
+
+      getActiveRule: ->
+        if @stable_enabled
+          @stable_rule
+        else
+          @rule
           
       onStep: (rulesetPhase)->
         if (gc = @spaceship_catcher)
-          if (@ruleset.size() > 1) and not @ruleset_enabled
-            alert "Rule is unstable, disabling catcher. Enable stabilization to make it available"
+          if (@stable_rule.size() > 1) and not @stable_enabled
+            alert "Disabling catcher. Enable stabilization to make it available"
             @disable_spaceship_catcher()
           else
             gc.scan @gol
           
       doStep: ->
-          if @ruleset_enabled
-            @doStepRuleset @step_size
-          else
-            @doStepSimpleRule @step_size
+          @doStepImpl @getActiveRule(), @step_size
           @showRulesetPhase()
             
           if @spaceship_catcher? and @generation >= @spaceship_catcher.reseed_period
             @generation = 0
-            @ruleset_phase = 0
+            @rule_phase = 0
             @do_clear()
             @random_fill_selection parseFloat(E("random-fill-percent").value)*0.01
           @updateCanvas()
           @update_time()
           @recordFrame()
 
-      doReverseStepRuleset: (step_size)->
-        phase = @ruleset_phase
-        iruleset = @inverse_ruleset
+      doReverseStepImpl: (irule, step_size)->
+        phase = @rule_phase
         for i in [0...step_size]
-          phase = mod (phase-1), iruleset.size()
-          @gol.untransform iruleset.rules[phase]
-          
-        @ruleset_phase = phase
+          phase = mod (phase-1), irule.size()
+          @gol.untransform irule.rules[phase]
+        @rule_phase = phase
         @generation -= @step_size
 
-      doReverseStepSimpleRule: (step_size)->
-        irule = @inverse_rule
-        for i in [0...@step_size]
-          @rule_phase = mod (@rule_phase-1), @rule.size()
-          @gol.untransform irule.rules[@rule_phase]
-        @generation -= @step_size
-        
+      getActiveRuleInv: ->
+        if @stable_enabled
+          @inverse_stable_rule
+        else
+          @inverse_rule
+      
       doReverseStep: ->
         unless @inverse_rule
           alert "Rule is not reversible"
           @stopPlayer()
           return
-        if @ruleset_enabled
-          @doReverseStepRuleset @step_size
-        else
-          @doReverseStepSimpleRule @step_size
+        @doReverseStepImpl @getActiveRuleInv(), @step_size
         @showRulesetPhase()
-
         @updateCanvas()
         @update_time()
         @recordFrame()

              alert "Rule must be specified, when using ruleset_phase"
            else
              phase = parseInt keys.ruleset_phase
              unless phase >=0 and phase < @ruleset.size()
                alert "Ruleset phase #{phase} is outside of allowed region"
              else
                @ruleset_enabled = true
                @ruleset_phase = phase
                @showRulesetPhase()
                
          if keys.frame_delay?

        urlArgs.push "size=#{fld.width}x#{fld.height}"
        urlArgs.push "cell_size=#{@view.cell_size},#{@view.grid_width}"
        urlArgs.push "phase=#{@gol.phase}"
        if @stable_enabled
          urlArgs.push "ruleset_phase=#{@rule_phase}"

        loc = ""+window.location
        if (anchorStartsAt = loc.indexOf "#") isnt -1
