Now, we’ll create our first consumable item – a healthy granola bar that will heal the player for 2 hit points.
Step 1: Modify Engine\Models\GameItem.cs
We’re eventually going to display all consumable items in a combombo on the UI, with a button to eat/use the item. So, we need a way to know which GameItem objects can be consumed.
For now, we’ll do that by adding the value ” Consumable” to the ItemCategory enum (line 11). Be sure to add the comma at the end of line 10.
GameItem.cs
using Engine.Actions;
namespace Engine.Models
{
public class GameItem
{
public enum ItemCategory
{
Miscellaneous,
Weapon,
Consumable
}
public ItemCategory Category { get; }
public int ItemTypeID { get; }
public string Name { get; }
public int Price { get; }
public bool IsUnique { get; }
public IAction Action { get; set; }
public GameItem(ItemCategory category, int itemTypeID, string name, int price,
bool isUnique = false, IAction action = null)
{
Category = category;
ItemTypeID = itemTypeID;
Name = name;
Price = price;
IsUnique = isUnique;
Action = action;
}
public void PerformAction(LivingEntity actor, LivingEntity target)
{
Action?.Execute(actor, target);
}
public GameItem Clone()
{
return new GameItem(Category, ItemTypeID, Name, Price, IsUnique, Action);
}
}
}
Step 2: Create the new class Engine\Actions\Heal.cs
Before we create the granola bar GameItem, we need to make the action class it will use. This will be the Heal class.
There is a lot of code in Heal that is similar to the code in AttackWithWeapon. We’re going to do some refactoring soon, to combine the duplicate code.
Heal.cs
using System;
using Engine.Models;
namespace Engine.Actions
{
public class Heal : IAction
{
private readonly GameItem _item;
private readonly int _hitPointsToHeal;
public event EventHandler<string> OnActionPerformed;
public Heal(GameItem item, int hitPointsToHeal)
{
if(item.Category != GameItem.ItemCategory.Consumable)
{
throw new ArgumentException($"{item.Name} is not consumable");
}
_item = item;
_hitPointsToHeal = hitPointsToHeal;
}
public void Execute(LivingEntity actor, LivingEntity target)
{
string actorName = (actor is Player) ? "You" : $"The {actor.Name.ToLower()}";
string targetName = (target is Player) ? "yourself" : $"the {target.Name.ToLower()}";
ReportResult($"{actorName} heal {targetName} for {_hitPointsToHeal} point{(_hitPointsToHeal > 1 ? "s" : "")}.");
target.Heal(_hitPointsToHeal);
}
private void ReportResult(string result)
{
OnActionPerformed?.Invoke(this, result);
}
}
}
Step 3: Modify Engine\Factories\ItemFactory.cs
Now, we can create the granola bar GameItem object.
I added a helper function BuildHealingItem (lines 51-56) to create the default healing item object and populate its Action property with a Heal action object.
We create the standard granola bar object on line 21.
ItemFactory.cs
using System.Collections.Generic;
using System.Linq;
using Engine.Actions;
using Engine.Models;
namespace Engine.Factories
{
public static class ItemFactory
{
private static readonly List<GameItem> _standardGameItems = new List<GameItem>();
static ItemFactory()
{
BuildWeapon(1001, "Pointy Stick", 1, 1, 2);
BuildWeapon(1002, "Rusty Sword", 5, 1, 3);
BuildWeapon(1501, "Snake fangs", 0, 0, 2);
BuildWeapon(1502, "Rat claws", 0, 0, 2);
BuildWeapon(1503, "Spider fangs", 0, 0, 4);
BuildHealingItem(2001, "Granola bar", 5, 2);
BuildMiscellaneousItem(9001, "Snake fang", 1);
BuildMiscellaneousItem(9002, "Snakeskin", 2);
BuildMiscellaneousItem(9003, "Rat tail", 1);
BuildMiscellaneousItem(9004, "Rat fur", 2);
BuildMiscellaneousItem(9005, "Spider fang", 1);
BuildMiscellaneousItem(9006, "Spider silk", 2);
}
public static GameItem CreateGameItem(int itemTypeID)
{
return _standardGameItems.FirstOrDefault(item => item.ItemTypeID == itemTypeID)?.Clone();
}
private static void BuildMiscellaneousItem(int id, string name, int price)
{
_standardGameItems.Add(new GameItem(GameItem.ItemCategory.Miscellaneous, id, name, price));
}
private static void BuildWeapon(int id, string name, int price,
int minimumDamage, int maximumDamage)
{
GameItem weapon = new GameItem(GameItem.ItemCategory.Weapon, id, name, price, true);
weapon.Action = new AttackWithWeapon(weapon, minimumDamage, maximumDamage);
_standardGameItems.Add(weapon);
}
private static void BuildHealingItem(int id, string name, int price, int hitPointsToHeal)
{
GameItem item = new GameItem(GameItem.ItemCategory.Consumable, id, name, price);
item.Action = new Heal(item, hitPointsToHeal);
_standardGameItems.Add(item);
}
}
}
Step 4: Modify Engine\Models\LivingEntity.cs
Since we’re going to display the player’s consumable inventory items in the UI, and let them eat/use one of them, we need to add a list of the consumable items (to bind to the combobox) and a property to hold the currently-selected consumable.
Line 18 has the backing variable “_currentConsumable” for the currently-selected consumable in the combobox.
The setter and getter for the CurrentConsumable are on lines 91-110. It subscribes to, and unsubscribes from, the item’s Action’s OnActionPerformed and handles it with the existing RaiseActionPerformedEvent function (to report the item’s message back to the UI).
There’s a new Consumables property (lines 119-120) to bind to the UI’s combobox, and a new HasConsumable property (line 122) to hide or show the combobox.
On lines 149-153, I added a small helper function we’ll call from GameSession, when the player uses their currently-selected consumable.
Currently, the actor and target are both the player (the “this” parameter values). In the future, we might add the ability to use a consumable on someone else – for example, using a healing potion on a pet that travels with you. But, we’ll worry about that in the future.
This function also removes the item from the player’s inventory after they use it.
The new Consumables list property does not automatically notify the UI of changes (because it’s a derived list), we need to manually notify the UI when we add or remove items that might be in the Consumables property.
We do this by calling the OnPropertyChanged function for the Consumables and HasConsumable properties on lines 215-216 and 240-241.
LivingEntity.cs
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
namespace Engine.Models
{
public abstract class LivingEntity : BaseNotificationClass
{
#region Properties
private string _name;
private int _currentHitPoints;
private int _maximumHitPoints;
private int _gold;
private int _level;
private GameItem _currentWeapon;
private GameItem _currentConsumable;
public string Name
{
get { return _name; }
private set
{
_name = value;
OnPropertyChanged();
}
}
public int CurrentHitPoints
{
get { return _currentHitPoints; }
private set
{
_currentHitPoints = value;
OnPropertyChanged();
}
}
public int MaximumHitPoints
{
get { return _maximumHitPoints; }
protected set
{
_maximumHitPoints = value;
OnPropertyChanged();
}
}
public int Gold
{
get { return _gold; }
private set
{
_gold = value;
OnPropertyChanged();
}
}
public int Level
{
get { return _level; }
protected set
{
_level = value;
OnPropertyChanged();
}
}
public GameItem CurrentWeapon
{
get { return _currentWeapon; }
set
{
if(_currentWeapon != null)
{
_currentWeapon.Action.OnActionPerformed -= RaiseActionPerformedEvent;
}
_currentWeapon = value;
if (_currentWeapon != null)
{
_currentWeapon.Action.OnActionPerformed += RaiseActionPerformedEvent;
}
OnPropertyChanged();
}
}
public GameItem CurrentConsumable
{
get => _currentConsumable;
set
{
if(_currentConsumable != null)
{
_currentConsumable.Action.OnActionPerformed -= RaiseActionPerformedEvent;
}
_currentConsumable = value;
if (_currentConsumable != null)
{
_currentConsumable.Action.OnActionPerformed += RaiseActionPerformedEvent;
}
OnPropertyChanged();
}
}
public ObservableCollection<GameItem> Inventory { get; }
public ObservableCollection<GroupedInventoryItem> GroupedInventory { get; }
public List<GameItem> Weapons =>
Inventory.Where(i => i.Category == GameItem.ItemCategory.Weapon).ToList();
public List<GameItem> Consumables =>
Inventory.Where(i => i.Category == GameItem.ItemCategory.Consumable).ToList();
public bool HasConsumable => Consumables.Any();
public bool IsDead => CurrentHitPoints <= 0;
#endregion
public event EventHandler<string> OnActionPerformed;
public event EventHandler OnKilled;
protected LivingEntity(string name, int maximumHitPoints, int currentHitPoints,
int gold, int level = 1)
{
Name = name;
MaximumHitPoints = maximumHitPoints;
CurrentHitPoints = currentHitPoints;
Gold = gold;
Level = level;
Inventory = new ObservableCollection<GameItem>();
GroupedInventory = new ObservableCollection<GroupedInventoryItem>();
}
public void UseCurrentWeaponOn(LivingEntity target)
{
CurrentWeapon.PerformAction(this, target);
}
public void UseCurrentConsumable()
{
CurrentConsumable.PerformAction(this, this);
RemoveItemFromInventory(CurrentConsumable);
}
public void TakeDamage(int hitPointsOfDamage)
{
CurrentHitPoints -= hitPointsOfDamage;
if(IsDead)
{
CurrentHitPoints = 0;
RaiseOnKilledEvent();
}
}
public void Heal(int hitPointsToHeal)
{
CurrentHitPoints += hitPointsToHeal;
if(CurrentHitPoints > MaximumHitPoints)
{
CurrentHitPoints = MaximumHitPoints;
}
}
public void CompletelyHeal()
{
CurrentHitPoints = MaximumHitPoints;
}
public void ReceiveGold(int amountOfGold)
{
Gold += amountOfGold;
}
public void SpendGold(int amountOfGold)
{
if(amountOfGold > Gold)
{
throw new ArgumentOutOfRangeException($"{Name} only has {Gold} gold, and cannot spend {amountOfGold} gold");
}
Gold -= amountOfGold;
}
public void AddItemToInventory(GameItem item)
{
Inventory.Add(item);
if(item.IsUnique)
{
GroupedInventory.Add(new GroupedInventoryItem(item, 1));
}
else
{
if(!GroupedInventory.Any(gi => gi.Item.ItemTypeID == item.ItemTypeID))
{
GroupedInventory.Add(new GroupedInventoryItem(item, 0));
}
GroupedInventory.First(gi => gi.Item.ItemTypeID == item.ItemTypeID).Quantity++;
}
OnPropertyChanged(nameof(Weapons));
OnPropertyChanged(nameof(Consumables));
OnPropertyChanged(nameof(HasConsumable));
}
public void RemoveItemFromInventory(GameItem item)
{
Inventory.Remove(item);
GroupedInventoryItem groupedInventoryItemToRemove = item.IsUnique ?
GroupedInventory.FirstOrDefault(gi => gi.Item == item) :
GroupedInventory.FirstOrDefault(gi => gi.Item.ItemTypeID == item.ItemTypeID);
if(groupedInventoryItemToRemove != null)
{
if(groupedInventoryItemToRemove.Quantity == 1)
{
GroupedInventory.Remove(groupedInventoryItemToRemove);
}
else
{
groupedInventoryItemToRemove.Quantity--;
}
}
OnPropertyChanged(nameof(Weapons));
OnPropertyChanged(nameof(Consumables));
OnPropertyChanged(nameof(HasConsumable));
}
#region Private functions
private void RaiseOnKilledEvent()
{
OnKilled?.Invoke(this, new System.EventArgs());
}
private void RaiseActionPerformedEvent(object sender, string result)
{
OnActionPerformed?.Invoke(this, result);
}
#endregion
}
}
Step 5: Modify Engine\ViewModels\GameSession.cs
Add the UseCurrentConsumable function on lines 272-275.
While we’re in this class, let’s give the Player a granola bar when they start the game (line 132).
GameSession.cs
using System;
using System.Linq;
using Engine.EventArgs;
using Engine.Factories;
using Engine.Models;
namespace Engine.ViewModels
{
public class GameSession : BaseNotificationClass
{
public event EventHandler<GameMessageEventArgs> OnMessageRaised;
#region Properties
private Player _currentPlayer;
private Location _currentLocation;
private Monster _currentMonster;
private Trader _currentTrader;
public World CurrentWorld { get; }
public Player CurrentPlayer
{
get { return _currentPlayer; }
set
{
if(_currentPlayer != null)
{
_currentPlayer.OnActionPerformed -= OnCurrentPlayerPerformedAction;
_currentPlayer.OnLeveledUp -= OnCurrentPlayerLeveledUp;
_currentPlayer.OnKilled -= OnCurrentPlayerKilled;
}
_currentPlayer = value;
if (_currentPlayer != null)
{
_currentPlayer.OnActionPerformed += OnCurrentPlayerPerformedAction;
_currentPlayer.OnLeveledUp += OnCurrentPlayerLeveledUp;
_currentPlayer.OnKilled += OnCurrentPlayerKilled;
}
}
}
public Location CurrentLocation
{
get { return _currentLocation; }
set
{
_currentLocation = value;
OnPropertyChanged();
OnPropertyChanged(nameof(HasLocationToNorth));
OnPropertyChanged(nameof(HasLocationToEast));
OnPropertyChanged(nameof(HasLocationToWest));
OnPropertyChanged(nameof(HasLocationToSouth));
CompleteQuestsAtLocation();
GivePlayerQuestsAtLocation();
GetMonsterAtLocation();
CurrentTrader = CurrentLocation.TraderHere;
}
}
public Monster CurrentMonster
{
get { return _currentMonster; }
set
{
if(_currentMonster != null)
{
_currentMonster.OnActionPerformed -= OnCurrentMonsterPerformedAction;
_currentMonster.OnKilled -= OnCurrentMonsterKilled;
}
_currentMonster = value;
if(_currentMonster != null)
{
_currentMonster.OnActionPerformed += OnCurrentMonsterPerformedAction;
_currentMonster.OnKilled += OnCurrentMonsterKilled;
RaiseMessage("");
RaiseMessage($"You see a {CurrentMonster.Name} here!");
}
OnPropertyChanged();
OnPropertyChanged(nameof(HasMonster));
}
}
public Trader CurrentTrader
{
get { return _currentTrader; }
set
{
_currentTrader = value;
OnPropertyChanged();
OnPropertyChanged(nameof(HasTrader));
}
}
public bool HasLocationToNorth =>
CurrentWorld.LocationAt(CurrentLocation.XCoordinate, CurrentLocation.YCoordinate + 1) != null;
public bool HasLocationToEast =>
CurrentWorld.LocationAt(CurrentLocation.XCoordinate + 1, CurrentLocation.YCoordinate) != null;
public bool HasLocationToSouth =>
CurrentWorld.LocationAt(CurrentLocation.XCoordinate, CurrentLocation.YCoordinate - 1) != null;
public bool HasLocationToWest =>
CurrentWorld.LocationAt(CurrentLocation.XCoordinate - 1, CurrentLocation.YCoordinate) != null;
public bool HasMonster => CurrentMonster != null;
public bool HasTrader => CurrentTrader != null;
#endregion
public GameSession()
{
CurrentPlayer = new Player("Scott", "Fighter", 0, 10, 10, 1000000);
if (!CurrentPlayer.Weapons.Any())
{
CurrentPlayer.AddItemToInventory(ItemFactory.CreateGameItem(1001));
}
CurrentPlayer.AddItemToInventory(ItemFactory.CreateGameItem(2001));
CurrentWorld = WorldFactory.CreateWorld();
CurrentLocation = CurrentWorld.LocationAt(0, 0);
}
public void MoveNorth()
{
if(HasLocationToNorth)
{
CurrentLocation = CurrentWorld.LocationAt(CurrentLocation.XCoordinate, CurrentLocation.YCoordinate + 1);
}
}
public void MoveEast()
{
if(HasLocationToEast)
{
CurrentLocation = CurrentWorld.LocationAt(CurrentLocation.XCoordinate + 1, CurrentLocation.YCoordinate);
}
}
public void MoveSouth()
{
if(HasLocationToSouth)
{
CurrentLocation = CurrentWorld.LocationAt(CurrentLocation.XCoordinate, CurrentLocation.YCoordinate - 1);
}
}
public void MoveWest()
{
if(HasLocationToWest)
{
CurrentLocation = CurrentWorld.LocationAt(CurrentLocation.XCoordinate - 1, CurrentLocation.YCoordinate);
}
}
private void CompleteQuestsAtLocation()
{
foreach(Quest quest in CurrentLocation.QuestsAvailableHere)
{
QuestStatus questToComplete =
CurrentPlayer.Quests.FirstOrDefault(q => q.PlayerQuest.ID == quest.ID &&
!q.IsCompleted);
if(questToComplete != null)
{
if(CurrentPlayer.HasAllTheseItems(quest.ItemsToComplete))
{
// Remove the quest completion items from the player's inventory
foreach (ItemQuantity itemQuantity in quest.ItemsToComplete)
{
for(int i = 0; i < itemQuantity.Quantity; i++)
{
CurrentPlayer.RemoveItemFromInventory(CurrentPlayer.Inventory.First(item => item.ItemTypeID == itemQuantity.ItemID));
}
}
RaiseMessage("");
RaiseMessage($"You completed the '{quest.Name}' quest");
// Give the player the quest rewards
RaiseMessage($"You receive {quest.RewardExperiencePoints} experience points");
CurrentPlayer.AddExperience(quest.RewardExperiencePoints);
RaiseMessage($"You receive {quest.RewardGold} gold");
CurrentPlayer.ReceiveGold(quest.RewardGold);
foreach(ItemQuantity itemQuantity in quest.RewardItems)
{
GameItem rewardItem = ItemFactory.CreateGameItem(itemQuantity.ItemID);
RaiseMessage($"You receive a {rewardItem.Name}");
CurrentPlayer.AddItemToInventory(rewardItem);
}
// Mark the Quest as completed
questToComplete.IsCompleted = true;
}
}
}
}
private void GivePlayerQuestsAtLocation()
{
foreach(Quest quest in CurrentLocation.QuestsAvailableHere)
{
if(!CurrentPlayer.Quests.Any(q => q.PlayerQuest.ID == quest.ID))
{
CurrentPlayer.Quests.Add(new QuestStatus(quest));
RaiseMessage("");
RaiseMessage($"You receive the '{quest.Name}' quest");
RaiseMessage(quest.Description);
RaiseMessage("Return with:");
foreach(ItemQuantity itemQuantity in quest.ItemsToComplete)
{
RaiseMessage($" {itemQuantity.Quantity} {ItemFactory.CreateGameItem(itemQuantity.ItemID).Name}");
}
RaiseMessage("And you will receive:");
RaiseMessage($" {quest.RewardExperiencePoints} experience points");
RaiseMessage($" {quest.RewardGold} gold");
foreach(ItemQuantity itemQuantity in quest.RewardItems)
{
RaiseMessage($" {itemQuantity.Quantity} {ItemFactory.CreateGameItem(itemQuantity.ItemID).Name}");
}
}
}
}
private void GetMonsterAtLocation()
{
CurrentMonster = CurrentLocation.GetMonster();
}
public void AttackCurrentMonster()
{
if(CurrentPlayer.CurrentWeapon == null)
{
RaiseMessage("You must select a weapon, to attack.");
return;
}
CurrentPlayer.UseCurrentWeaponOn(CurrentMonster);
if(CurrentMonster.IsDead)
{
// Get another monster to fight
GetMonsterAtLocation();
}
else
{
CurrentMonster.UseCurrentWeaponOn(CurrentPlayer);
}
}
public void UseCurrentConsumable()
{
CurrentPlayer.UseCurrentConsumable();
}
private void OnCurrentPlayerPerformedAction(object sender, string result)
{
RaiseMessage(result);
}
private void OnCurrentMonsterPerformedAction(object sender, string result)
{
RaiseMessage(result);
}
private void OnCurrentPlayerKilled(object sender, System.EventArgs eventArgs)
{
RaiseMessage("");
RaiseMessage("You have been killed.");
CurrentLocation = CurrentWorld.LocationAt(0, -1);
CurrentPlayer.CompletelyHeal();
}
private void OnCurrentMonsterKilled(object sender, System.EventArgs eventArgs)
{
RaiseMessage("");
RaiseMessage($"You defeated the {CurrentMonster.Name}!");
RaiseMessage($"You receive {CurrentMonster.RewardExperiencePoints} experience points.");
CurrentPlayer.AddExperience(CurrentMonster.RewardExperiencePoints);
RaiseMessage($"You receive {CurrentMonster.Gold} gold.");
CurrentPlayer.ReceiveGold(CurrentMonster.Gold);
foreach(GameItem gameItem in CurrentMonster.Inventory)
{
RaiseMessage($"You receive one {gameItem.Name}.");
CurrentPlayer.AddItemToInventory(gameItem);
}
}
private void OnCurrentPlayerLeveledUp(object sender, System.EventArgs eventArgs)
{
RaiseMessage($"You are now level {CurrentPlayer.Level}!");
}
private void RaiseMessage(string message)
{
OnMessageRaised?.Invoke(this, new GameMessageEventArgs(message));
}
}
}
Step 6: Modify WPFUI\MainWindow.xaml and MainWindow.xaml.cs
Replace the “Combat Controls” grid (lines 216-241, in the original code) with the code listed below.
This is the new combobox and “Use” button for consumable items.
There are also some changes for hiding and showing the controls. Originally, the complete grid was only shown if there is a monster at the current location. Now, the weapon combobox and button use the “HasMonster” property, while the consumable controls use “CurrentPlayer.HasConsumable” – so the player can use a consumable item at any location.
NOTE: I also removed the SelectedValuePath=”ID” attribute from the CurrentWeapon combobox. We don’t use it, and it actually should have been “ItemTypeID”.
MainWindow.xaml.cs has a new function OnClick_UseCurrentConsumable (lines 49-52) for when the player clicks the “Use” button for a consumable item.
MainWindow.xaml (lines 216-252)
<!-- Combat Controls -->
<Grid Grid.Row="0" Grid.Column="0"
HorizontalAlignment="Center"
VerticalAlignment="Center">
<Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/>
</Grid.RowDefinitions>
<Grid.ColumnDefinitions>
<ColumnDefinition Width="150"/>
<ColumnDefinition Width="10"/>
<ColumnDefinition Width="50"/>
</Grid.ColumnDefinitions>
<ComboBox Grid.Row="0" Grid.Column="0"
Visibility="{Binding HasMonster, Converter={StaticResource BooleanToVisibility}}"
ItemsSource="{Binding CurrentPlayer.Weapons}"
SelectedItem="{Binding CurrentPlayer.CurrentWeapon}"
DisplayMemberPath="Name"/>
<Button Grid.Row="0" Grid.Column="2"
Visibility="{Binding HasMonster, Converter={StaticResource BooleanToVisibility}}"
Content="Use"
Click="OnClick_AttackMonster"/>
<ComboBox Grid.Row="1" Grid.Column="0"
Visibility="{Binding CurrentPlayer.HasConsumable, Converter={StaticResource BooleanToVisibility}}"
ItemsSource="{Binding CurrentPlayer.Consumables}"
SelectedItem="{Binding CurrentPlayer.CurrentConsumable}"
DisplayMemberPath="Name"/>
<Button Grid.Row="1" Grid.Column="2"
Visibility="{Binding CurrentPlayer.HasConsumable, Converter={StaticResource BooleanToVisibility}}"
Content="Use"
Click="OnClick_UseCurrentConsumable"/>
</Grid>
MainWindow.xaml.cs
using System.Windows;
using System.Windows.Documents;
using Engine.EventArgs;
using Engine.ViewModels;
namespace WPFUI
{
/// <summary>
/// Interaction logic for MainWindow.xaml
/// </summary>
public partial class MainWindow : Window
{
private readonly GameSession _gameSession = new GameSession();
public MainWindow()
{
InitializeComponent();
_gameSession.OnMessageRaised += OnGameMessageRaised;
DataContext = _gameSession;
}
private void OnClick_MoveNorth(object sender, RoutedEventArgs e)
{
_gameSession.MoveNorth();
}
private void OnClick_MoveWest(object sender, RoutedEventArgs e)
{
_gameSession.MoveWest();
}
private void OnClick_MoveEast(object sender, RoutedEventArgs e)
{
_gameSession.MoveEast();
}
private void OnClick_MoveSouth(object sender, RoutedEventArgs e)
{
_gameSession.MoveSouth();
}
private void OnClick_AttackMonster(object sender, RoutedEventArgs e)
{
_gameSession.AttackCurrentMonster();
}
private void OnClick_UseCurrentConsumable(object sender, RoutedEventArgs e)
{
_gameSession.UseCurrentConsumable();
}
private void OnGameMessageRaised(object sender, GameMessageEventArgs e)
{
GameMessages.Document.Blocks.Add(new Paragraph(new Run(e.Message)));
GameMessages.ScrollToEnd();
}
private void OnClick_DisplayTradeScreen(object sender, RoutedEventArgs e)
{
TradeScreen tradeScreen = new TradeScreen();
tradeScreen.Owner = this;
tradeScreen.DataContext = _gameSession;
tradeScreen.ShowDialog();
}
}
}
Step 7: Run the unit tests and test the game
NEXT LESSON: Lesson 12.6: Refactoring after adding Actions
PREVIOUS LESSON: Lesson 12.4: Letting the Monster use AttackWithWeapon