コード例 #1
0
        private void Display(string text, StringBuilder message)
        {
            int textIndex = 0;

            while (textIndex < text.Length && this.MessageState.TextHeight <= (HeightMax - 1))
            {
                while (this.dispCharCur < this.dispWidthMax)
                {
                    if (textIndex >= text.Length)
                    {
                        return;
                    }

                    if (text[textIndex] == this.MessageState.NewlineChar)
                    {
                        textIndex++;
                        message.Append(text[textIndex]);
                        textIndex++;
                        this.dispCharCur++;
                    }
                    else
                    {
                        switch (text[textIndex])
                        {
                        case (char)0x0a:
                            // linefeed
                            message.Append(text[textIndex]);
                            textIndex++;
                            this.NewLine();
                            break;

                        case (char)0x20:
                            // space
                            this.dispLastWordIndex = message.Length;
                            message.Append(text[textIndex]);
                            textIndex++;
                            this.dispCharCur++;
                            break;

                        case (char)0x25:
                            // % control
                            textIndex++;

                            int    num = 0;
                            string embedded;

                            switch (text[textIndex++])
                            {
                            case 'g':
                                num      = StringUtility.ParseNumber(text, ref textIndex);
                                embedded = this.Interpreter.ResourceManager.LogicResources[0].GetMessage(num);
                                if (embedded != null)
                                {
                                    this.Display(embedded, message);
                                }

                                break;

                            case 'm':
                                num      = StringUtility.ParseNumber(text, ref textIndex);
                                embedded = this.Interpreter.LogicInterpreter.CurrentLogic.GetMessage(num);
                                if (embedded != null)
                                {
                                    this.Display(embedded, message);
                                }

                                break;

                            case 'o':
                                num      = StringUtility.ParseNumber(text, ref textIndex);
                                embedded = this.Interpreter.ResourceManager.InventoryResource.Items[this.Interpreter.State.Variables[num]].Name;
                                this.Display(embedded, message);
                                break;

                            case 's':
                                num      = StringUtility.ParseNumber(text, ref textIndex);
                                embedded = this.Interpreter.State.Strings[num];
                                this.Display(embedded, message);
                                break;

                            case 'v':
                                num      = StringUtility.ParseNumber(text, ref textIndex);
                                embedded = StringUtility.NumberToString(this.Interpreter.State.Variables[num]);
                                if (textIndex < text.Length && text[textIndex] == '|')
                                {
                                    textIndex++;
                                    int paddingSize = StringUtility.ParseNumber(text, ref textIndex);
                                    embedded = StringUtility.PadWithZeros(embedded, paddingSize);
                                }

                                this.Display(embedded, message);
                                break;

                            case 'w':
                                num = StringUtility.ParseNumber(text, ref textIndex);
                                num--;
                                embedded = this.Interpreter.ParserResults[num].Word;
                                this.Display(embedded, message);
                                break;

                            default:
                                break;
                            }

                            break;

                        default:
                            // normal character
                            message.Append(text[textIndex]);
                            textIndex++;
                            this.dispCharCur++;
                            break;
                        }
                    }
                }

                if (this.dispLastWordIndex == -1)
                {
                    message.Append((char)0x0a);
                    this.NewLine();
                }
                else
                {
                    this.dispCharCur = this.dispCharCur - (message.Length - this.dispLastWordIndex);
                    this.NewLine();
                    message[this.dispLastWordIndex] = (char)0x0a;

                    this.dispCharCur       = message.Length - this.dispLastWordIndex - 1;
                    this.dispLastWordIndex = -1;
                }
            }
        }
コード例 #2
0
 public static string KernelVersion2(string name, string version, string id, string platform, string interpreter)
 {
     return(StringUtility.ConvertSystemResourceText(string.Format(CultureInfo.CurrentUICulture, Resources.KernelVersion2, name, version, id, platform, interpreter)));
 }
コード例 #3
0
        public void PrintFormatted(string text, params object[] args)
        {
            if (text == null)
            {
                throw new ArgumentNullException(nameof(text));
            }

            int currentArgument  = 0;
            int currentCharacter = 0;

            while (currentCharacter < text.Length)
            {
                char c = text[currentCharacter];

                if (c != '%')
                {
                    this.DisplayCharacter(c);
                }
                else
                {
                    currentCharacter++;
                    c = text[currentCharacter];
                    switch (c)
                    {
                    case 's':
                    {
                        // string
                        string arg = (string)args[currentArgument];
                        currentArgument++;
                        this.DisplayString(arg);
                        break;
                    }

                    case 'd':
                    {
                        // decimal
                        short arg = short.Parse(args[currentArgument].ToString(), NumberStyles.Integer, CultureInfo.CurrentCulture);
                        currentArgument++;
                        if (arg < 0)
                        {
                            this.DisplayCharacter('-');
                            this.DisplayString(StringUtility.NumberToString(arg * -1));
                        }
                        else
                        {
                            this.DisplayString(StringUtility.NumberToString(arg));
                        }

                        break;
                    }

                    case 'u':
                    {
                        // unsigned decimal
                        ushort arg = ushort.Parse(args[currentArgument].ToString(), NumberStyles.Integer, CultureInfo.CurrentCulture);
                        currentArgument++;
                        this.DisplayString(StringUtility.NumberToString(arg));
                        break;
                    }

                    case 'x':
                    {
                        // hex number
                        ushort arg = ushort.Parse(args[currentArgument].ToString(), NumberStyles.Integer, CultureInfo.CurrentCulture);
                        currentArgument++;
                        this.DisplayString(StringUtility.NumberToHexString(arg));
                        break;
                    }

                    case 'c':
                    {
                        // character
                        char   arg = '\0';
                        string s   = args[currentArgument].ToString();
                        if (s.Length > 0)
                        {
                            arg = s[0];
                        }

                        currentArgument++;
                        this.DisplayCharacter(arg);
                        break;
                    }

                    default:
                    {
                        // not recognised
                        this.DisplayCharacter('%');
                        currentCharacter--;
                        break;
                    }
                    }
                }

                currentCharacter++;
            }

            this.UpdateTextRegion();
        }