public override void Update(Frame frame)
{
foreach (var digger in diggers.Where(x => x.ReadyToDig(frame.TimeSinceStart)))
{
var digResult = digger.Dig(frame.TimeSinceStart);
if (!digResult.Failed)
{
var table = new TableOutput(80, PcmColor.DarkYellow);
table.AddHeaders("Name", "Dug", "Damage", "Durability", "Hopper");
table.AddRow(
digger.Name,
digResult.ChipsDug.ToString(),
digResult.DurabilityLost.ToString(),
$"{digger.Durability.Current}/{digger.Durability.Max}",
$"{digger.Hopper.Count}/{digger.Hopper.Max}");
Game.Write(table, GameConsoles.Events);
}
else
{
foreach (var message in digResult.FaultMessages)
{
Game.WriteLine(
message,
PcmColor.Cyan,
PcmColor.Black,
GameConsoles.Events);
}
}
}
}
public void Handle(ViewClaimListingsCommand command)
{
var table = new TableOutput(80, PcmColor.Green);
table.AddHeaders("Id", "Price", "Density", "Hardness", "Rent");
if (!command.Listings.GetAll().Any())
{
table.AddRow("No Claims Available");
Game.Write(table);
return;
}
foreach (var listing in command.Listings.GetAll())
{
table.AddRow(
listing.Id.ToString(),
listing.Price.ToString(),
listing.Survey.Density,
listing.Survey.Hardness,
listing.LeasePrice.ToString());
}
Game.Write(table);
}
public void TableExtensionTest()
{
List <Person> persons = new List <Person>();
persons.Add(new Person()
{
FirstName = "John", LastName = "Doe", Age = 34
});
persons.Add(new Person()
{
FirstName = "Jane", LastName = "Doe", Age = 26
});
var output = persons.AsTable();
Assert.IsInstanceOfType(output, typeof(TableOutput));
TableOutput table = output as TableOutput;
Assert.AreEqual(table.Columns.Count, 3);
Assert.AreEqual(table.Columns[0], "FirstName");
Assert.AreEqual(table.Columns[1], "LastName");
Assert.AreEqual(table.Columns[2], "Age");
Assert.AreEqual(table.Rows.Count, 2);
Assert.AreEqual(table.Rows[0][0], "John");
Assert.AreEqual(table.Rows[0][1], "Doe");
Assert.AreEqual(table.Rows[0][2], "34");
Assert.AreEqual(table.Rows[1][0], "Jane");
Assert.AreEqual(table.Rows[1][1], "Doe");
Assert.AreEqual(table.Rows[1][2], "26");
}
private static void ReportDiggerIdentityInfo(ChipDigger digger)
{
Game.ClearConsole();
var headTable = new TableOutput(80, PcmColor.Yellow);
headTable.AddHeaders("Name", "Class", "Equipped Date");
headTable.AddRow($"{digger.Name}", $"{digger.Class.ToString()}",
$"{digger.FirstEquipped}");
Game.Write(headTable);
}
private void ReportFiles()
{
var table = new TableOutput(80);
table.AddHeaders("File Name", "Save Date");
foreach (var file in persistenceService.GetSaveFileNames(GameState))
{
table.AddRow(file.Name, file.ModifiedDate.ToShortDateString());
}
Game.Write(table);
}
public void Handle(StockCommand command)
{
var table = new TableOutput(80, PcmColor.Green);
table.AddHeaders("Name", "Price", "Quantity");
foreach (var storeItem in command.State.ItemsForSale)
{
table.AddRow(storeItem.Name, storeItem.Price.ToString(), storeItem.Count.ToString());
}
Game.Write(table);
}
private static void ReportDiggerCoreStats(ChipDigger digger)
{
var vitalsTable = new TableOutput(80, PcmColor.Yellow);
vitalsTable.AddHeaders("Stat", "Value");
vitalsTable.AddRow("Site Hardness", digger.MineClaim.Hardness.ToString());
vitalsTable.AddRow("Site Chip Density", digger.MineClaim.ChipDensity.ToString());
vitalsTable.AddRow("Durablity (Left) / (Max)", $"{digger.Durability.Current} / {digger.Durability.Max}");
vitalsTable.AddRow("Hopper", digger.Hopper.Name);
vitalsTable.AddRow("Hopper Space (Left) / (Max)",
$"{digger.Hopper.Max - digger.Hopper.Count} / {digger.Hopper.Max}");
Game.Write(vitalsTable);
}
/// <summary>
/// Opens an output window
/// </summary>
private void OpenGLItem_Click(object sender, System.Windows.RoutedEventArgs e)
{
CommonAttribService.MODE_2D = false;
TableOutput table3D = new TableOutput();
tableManager.Table3D = table3D;
// change the mode back to 2D after closing this window
table3D.Closed += new EventHandler(delegate(object sender2, EventArgs e2)
{
CommonAttribService.MODE_2D = true;
});
table3D.Show();
}
private static void ReportDiggerLifetimeStats(ChipDigger digger)
{
Game.WriteLine("Lifetime Statistics", PcmColor.Black, PcmColor.Yellow);
var lifetimeTable = new TableOutput(80, PcmColor.Yellow);
lifetimeTable.AddHeaders("Stat", "Value");
lifetimeTable.AddRow("First Equipped", digger.FirstEquipped.ToString(CultureInfo.CurrentCulture));
lifetimeTable.AddRow("Lifetime Digs", digger.GetLifeTimeStat(DiggerStats.LifetimeDigs).ToString());
lifetimeTable.AddRow("Lifetime Chips", digger.GetLifeTimeStat(DiggerStats.LifetimeChips).ToString());
lifetimeTable.AddRow("Lifetime Repairs", digger.GetLifeTimeStat(DiggerStats.LifetimeRepairs).ToString());
lifetimeTable.AddRow("Lifetime Bolts Cost", digger.GetLifeTimeStat(DiggerStats.LifeTimeBoltsCost).ToString());
lifetimeTable.AddRow("Lifetime Tokes Cost", digger.GetLifeTimeStat(DiggerStats.LifeTimeTokensCost).ToString());
Game.Write(lifetimeTable);
}
void ShowClaims()
{
var table = new TableOutput(80);
table.AddHeaders("Id", "Price", "Density", "Hardness");
foreach (var claimLease in GameState.Miner.ClaimLeases.GetAll())
{
table.AddRow(
claimLease.Id.ToString(),
claimLease.Price.ToString(),
claimLease.Claim.ChipDensity.ToString(),
claimLease.Claim.Hardness.ToString());
}
Game.Write(table);
}
private static void ReportDiggerUpgrades(ChipDigger digger)
{
Game.WriteLine("Available Upgrades", PcmColor.Black, PcmColor.Yellow);
var upgradesTable = new TableOutput(80, PcmColor.Yellow);
upgradesTable.AddHeaders("Name", "Max Level", "Current Level", "Slot");
foreach (var diggerUpgrade in digger.AvailableUpgrades)
{
upgradesTable.AddRow(diggerUpgrade.Name,
diggerUpgrade.MaxLevel.ToString(),
diggerUpgrade.CurrentLevel.ToString(),
diggerUpgrade.Slot.ToString()
);
upgradesTable.AddRow(diggerUpgrade.Description);
}
Game.Write(upgradesTable);
}
public CommandsGroup Build()
{
var commandsGroup = new CommandsGroup();
commandsGroup.LocalCommands = new List <CommandsDefinition>
{
new CommandsDefinition
{
CommandText = "help",
Description = "Display all of the commands available.",
Command = (userCommand, GameState) => new HelpCommand {
GameState = GameState
}
},
new CommandsDefinition
{
CommandText = "store",
Description = "Opens the store mode and makes the store commands accessible.",
Execute = (command, gameState) => { gameState.Store.EnterRoom(); }
},
new CommandsDefinition
{
CommandText = "miner",
Description = "Displays the miner's current chip vault, tater tokens, and diggers",
Execute = (userCommand, gameState) =>
{
var miner = gameState.Miner;
Game.WriteLine($"Name: {miner.Name}", PcmColor.Yellow);
Game.WriteLine($"Chip Vault:{miner.Inventory("rawchip").Count}", PcmColor.Yellow);
Game.WriteLine($"Tater Tokens:{miner.TaterTokens}", PcmColor.Yellow);
Game.WriteLine($"Diggers Count:{miner.Diggers.Count}", PcmColor.Yellow);
Game.WriteLine($"Lifetime Chips Dug:{miner.GetLifeTimeStat(Stats.LifetimeChips)}");
}
},
new CommandsDefinition
{
CommandText = "vault",
Description = "Shows the number of chips currently in your vault.",
Execute = (userCommand, gameState) =>
{
Game.WriteLine($"Chip Vault: {gameState.Miner.Inventory("rawchip").Count}");
}
},
new CommandsDefinition
{
CommandText = "tokens",
Description = "Shows then number of tokens you currently have.",
Execute = TokensHandler()
},
new CommandsDefinition
{
CommandText = "exit",
Description = "Leaves the current room and returns you to the lobby.",
Execute = (userCommand, gameState) =>
{
if (gameState.Mode == GameMode.Lobby)
{
return;
}
Game.WriteLine($"Leaving {gameState.Mode}...");
gameState.Lobby.EnterRoom();
}
},
new CommandsDefinition
{
CommandText = "quit",
Description = "Ends the game.",
Execute = (userCommand, gameState) => { gameState.Running = false; }
},
new CommandsDefinition
{
CommandText = "end",
Description = "Ends the game.",
Execute = (userCommand, gameState) => { gameState.Running = false; }
},
new CommandsDefinition
{
CommandText = "inventory",
Description = "Shows the miners items inventory",
Execute = (userCommand, gameState) =>
{
var table = new TableOutput(80);
table.AddHeaders("Name", "Quantity");
foreach (var minerInventoryItem in gameState.Miner.InventoryItems)
{
table.AddRow(minerInventoryItem.Name, minerInventoryItem.Count.ToString());
}
Game.Write(table);
}
},
new CommandsDefinition
{
CommandText = "control-room",
Description = "Enter the control room. Control room commands become available",
Execute = (userCommand, gameState) => { gameState.ControlRoom.EnterRoom(); }
},
new CommandsDefinition
{
CommandText = "diggers",
Description = "Displays a list of all of the miner's equipped diggers.",
Execute = (userCommand, gameState) =>
{
var table = new TableOutput(80, PcmColor.Yellow);
table.AddHeaders("Name", "Durability", "Density", "Hardness", "Hopper Space");
foreach (var digger in gameState.Miner.Diggers)
{
table.AddRow(digger.Name,
digger.Durability.Current.ToString(),
digger.MineClaim.ChipDensity.ToString(),
digger.MineClaim.Hardness.ToString(),
$"{digger.Hopper.Max - digger.Hopper.Count}/{digger.Hopper.Max}");
}
Game.Write(table);
}
},
new CommandsDefinition
{
CommandText = "claims",
Description = "Shows the miners claims",
Execute = (userCommand, gameState) =>
{
var table = new TableOutput(80);
table.AddHeaders("Id", "Price", "Density", "Hardness", "InUse");
foreach (var claimLease in gameState.Miner.ClaimLeases.GetAll())
{
table.AddRow(
claimLease.Id.ToString(),
claimLease.Price.ToString(),
claimLease.Claim.ChipDensity.ToString(),
claimLease.Claim.Hardness.ToString(),
claimLease.InUse ? "X" : "");
}
Game.Write(table);
}
},
new CommandsDefinition
{
CommandText = "save",
Description = "Saves the current game.",
Execute = SaveHandler()
},
new CommandsDefinition
{
CommandText = "load",
EntryDescription = "load || load [save name]",
Description = "Loads shows games available to load, or loads the indicated saved game.",
Execute = LoadHandler()
},
new CommandsDefinition
{
CommandText = "claims-office",
Description = "Enter the claims office. Claims will be available for purchase.",
Execute = (userCommand, gameState) => { gameState.ClaimsOffice.EnterRoom(); }
}
};
return(commandsGroup);
}
