Example #1
0
        protected override void BeforeRead(int address, Column column)
        {
            base.BeforeRead(address, column);
            CoreEventRecord evnt = coreEvents[address];

            evnt.Event  |= InstructionEvent.Read;
            evnt.Level   = CoreEventsLevel.Flash;
            evnt.Touched = activeWarrior;
            evnt.Read    = activeWarrior;
            evnt.Version = ++version;
            evnt.Cycle   = cycle;
            evnt.Level   = CoreEventsLevel.Clean;
        }
Example #2
0
        protected override void AfterWrite(int address, Column column)
        {
            base.AfterWrite(address, column);
            CoreEventRecord evnt = coreEvents[address];

            evnt.Level   = CoreEventsLevel.Flash;
            evnt.Touched = activeWarrior;
            if (column == Column.All)
            {
                evnt.Died               = null;
                evnt.Executed           = null;
                evnt.WrittenInstruction = activeWarrior;
                evnt.WrittenData        = activeWarrior;
                evnt.Event             |= InstructionEvent.WrittenInstruction;
                evnt.Event             |= InstructionEvent.WrittenData;
            }
            else
            {
                evnt.WrittenData = activeWarrior;
                evnt.Event      |= InstructionEvent.WrittenData;
            }
            evnt.Version = ++version;
            evnt.Cycle   = cycle;
        }
Example #3
0
        public StepResult PrevStep()
        {
            if (!CanStepBack)
            {
                throw new InvalidOperationException("Cannot step back now");
            }
            EngineEvent e = History.Pop();

            cycle      = e.Cycles;
            cyclesLeft = e.CyclesLeft;
            int lastTask      = e.Warrior.Tasks.Count;
            int liveLastRound = liveWarriors.Count;

            if (e.Died)
            {
                lastTask++;
                if (warriors.Count == 0)
                {
                    liveLastRound++;
                }
            }
            if (e.Split)
            {
                lastTask--;
            }

            // refill live warriors queue
            Queue <EngineWarrior> nlive = new Queue <EngineWarrior>();

            nlive.Enqueue(e.Warrior);
            for (int w = 0; w < liveLastRound - 1; w++)
            {
                nlive.Enqueue(liveWarriors.Dequeue());
            }
            liveWarriors = nlive;

            //refill tasks queue
            Queue <int> ntasks = new Queue <int>();

            ntasks.Enqueue(e.Ip);
            for (int t = 0; t < lastTask - 1; t++)
            {
                ntasks.Enqueue(e.Warrior.Tasks.Dequeue());
            }
            e.Warrior.Tasks = ntasks;

            //rollback core
            while (e.instructionsChanged.Count > 0)
            {
                EngineInstruction ei = e.instructionsChanged.Pop();
                core[ei.Address].Operation           = ei.Operation;
                core[ei.Address].Modifier            = ei.Modifier;
                core[ei.Address].ModeA               = ei.ModeA;
                core[ei.Address].ModeB               = ei.ModeB;
                core[ei.Address].ValueA              = ei.ValueA;
                core[ei.Address].ValueB              = ei.ValueB;
                core[ei.Address].OriginalOwner       = ei.OriginalOwner;
                core[ei.Address].OriginalInstruction = ei.OriginalInstruction;

                CoreEventRecord evnt = CoreEvents[ei.Address];
                evnt.Event              = InstructionEvent.None;
                evnt.Cycle              = cycle;
                evnt.Touched            = null;
                evnt.Executed           = null;
                evnt.Read               = null;
                evnt.Died               = null;
                evnt.WrittenData        = null;
                evnt.WrittenInstruction = null;
                evnt.Version            = ++version;
                evnt.Level              = CoreEventsLevel.Clean;
            }

            if (e.PSpaceAddress != -1)
            {
                PSpaces[e.Warrior.WarriorIndex][e.PSpaceAddress] = e.PSpaceValue;
            }

            lastStepResult = e.PrevStepResult;
            return(e.PrevStepResult);
        }