Example #1
0
 public override ErrorInfo TryParseData(IDataModel model, string name, int dataIndex, ref IFormattedRun run)
 {
     run = new PLMRun(model, dataIndex);
     if (run.Length == 0)
     {
         return(new ErrorInfo("Format specified was for pokemon level-up move data, but could not parse that location as level-up move data."));
     }
     return(ErrorInfo.NoError);
 }
Example #2
0
        public override void UpdateNewRunFromPointerFormat(IDataModel model, ModelDelta token, string name, IReadOnlyList <ArrayRunElementSegment> sourceSegments, int parentIndex, ref IFormattedRun run)
        {
            var runAttempt = new PLMRun(model, run.Start);

            if (runAttempt.Length > 0)
            {
                run = runAttempt.MergeAnchor(run.PointerSources);
                model.ClearFormat(token, run.Start, run.Length);
            }
        }
Example #3
0
        public override bool TryAddFormatAtDestination(IDataModel owner, ModelDelta token, int source, int destination, string name, IReadOnlyList <ArrayRunElementSegment> sourceSegments, int parentIndex)
        {
            var plmRun = new PLMRun(owner, destination);
            var length = plmRun.Length;

            if (length < 2)
            {
                return(false);
            }

            if (!(token is NoDataChangeDeltaModel))
            {
                owner.ObserveRunWritten(token, plmRun);
            }

            return(true);
        }
Example #4
0
 /// <summary>
 /// Parses text in a PLM run to get the level and move.
 /// returns an error string if the parse fails.
 /// </summary>
 private string ValidatePlmText(PLMRun run, int quoteCount, out int level, out int move)
 {
     (level, move) = (default, default);
Example #5
0
        public void Visit(PlmItem item, byte data)
        {
            var memoryLocation = this.memoryLocation;
            var run            = (PLMRun)Model.GetNextRun(memoryLocation);

            // part 1: contraction (if they entered the end token)
            if (CurrentText == EggMoveRun.GroupStart + EggMoveRun.GroupEnd)
            {
                for (int i = this.memoryLocation; i < run.Start + run.Length; i += 2)
                {
                    Model.WriteMultiByteValue(i, 2, CurrentChange, 0xFFFF);
                }
                Model.ObserveRunWritten(CurrentChange, new PLMRun(Model, run.Start));
                return;
            }

            // part 2: validation
            if (!CurrentText.Contains(" "))
            {
                return;
            }
            var quoteCount = CurrentText.Count(c => c == StringDelimeter);

            if (quoteCount % 2 != 0)
            {
                return;
            }
            if (!CurrentText.EndsWith(StringDelimeter.ToString()) && !CurrentText.EndsWith(" "))
            {
                return;
            }
            ErrorText = ValidatePlmText(run, quoteCount, out var level, out var move);
            if (ErrorText != null || move == -1)
            {
                return;
            }

            // part 3: write to the model
            NewDataIndex = memoryLocation + 2;
            Result       = true;
            var value            = (level << 9) + move;
            var initialItemValue = Model.ReadMultiByteValue(memoryLocation, 2);

            Model.WriteMultiByteValue(memoryLocation, 2, CurrentChange, value);

            // part 4: expansion
            if (initialItemValue == 0xFFFF)
            {
                var newRun = Model.RelocateForExpansion(CurrentChange, run, run.Length + 2);
                if (newRun.Start != run.Start)
                {
                    MessageText     = $"Level Up Moves were automatically moved to {newRun.Start.ToString("X6")}. Pointers were updated.";
                    memoryLocation += newRun.Start - run.Start;
                    NewDataIndex    = memoryLocation + 2;
                    DataMoved       = true;
                }
                Model.WriteMultiByteValue(memoryLocation + 2, 2, CurrentChange, 0xFFFF);
                var lvlRun = new PLMRun(Model, newRun.Start);
                Model.ObserveRunWritten(CurrentChange, lvlRun);
            }
        }