public void PickupItem() { //From Ground Point inventoryUserPosition = GetParent().GetComponent <SpriteAnimation>(ComponentType.SpriteAnimation).Position; var a = GetParent().GetComponent <Actor>(ComponentType.Actor); if (a != null) { var i = a.Map.GetItemAt(inventoryUserPosition.X, inventoryUserPosition.Y); if (i != null) { AddItem(i); i.GetComponent <SpriteAnimation>(ComponentType.SpriteAnimation).IsVisible = false; i.GetComponent <SpriteAnimation>(ComponentType.SpriteAnimation).Position = new Point(0, 0); if (GetParent().logger != null) { ColoredString str = new ColoredString("Item : "); str += string.Format("{0}", i.NAME).CreateColored(Color.Cyan); str += ", Picked up.".CreateColored(Color.White); GetParent().logger.Write(str); } } else { if (GetParent().logger != null) { GetParent().logger.Write("There is no item to pick up."); } } } }
public override void Show(bool modal) { if (IsVisible) { return; } Center(); base.Show(modal); UpdateCharSheetColors(); string[] items = new string[] { "Current Index:", SelectedCharacterIndex.ToString() + " ", ((char)SelectedCharacterIndex).ToString() }; items[2] = items[2].PadRight(Width - 2 - (items[0].Length + items[1].Length)); ColoredString text = items[0].CreateColored(Color.LightBlue, Color.Black, null) + items[1].CreateColored(Color.LightCoral, Color.Black, null) + items[2].CreateColored(Color.LightCyan, Color.Black, null); text.IgnoreBackground = true; text.IgnoreEffect = true; Print(1, Height - 2, text); }
public ParseCommandGradient(string parameters) { var badCommandException = new ArgumentException("command is invalid for Recolor: " + parameters); string[] parametersArray = parameters.Split(':'); if (parametersArray.Length > 3) { CommandType = parametersArray[0] == "b" ? CommandTypes.Background : CommandTypes.Foreground; Counter = Length = int.Parse(parametersArray[parametersArray.Length - 1], CultureInfo.InvariantCulture); bool keep; bool useDefault; List <Color> steps = new List <Color>(); for (int i = 1; i < parametersArray.Length - 1; i++) { steps.Add(Color.White.FromParser(parametersArray[i], out keep, out keep, out keep, out keep, out useDefault)); } GradientString = new ColorGradient(steps.ToArray()).ToColoredString(new string(' ', Length)); } else { throw badCommandException; } }
public static void PrintStyledText(this CellSurface surface, int x, int y, params ColoredString[] text) { var glyphs = text.SelectMany(part => part.ToArray()).ToArray(); var coloredString = new ColoredString(glyphs); surface.Print(x, y, coloredString); }
/// <summary> /// Creates a <see cref="ColoredString"/> object from an existing string with the specified foreground and background, setting the ignore properties if needed. /// </summary> /// <param name="value">The current string.</param> /// <param name="foreground">The foreground color. If null, <see cref="ColoredString.IgnoreForeground"/> will be set.</param> /// <param name="background">The background color. If null, <see cref="ColoredString.IgnoreBackground"/> will be set.</param> /// <param name="spriteEffect">The background color. If null, <see cref="ColoredString.IgnoreEffect"/> will be set.</param> /// <returns>A <see cref="ColoredString"/> object instace.</returns> public static ColoredString CreateColored(this string value, Color?foreground = null, Color?background = null) { var stacks = new ParseCommandStacks(); if (foreground.HasValue) { stacks.AddSafe(new ParseCommandRecolor() { R = foreground.Value.R, G = foreground.Value.G, B = foreground.Value.B, A = foreground.Value.A, CommandType = CommandTypes.Foreground }); } if (background.HasValue) { stacks.AddSafe(new ParseCommandRecolor() { R = background.Value.R, G = background.Value.G, B = background.Value.B, A = background.Value.A, CommandType = CommandTypes.Background }); } ColoredString newString = ColoredString.Parse(value, initialBehaviors: stacks); if (!foreground.HasValue) { newString.IgnoreForeground = true; } if (!background.HasValue) { newString.IgnoreBackground = true; } return(newString); }
public void CreateEquipped(IIndexedKeybinding[] keybindings) { int index = 0; var equippedItems = InventoryManager.GetEquippedItems <PlayerInventory>(); foreach (var item in keybindings) { ColoredString prefix = new ColoredString(); var equippedItem = ItemManager.GetItem <IItem>(equippedItems[index].ObjectId); ColoredString itemName = ItemManager.GetItemName <IItem>(equippedItem.ObjectId); // temporary solution for item type formatting specifically for this window string itemType = equippedItem.GetType() == typeof(WeaponItem) ? "[WEAPON]" : equippedItem.GetType() == typeof(HeadItem) ? "[HEAD]" : equippedItem.GetType() == typeof(BodyItem) ? "[BODY]" : equippedItem.GetType() == typeof(LegsItem) ? "[LEGS]" : "UNKNOWN"; string itemId = $"itemId_{equippedItem.ObjectId}"; var printableItem = new PrintContainerBase() { Name = itemName, Type = itemType, Data = "\0", Id = "\0", ButtonIndex = new ButtonIndex(keybindings[index].Key, Color.Green, Color.White, 0, 0, true) }; _printable.Add(printableItem); index++; } }
public void AddText(ColoredString text, int lineNumber) { for (var i = 0; i < text.Length; i++) { Text[lineNumber, i + 2] = text[i]; } }
public void CreateLocations(IIndexedKeybinding[] keybindings) { int index = 0; foreach (var item in keybindings) { var location = LocationManager.GetLocationByObjectId <ILocation>(item.ObjectId); ColoredString locationName = LocationManager.GetLocationName <ILocation>(location.ObjectId); if (location.ObjectId == Game.GameSession.Player.CurrentLocation.ObjectId) { locationName.SetBackground(new Color(18, 77, 7)); } var printableLocation = new PrintContainerBase() { Name = locationName, Type = location.MinLevel == 0 && location.MaxLevel == 0 ? "\0" : $"<{location.MinLevel} - {location.MaxLevel}>", Data = "\0", Id = "\0", ButtonIndex = new ButtonIndex(keybindings[index].Key, Constants.Theme.ButtonKeyColor, Constants.Theme.ForegroundColor, 0, 0, true) }; _printable.Add(printableLocation); index++; } }
protected virtual void GetColoredString(List <ColoredString> list) { if (this.SyntaxType == SyntaxType.WhiteSpaceTrivia) { list.Add(ColoredString.Create(this.text, ColorType.WhiteSpace)); } }
public static void PrintHeader(ICellSurface target, SadConsole.UI.Colors themeColors, Point position, int totalWidth, string text) { totalWidth = totalWidth - text.Length - 3; if (totalWidth < 0) { throw new Exception("Header text too small"); } var lineText = ColoredString.FromGradient( new Gradient( new[] { themeColors.White, themeColors.White, themeColors.Gray, themeColors.Gray, themeColors.GrayDark, themeColors.GrayDark }, new[] { 0f, 0.3f, 0.31f, 0.65f, 0.66f, 1f }), new string((char)196, totalWidth)); target.Print(position.X, position.Y, new ColoredString(new ColoredGlyph(themeColors.White, Color.Transparent, 196)) + new ColoredString(new ColoredGlyph(themeColors.Cyan, Color.Transparent, 254)) + new ColoredString(text, themeColors.Title, Color.Transparent) + new ColoredString(new ColoredGlyph(themeColors.Cyan, Color.Transparent, 254)) ); var targetPosition = Point.FromIndex(position.ToIndex(target.Width) + text.Length + 3, target.Width); target.Print(targetPosition.X, targetPosition.Y, lineText); }
// Calculates the outcome of a defender's attempt // at blocking incoming hits. // Modifies a StringBuilder messages that will be displayed // in the MessageLog, expressing the number of hits blocked. private static int ResolveDefense(Actor defender, int hits, ColoredString attackMessage, ColoredString defenseMessage) { int blocks = 0; if (hits > 0) { // Create a string that displays the defender's name and outcomes attackMessage.String += ($"scoring {hits} hits."); defenseMessage.String += ($"{defender.Name} defends and rolls "); //The defender's Defense value determines the number of D100 dice rolled for (int i = 0; i < defender.Defense; i++) { //Roll a single D100 and add its results to the defense Message int diceOutcome = Dice.Roll("1d100"); //Resolve the dicing outcome and register a block, governed by the //attacker's DefenceChance value. if (diceOutcome >= 100 - defender.DefenseChance) { blocks++; } } defenseMessage.String += ($"resulting in {blocks} blocks."); } else { attackMessage.String += ("and misses completely!;"); } return(blocks); }
// Executes an attack from an attacking actor // on a defending actor, and then describes // the outcome of the attack in the Message Log public void Attack(Actor attacker, Actor defender) { // Create two messages that describe the outcome // of the attack and defense ColoredString attackMessage = new ColoredString(""); ColoredString defenseMessage = new ColoredString(""); // Count up the amount of attacking damage done // and the number of successful blocks int hits = ResolveAttack(attacker, defender, attackMessage); int blocks = ResolveDefense(defender, hits, attackMessage, defenseMessage); // Display the outcome of the attack & defense GameLoop.UIManager.MessageLog.Add(attackMessage); if (!string.IsNullOrWhiteSpace(defenseMessage.ToString())) { GameLoop.UIManager.MessageLog.Add(defenseMessage); } int damage = hits - blocks; // The defender now takes damage ResolveDamage(defender, damage); }
public override void FireEvent(object sender, EventArgs e) { if (e.GetType() == typeof(NewAttackEventArgs)) { var hitPercent = ResolveAttack(); var dmg = AttackValue * hitPercent; System.Console.WriteLine(AttackValue); System.Console.WriteLine("Damage:{0}", (int)dmg); (e as NewAttackEventArgs).Damage = (int)dmg; //TODO: Modify Damage Here ? var self_a = GetComponent <Actor>(ComponentType.Actor); BaseEntity other = self_a.Map.GetEntityAt((e as NewAttackEventArgs).Position.X, (e as NewAttackEventArgs).Position.Y); if (other != null) { if (GetParent().logger != null) { ColoredString str = new ColoredString(string.Format("{0}, ", GetParent().NAME)); str += "Attacks".CreateColored(Color.Red); str += string.Format(" {0} for", other.NAME).CreateColored(Color.White); str += string.Format(" {0} ", (int)dmg).CreateColored(Color.DarkRed); str += "damage".CreateColored(Color.Red); str += ".".CreateColored(Color.White); GetParent().logger.Write(str); } other.FireEvent(this, new NewDamageEventArgs((e as NewAttackEventArgs).Damage)); } } }
private void PrintNoCheck(int index, ColoredString text) { int total = index + text.Count > textSurface.Cells.Length ? textSurface.Cells.Length : index + text.Count; int charIndex = 0; for (; index < total; index++) { if (!text.IgnoreGlyph) { textSurface.Cells[index].Glyph = text[charIndex].GlyphCharacter; } if (!text.IgnoreBackground) { textSurface.Cells[index].Background = text[charIndex].Background; } if (!text.IgnoreForeground) { textSurface.Cells[index].Foreground = text[charIndex].Foreground; } if (!text.IgnoreMirror) { textSurface.Cells[index].Mirror = text[charIndex].Mirror; } if (!text.IgnoreEffect) { SetEffect(index, text[charIndex].Effect); } charIndex++; } textSurface.IsDirty = true; }
public SfmlApp() { InitGame(); _window = InitGui(); ColoredString.Write("You wake up in an Unknown world."); }
public void DrawMonsterStats(Monster monster, int monsterIdx) { // Start at Y=13 which is below the player stats. // Multiply the position by 2 to leave a space between each stat int yPosition = 13 + (monsterIdx * 2); // Begin the line by printing the symbol of the monster in the appropriate color Print(1, yPosition, monster.Symbol.ToString(), monster.color); // Figure out the width of the health bar by dividing current health by max health int width = Convert.ToInt32(((double)monster.Health / monster.MaxHealth) * 16.0); int remainingWidth = 16 - width; // Set the background colors of the health bar to show how damaged the monster is ColoredString curHp = new ColoredString(width); curHp.SetBackground(Swatch.Primary); Print(3, yPosition, curHp); ColoredString missHp = new ColoredString(remainingWidth); missHp.SetBackground(Swatch.PrimaryDarkest); Print(3 + width, yPosition, missHp); // Print the monsters name over top of the health bar Print(2, yPosition, $": {monster.Name}", Swatch.DbLight); }
public UserVariableDefinition(StructDeclaratorSyntax declarator, IdentifierSyntax identifier, string documentation, DefinitionKind kind, Scope scope) : base(documentation, kind, scope, identifier.Span) { if (kind == DefinitionKind.LocalVariable) { this.Name = ColoredString.Create(identifier.Identifier, ColorType.LocalVariable); } else { this.Name = ColoredString.Create(identifier.Identifier, ColorType.GlobalVariable); } InterfaceBlockSyntax block = declarator.Parent as InterfaceBlockSyntax; this.TypeQualifiers = block.TypeQualifier?.ToSyntaxTypes() ?? new List <SyntaxType>(); this.Type = new TypeDefinition(SyntaxType.TypeName); List <ColoredString> arraySpecifiers = new List <ColoredString>(); for (int i = 0; i < declarator.ArraySpecifiers.Count; i++) { arraySpecifiers.AddRange(declarator.ArraySpecifiers[i].ToColoredString()); } this.ArraySpecifiers = arraySpecifiers; }
public override void Render() { if (DropMode) { this.Title = "Inventory - DropMode"; } else { this.Title = "Inventory"; } if (inventory != null) { this.VirtualCursor.Position = new Point(0, 1); foreach (var item in inventory.inventory) { this.VirtualCursor.Down(1); this.VirtualCursor.Right(1); var s = char.ConvertFromUtf32(item.Value.GetComponent <SpriteAnimation>(ComponentType.SpriteAnimation).Symbol); ColoredString str = new ColoredString(""); str += string.Format("{0}:", item.Key).CreateColored(Color.White); if (inventoryUser.GetComponent <Equipment>(ComponentType.Equipment).Contains(item.Value.GetComponent <Item>(ComponentType.Item))) { str += "(E)".CreateColored(Color.Crimson); str += ":".CreateColored(Color.White); } str += new ColoredString(s, item.Value.GetComponent <SpriteAnimation>(ComponentType.SpriteAnimation).Foreground, item.Value.GetComponent <SpriteAnimation>(ComponentType.SpriteAnimation).Background); str += string.Format(":{0}", item.Value.NAME).CreateColored(Color.White); this.VirtualCursor.Print(str).NewLine(); } } base.Render(); }
private void PrintNoCheck(int index, ColoredString text) { int total = index + text.Count > textSurface.Cells.Length ? textSurface.Cells.Length : index + text.Count; int charIndex = 0; for (; index < total; index++) { if (!text.IgnoreGlyph) { textSurface.Cells[index].GlyphIndex = text[charIndex].Glyph; } if (!text.IgnoreBackground) { textSurface.Cells[index].Background = text[charIndex].Background; } if (!text.IgnoreForeground) { textSurface.Cells[index].Foreground = text[charIndex].Foreground; } if (!text.IgnoreSpriteEffect) { textSurface.Cells[index].SpriteEffect = text[charIndex].SpriteEffect; } if (!text.IgnoreEffect) { SetEffect(index, text[charIndex].Effect); } charIndex++; } }
public void Modify(ref ColoredString Name) { if (Armed) { Name = new ColoredString("[Armed] ", Color.Red, Color.Black) + Name; } }
/// <summary> /// Shows a window prompt with two buttons for the user to click. /// </summary> /// <param name="message">The text to display. (background color is ignored)</param> /// <param name="yesPrompt">The yes button's text.</param> /// <param name="noPrompt">The no button's text.</param> /// <param name="resultCallback">Callback with the yes (true) or no (false) result.</param> public static void Prompt(ColoredString message, string yesPrompt, string noPrompt, Action <bool> resultCallback) { Window window = new Window(message.ToString().Length + 4, 6); message.IgnoreBackground = true; window.Print(2, 2, message); Button yesButton = new Button(yesPrompt.Length + 2); Button noButton = new Button(noPrompt.Length + 2); yesButton.Position = new Point(2, window.textSurface.Height - 2); noButton.Position = new Point(window.textSurface.Width - noButton.Width - 2, window.textSurface.Height - 2); yesButton.Text = yesPrompt; noButton.Text = noPrompt; yesButton.Click += (o, e) => { window.DialogResult = true; window.Hide(); }; noButton.Click += (o, e) => { window.DialogResult = false; window.Hide(); }; window.Add(yesButton); window.Add(noButton); window.Closed += (o, e) => { resultCallback(window.DialogResult); }; window.Show(true); window.Center(); }
public FieldDefinition(IReadOnlyList <SyntaxType> typeQualifier, TypeDefinition type, string name, IReadOnlyList <ColoredString> arraySpecifiers, string documentation, Scope scope, TrackingSpan span) : base(ColoredString.Create(name, ColorType.Field), documentation, DefinitionKind.Field, scope, span) { this.TypeQualifiers = typeQualifier ?? new List <SyntaxType>(); this.Type = type; this.ArraySpecifiers = arraySpecifiers ?? new List <ColoredString>(); }
public static void Prompt(ColoredString message, string yesPrompt, string noPrompt, Action<bool> resultCallback) { Window window = new Window(message.ToString().Length + 4, 6); message.IgnoreBackground = true; window._cellData.Print(2, 2, message); Button yesButton = new Button(yesPrompt.Length + 2, 1); Button noButton = new Button(noPrompt.Length + 2, 1); yesButton.Position = new Microsoft.Xna.Framework.Point(2, window._cellData.Height - 2); noButton.Position = new Microsoft.Xna.Framework.Point(window._cellData.Width - noButton.Width - 2, window._cellData.Height - 2); yesButton.Text = yesPrompt; noButton.Text = noPrompt; yesButton.ButtonClicked += (o, e) => { window.DialogResult = true; window.Hide(); }; noButton.ButtonClicked += (o, e) => { window.DialogResult = false; window.Hide(); }; window.Add(yesButton); window.Add(noButton); window.Closed += (o, e) => { resultCallback(window.DialogResult); }; window.Show(true); window.Center(); }
/// <summary> /// Draws the string on the console at the specified location, wrapping if needed. /// </summary> /// <param name="x">X location of the text.</param> /// <param name="y">Y location of the text.</param> /// <param name="text">The string to display.</param> public void Print(int x, int y, string text) { if (String.IsNullOrEmpty(text)) { return; } if (x >= textSurface.Width || x < 0 || y >= textSurface.Height || y < 0) { throw new Exception("X,Y is out of range for Print"); } int index = y * textSurface.Width + x; if (!UsePrintProcessor) { int total = index + text.Length > textSurface.Cells.Length ? textSurface.Cells.Length - index : index + text.Length; int charIndex = 0; for (; index < total; index++) { textSurface.Cells[index].Glyph = text[charIndex]; charIndex++; } } else { PrintNoCheck(index, ColoredString.Parse(text, index, textSurface, this)); } textSurface.IsDirty = true; }
public ColoredString ColoredSeason() { Color SeasonColor = new Color(); switch (GetSeasonName()) { case "Spring": SeasonColor = Color.SpringGreen; break; case "Summer": SeasonColor = Color.Goldenrod; break; case "Autumn": SeasonColor = Color.OrangeRed; break; case "Winter": SeasonColor = Color.CornflowerBlue; break; default: SeasonColor = Color.Red; break; } var date = GetSeasonName() + " "; ColoredString season = new ColoredString(date, SeasonColor, Color.TransparentBlack); return(season); }
public ParseCommandGradient(string parameters) { var badCommandException = new ArgumentException("command is invalid for Recolor: " + parameters); string[] parametersArray = parameters.Split(':'); if (parametersArray.Length > 3) { CommandType = parametersArray[0] == "b" ? CommandTypes.Background : CommandTypes.Foreground; Counter = Length = int.Parse(parametersArray[parametersArray.Length - 1]); bool keep; bool useDefault; List<Color> steps = new List<Color>(); for (int i = 1; i < parametersArray.Length - 1; i++) { steps.Add(Color.White.FromParser(parametersArray[i], out keep, out keep, out keep, out keep, out useDefault)); } GradientString = new ColorGradient(steps.ToArray()).ToColoredString(new string(' ', Length)); } else throw badCommandException; }
public ParameterDefinition(IReadOnlyList <SyntaxType> typeQualifier, TypeDefinition type, string identifier, string documentation, IReadOnlyList <ColoredString> arraySpecifiers, Scope scope, TrackingSpan span) : base(ColoredString.Create(identifier, ColorType.Parameter), documentation, DefinitionKind.Parameter, scope, span) { this.TypeQualifiers = typeQualifier ?? new List <SyntaxType>(); this.Type = type; this.ArraySpecifiers = arraySpecifiers ?? new List <ColoredString>(); }
public override IReadOnlyList <ColoredString> GetColoredText() { List <ColoredString> list = new List <ColoredString>(); list.AddRange(this.ReturnType.GetColoredText()); list.Add(ColoredString.Space); list.Add(this.Name); list.Add(ColoredString.Create("(", ColorType.Punctuation)); for (int i = 0; i < this.Parameters.Count; i++) { if (i != 0) { list.Add(ColoredString.Create(",", ColorType.Punctuation)); list.Add(ColoredString.Space); } list.AddRange(this.Parameters[i].GetColoredText()); } list.Add(ColoredString.Create(")", ColorType.Punctuation)); return(list); }
// Removes an Actor that has died // and displays a message showing // the actor that has died, and they loot they dropped private static void ResolveDeath(Actor actor) { // Set up a customized death message ColoredString deathMessage = new ColoredString($"{actor.Name} has died"); // dump the dead actor's inventory (if any) // at the map position where it died if (actor.Inventory.Count > 0) { deathMessage.String += (" and dropped"); foreach (Item item in actor.Inventory) { // move the Item to the place where the actor died item.Position = actor.Position; // Now let the MultiSpatialMap know that the Item is visible GameLoop.World.CurrentMap.Add(item); // Append the item to the deathMessage deathMessage.String += (", " + item.Name); } // Clear the actor's inventory. Not strictly // necessary, but makes for good coding habits! actor.Inventory.Clear(); } else { // The monster carries no loot, so don't show any loot dropped deathMessage.String += ("."); } // actor goes bye-bye GameLoop.World.CurrentMap.Remove(actor); // Now show the deathMessage in the messagelog GameLoop.UIManager.MessageLog.Add(deathMessage); if (actor is Player) { ColoredString message = new ColoredString($" {actor.Name} was killed."); GameLoop.UIManager.MessageLog.Add(message); } else if (actor is Monster) { ColoredString message = new ColoredString($"{actor.Name} died and dropped {actor.Gold} gold coins."); GameLoop.UIManager.MessageLog.Add(message); //Update the player stats and call the refresh function to draw them GameLoop.World.Player.Gold += actor.Gold; var stat = new ColoredString($"Gold: {GameLoop.World.Player.Gold}", Color.Gold, Color.Transparent); GameLoop.UIManager.StatWindow._lines[5] = stat; GameLoop.UIManager.StatWindow.Refresh(); } }
public void Write(ColoredString message) { _lines.Enqueue(message.ToString()); if (_fireNewMessage != null) { _fireNewMessage(this, new NewMessageEventArgs(message)); } }
public void ImplicitStringifyingWorks() { var s = new ColoredString("text", ConsoleColor.Blue); string str = s; str.Should().Be("text"); }
public static void PrintColor(ColoredString str) { var prevColor = Console.BackgroundColor; Console.BackgroundColor = str.Color; Console.Write(str.Content); Console.BackgroundColor = prevColor; }
/// <summary> /// Displays a dialog to the user with a specific message. /// </summary> /// <param name="message">The message. (background color is ignored)</param> /// <param name="closeButtonText">The text of the dialog's close button.</param> /// <param name="closedCallback">A callback indicating the message was dismissed.</param> public static void Message(ColoredString message, string closeButtonText, Action closedCallback = null) { Window window = new Window(message.ToString().Length + 4, 6); message.IgnoreBackground = true; window.Print(2, 2, message); Button closeButton = new Button(closeButtonText.Length + 2); closeButton.Position = new Point(2, window.textSurface.Height - 2); closeButton.Text = closeButtonText; closeButton.Click += (o, e) => { window.DialogResult = true; window.Hide(); closedCallback?.Invoke(); }; window.Add(closeButton); window.Show(true); window.Center(); }
public static void Message(ColoredString message, string closeButtonText) { Window window = new Window(message.ToString().Length + 4, 6); message.IgnoreBackground = true; window._cellData.Print(2, 2, message); Button closeButton = new Button(closeButtonText.Length + 2, 1); closeButton.Position = new Microsoft.Xna.Framework.Point(2, window._cellData.Height - 2); closeButton.Text = closeButtonText; closeButton.ButtonClicked += (o, e) => { window.DialogResult = true; window.Hide(); }; window.Add(closeButton); window.Show(true); window.Center(); }
private void PrintNoCheck(int index, ColoredString text) { int total = index + text.Count > textSurface.Cells.Length ? textSurface.Cells.Length : index + text.Count; int charIndex = 0; for (; index < total; index++) { if (!text.IgnoreGlyph) textSurface.Cells[index].GlyphIndex = text[charIndex].Glyph; if (!text.IgnoreBackground) textSurface.Cells[index].Background = text[charIndex].Background; if (!text.IgnoreForeground) textSurface.Cells[index].Foreground = text[charIndex].Foreground; if (!text.IgnoreSpriteEffect) textSurface.Cells[index].SpriteEffect = text[charIndex].SpriteEffect; if (!text.IgnoreEffect) SetEffect(index, text[charIndex].Effect); charIndex++; } }
/// <summary> /// Draws the string on the console at the specified location, wrapping if needed. /// </summary> /// <param name="x">X location of the text.</param> /// <param name="y">Y location of the text.</param> /// <param name="text">The string to display.</param> public void Print(int x, int y, ColoredString text) { if (x >= textSurface.Width || x < 0 || y >= textSurface.Height || y < 0) throw new Exception("X,Y is out of range for Print"); int index = y * textSurface.Width + x; PrintNoCheck(index, text); }
/// <summary> /// Prints text to the console using the appearance of the colored string. /// </summary> /// <param name="text">The text to print.</param> /// <returns>Returns this cursor object.</returns> public Cursor Print(ColoredString text) { // If we don't want the pretty print, or we're printing a single character (for example, from keyboard input) // Then use the pretty print system. if (!DisableWordBreak && text.String.Length != 1) { // Prep var console = (SurfaceEditor)_console.Target; ColoredGlyph glyph; ColoredGlyph spaceGlyph = text[0].Clone(); spaceGlyph.Glyph = ' '; string stringText = text.String.TrimEnd(' '); // Pull any starting spaces off var newStringText = stringText.TrimStart(' '); int spaceCount = stringText.Length - newStringText.Length; for (int i = 0; i < spaceCount; i++) PrintGlyph(spaceGlyph, text); if (spaceCount != 0) text = text.SubString(spaceCount, text.Count - spaceCount); stringText = newStringText; string[] parts = stringText.Split(' '); // Start processing the string int c = 0; for (int wordMajor = 0; wordMajor < parts.Length; wordMajor++) { // Words broken up by spaces = parts if (parts[wordMajor].Length != 0) { // Parts broken by new lines = newLineParts string[] newlineParts = parts[wordMajor].Split('\n'); for (int indexNL = 0; indexNL < newlineParts.Length; indexNL++) { if (newlineParts[indexNL].Length != 0) { int currentLine = _position.Y; // New line parts broken up by carriage returns = returnParts string[] returnParts = newlineParts[indexNL].Split('\r'); for (int indexR = 0; indexR < returnParts.Length; indexR++) { // If the text we'll print will move off the edge, fill with spaces to get a fresh line if (returnParts[indexR].Length > console.Width - _position.X && _position.X != 0) { var spaces = console.Width - _position.X; // Fill rest of line with spaces for (int i = 0; i < spaces; i++) PrintGlyph(spaceGlyph, text); } // Print the rest of the text as normal. for (int i = 0; i < returnParts[indexR].Length; i++) { glyph = text[c]; PrintGlyph(glyph, text); c++; } // If we had a \r in the string, handle it by going back if (returnParts.Length != 1 && indexR != returnParts.Length - 1) { // Wrapped to a new line through print glyph, which triggerd \r\n. We don't want the \n so return back. if (_position.X == 0 && _position.Y != currentLine) _position.Y -= 1; else CarriageReturn(); c++; } } } // We had \n in the string, handle them. if (newlineParts.Length != 1 && indexNL != newlineParts.Length - 1) { if (!UseLinuxLineEndings) LineFeed(); else NewLine(); c++; } } } // Not last part if (wordMajor != parts.Length - 1 && _position.X != 0) { PrintGlyph(spaceGlyph, text); c++; } else c++; } } else { bool movedLines = false; int oldLine = _position.Y; foreach (var glyph in text) { // Check if the previous print moved us down a line (from print at end of the line) and move use back for the \r if (movedLines) { if (_position.X == 0 && glyph.Glyph == '\r') { _position.Y -= 1; continue; } else movedLines = false; } if (glyph.Glyph == '\r') CarriageReturn(); else if (glyph.Glyph == '\n') { if (!UseLinuxLineEndings) LineFeed(); else NewLine(); } else { PrintGlyph(glyph, text); // Lines changed and it wasn't a \n that caused it, so it was a print that did it. movedLines = _position.Y != oldLine; } } } return this; }
private void PrintGlyph(ColoredGlyph glyph, ColoredString settings) { var console = (SurfaceEditor)_console.Target; var cell = console.TextSurface.Cells[_position.Y * console.TextSurface.Width + _position.X]; if (!PrintOnlyCharacterData) { if (!settings.IgnoreBackground) cell.Background = glyph.Background; if (!settings.IgnoreForeground) cell.Foreground = glyph.Foreground; if (!settings.IgnoreEffect) cell.Effect = glyph.Effect; if (!settings.IgnoreSpriteEffect) cell.SpriteEffect = glyph.SpriteEffect; } if (!settings.IgnoreGlyph) cell.GlyphIndex = glyph.Glyph; _position.X += 1; if (_position.X >= console.TextSurface.Width) { _position.X = 0; _position.Y += 1; if (_position.Y >= console.TextSurface.Height) { _position.Y -= 1; if (AutomaticallyShiftRowsUp) { console.ShiftUp(); } } } }
/// <summary> /// Builds a string from the text surface. /// </summary> /// <param name="index">Where to start getting characters from.</param> /// <param name="length">How many characters to fill the string with.</param> /// <returns>A string built from the text surface data.</returns> public ColoredString GetStringColored(int index, int length) { if (index >= 0 && index < textSurface.Cells.Length) { ColoredString sb = new ColoredString(length); int tempIndex = 0; for (int i = 0; i < length; i++) { tempIndex = i + index; if (tempIndex < textSurface.Cells.Length) textSurface.Cells[tempIndex].CopyAppearanceTo(sb[i]); } return sb; } return new ColoredString(string.Empty); }
/// <summary> /// Prints text to the console using the appearance of the colored string. /// </summary> /// <param name="text">The text to print.</param> /// <returns>Returns this cursor object.</returns> public Cursor Print(ColoredString text) { var console = (Console)_console.Target; foreach (var character in text) { if (character.Character == '\r') CarriageReturn(); else if (character.Character == '\n') LineFeed(); else { var cell = console.CellData[_position.X, _position.Y]; if (!PrintOnlyCharacterData) { if (!text.IgnoreCharacter) cell.CharacterIndex = character.Character; if (!text.IgnoreBackground) cell.Background = character.Background; if (!text.IgnoreForeground) cell.Foreground = character.Foreground; if (!text.IgnoreEffect) console._cellData.SetEffect(cell, character.Effect); } _position.X += 1; if (_position.X > console.CellData.Width - 1) { _position.X = 0; _position.Y += 1; if (_position.Y > console.CellData.Height - 1) { _position.Y -= 1; if (AutomaticallyShiftRowsUp) console.CellData.ShiftRowsUp(); } } } } return this; }