/*
* Fetch all players from the database and rturn the resulant playerList object
*/
public PlayerCollection getPlayers()
{
PlayerCollection playerList = new PlayerCollection();
const string selectStatement = "SELECT * FROM player";
cmd = new SqlCommand(selectStatement, conn);
try
{
conn.Open();
SqlDataReader reader = cmd.ExecuteReader(CommandBehavior.CloseConnection);
while (reader.Read())
playerList.Add(new Player(reader["playerName"].ToString(), (int)reader["rating"], (int)reader["wins"], (int)reader["losses"], (int)reader["draws"], (int)reader["id"]));
reader.Close();
}
catch (SqlException)
{
}
finally
{
conn.Close();
}
return playerList;
}
public Game(SerializationInfo info, StreamingContext context)
{
CombatLocations = (LocationCollection)info.GetValue("CombatLocations", typeof(LocationCollection));
StarSystems = (StarSystemCollection)info.GetValue("StarSystems", typeof(StarSystemCollection));
Players = (PlayerCollection)info.GetValue("Players", typeof(PlayerCollection));
ExistingHulls = (List<ShipHull>)info.GetValue("ExistingHulls", typeof(List<ShipHull>));
ExistingParts = (List<EidosPart>)info.GetValue("ExistingParts", typeof(List<EidosPart>));
ExistingShips = (List<Ship>)info.GetValue("ExistingShips", typeof(List<Ship>));
}
/*
* Fetch all players from the database and store them in the playerList object
* passed in by reference
*/
public PlayerCollection getPlayers()
{
XmlDocument doc = GetFile(fullPath);
PlayerCollection list = new PlayerCollection();
foreach (XmlElement elem in doc.DocumentElement.ChildNodes)
{
list.Add(FromElement(elem));
}
return list;
}
public GameOverview(GameSettings settings = null)
{
if (settings == null)
{
settings = new GameSettings();
}
Settings = settings;
Players = new PlayerCollection();
Status = GameStatus.WaitingForPlayers;
}
public PlayerCollection<Player> CreatePlayerCollection()
{
var players = new PlayerCollection<Player>();
for (int i = 0; i < 15; i++)
{
players.Add(new Player(i, "PlayerKey_" + i, "Player " + i, "Status_" + i, null, null));
}
return players;
}
public Table(int playerCount, AppSettings settings)
{
TotalRounds = 0;
ButtonPlayerPrev = -999;
_random = new Random();
ShortButton1 = settings.ShortButtonRect1;
ShortButton2 = settings.ShortButtonRect2;
ShortButton3 = settings.ShortButtonRect3;
ShortButton4 = settings.ShortButtonRect4;
CardSuitRect = settings.CardSuitRect;
CardRankRect = settings.CardRankRect;
CardMinSize = (int)settings.MinCardSize;
BetCounterPreFlop = 1;
BetCounterFlop = 1;
BetCounterTurn = 1;
BetCounterRiver = 1;
RaiseCounter = 0;
PlayerActionCounter = 0;
PlayerRects = new List<Rectangle>();
PlayerFolds = new List<Rectangle>();
ButtonRects = new List<Rectangle>();
BetRects = new List<Rectangle>();
Players = new PlayerCollection();
DealerButtons = new List<bool>();
PlayerBets = new List<PlayerBet>();
MyBalance = new Player();
Bank = new Bank();
for (int i = 0; i < playerCount; i++)
{
Players.Add(new Player {Action = PlayerAction.Init});
}
for (int i = 0; i < playerCount; i++)
{
DealerButtons.Add(false);
}
for (int i = 0; i < playerCount; i++)
{
PlayerBets.Add(new PlayerBet());
}
_cardRecognizer = new CardRecognizer();
}
protected GameManager()
{
Players = new PlayerCollection();
WallList = new List<Wall>();
PowerUpList = new List<PowerUp>();
BombList = new List<Bomb>();
_currentMap = new Map();
BaseCurrentMap = _currentMap;
_gameStopWatch = TimeSpan.Zero;
_gameTime = new GameTime();
}
public GeneralStats(Demo demo)
: base(demo)
{
m_GameEventHandlers = new Dictionary<string, OnGameEvent>();
m_GameEventHandlers.Add("flashbang_detonate", new OnGameEvent(FlashbangDetonate));
m_GameEventHandlers.Add("player_blind", new OnGameEvent(PlayerBlind));
m_GameEventHandlers.Add("player_connect", new OnGameEvent(PlayerConnect));
m_GameEventHandlers.Add("player_connect_full", new OnGameEvent(PlayerConnectFull));
m_GameEventHandlers.Add("player_death", new OnGameEvent(PlayerDeath));
m_GameEventHandlers.Add("player_disconnect", new OnGameEvent(PlayerDisconnect));
m_GameEventHandlers.Add("player_team", new OnGameEvent(PlayerTeam));
m_Players = new PlayerCollection(demo);
}
/*
* Fetch all players from the database and store them in the playerList object
* passed in by reference
*/
public PlayerCollection getPlayers()
{
PlayerCollection playerList = new PlayerCollection();
if (File.Exists(this.fullPath))
{
byte[] fileContents = File.ReadAllBytes(this.fullPath);
Player currPlayer = null;
int currIndex = 0;
while ((currPlayer = Player.FromBytes(fileContents, ref currIndex)) != null)
playerList.Add(currPlayer);
}
return playerList;
}
public Main()
{
InitializeComponent();
IPlayerDB db = GetPlayerIO();
this.playerList = db.getPlayers();
foreach (Player p in this.playerList)
{
cmbPlayer1.Items.Add(p);
cmbPlayer2.Items.Add(p);
}
#if DEBUG
if (this.playerList.Count > 1)
{
cmbPlayer1.SelectedIndex = 0;
cmbPlayer2.SelectedIndex = 1;
}
#endif
}
/// <summary>
/// Parses the raw binary data for use within TQVault
/// </summary>
private void ParseRawData(PlayerCollection pc)
{
// First create a memory stream so we can decode the binary data as needed.
using (MemoryStream stream = new MemoryStream(pc.rawData, false))
using (BinaryReader reader = new BinaryReader(stream))
{
// Find the block pairs until we find the block that contains the item data.
int blockNestLevel = 0;
int currentOffset = 0;
int itemOffset = 0;
int equipmentOffset = 0;
// vaults start at the item data with no crap
bool foundItems = pc.IsVault;
bool foundEquipment = pc.IsVault;
while ((!foundItems || !foundEquipment) && (currentOffset = FindNextBlockDelim(pc, currentOffset)) != -1)
{
if (pc.rawData[currentOffset] == beginBlockPattern[0])
{
// begin block
++blockNestLevel;
currentOffset += beginBlockPattern.Length;
// skip past the 4 bytes of noise after begin_block
currentOffset += 4;
// Seek our stream to the correct position
stream.Seek(currentOffset, SeekOrigin.Begin);
// Now get the string for pc block
string blockName = TQData.ReadCString(reader).ToUpperInvariant();
// Assign loc to our new stream position
currentOffset = (int)stream.Position;
// See if we accidentally got a begin_block or end_block
if (blockName.Equals("BEGIN_BLOCK"))
{
blockName = "(NONAME)";
currentOffset -= beginBlockPattern.Length;
}
else if (blockName.Equals("END_BLOCK"))
{
blockName = "(NONAME)";
currentOffset -= endBlockPattern.Length;
}
else if (blockName.Equals("ITEMPOSITIONSSAVEDASGRIDCOORDS"))
{
currentOffset += 4;
itemOffset = currentOffset; // skip value for itemPositionsSavedAsGridCoords
foundItems = true;
}
else if (blockName.Equals("USEALTERNATE"))
{
currentOffset += 4;
equipmentOffset = currentOffset; // skip value for useAlternate
foundEquipment = true;
}
}
else
{
// end block
--blockNestLevel;
currentOffset += endBlockPattern.Length;
}
}
if (foundItems)
{
try
{
ParseItemBlock(pc, itemOffset, reader);
}
catch (ArgumentException exception)
{
var ex = new ArgumentException($"Error parsing player file Item Block- '{pc.PlayerName}'", exception);
Log.ErrorException(ex);
throw ex;
}
}
// Process the equipment block
if (foundEquipment && !pc.IsVault)
{
try
{
ParseEquipmentBlock(pc, equipmentOffset, reader);
}
catch (ArgumentException exception)
{
var ex = new ArgumentException($"Error parsing player file Equipment Block - '{pc.PlayerName}'", exception);
Log.ErrorException(ex);
throw ex;
}
}
if (pc.IsPlayer)
{
try
{
pc.PlayerInfo = ReadPlayerInfo(pc);
}
catch (ArgumentException ex)
{
var exx = new ArgumentException($"Error parsing player player info Block - '{pc.PlayerName}'", ex);
Log.ErrorException(exx);
throw exx;
}
}
}
}
public GameServer()
{
Channels = new ChannelCollection();
Rooms = new RoomCollection();
Players = new PlayerCollection();
Logger = new Logger() { WriteToConsole = true };
_packetLogger = new PacketLogger();
Logger.Load(Path.Combine("logs", string.Format("game_{0}.log", DateTime.Now.ToString("dd-MM-yyyy_HH-mm-ss"))));
AppDomain.CurrentDomain.UnhandledException += (s, e) =>
{
Error(s, new ExceptionEventArgs((Exception)e.ExceptionObject));
Environment.Exit(0);
};
_packetLogger.Load("game_packets.log");
Logger.Info("Loading game_config.xml...");
GameConfig.Load();
Logger.Info("Setting up servers...");
_server = new TcpServer(IPAddress.Parse(GameConfig.Instance.IP), GameConfig.Instance.Port);
_server.PacketReceived += HandlePacket;
_server.ClientDisconnected += ClientDisconnected;
_server.Error += Error;
var isMono = Type.GetType("Mono.Runtime") != null;
switch (GameConfig.Instance.AuthRemote.Binding)
{
case "pipe":
if (isMono)
{
Logger.Error("pipe is not supported in mono, use http!");
Environment.Exit(1);
return;
}
_authRemoteClient = new RemoteClient(ERemoteBinding.Pipe, string.Format("localhost/AuthServer/{0}/", SHA256.ComputeHash(GameConfig.Instance.AuthRemote.Password)));
break;
case "tcp":
if (isMono)
{
Logger.Error("pipe is not supported in mono, use http!");
Environment.Exit(1);
return;
}
_authRemoteClient = new RemoteClient(ERemoteBinding.Pipe, string.Format("{0}:{1}/AuthServer/{2}/", GameConfig.Instance.AuthRemote.Server, GameConfig.Instance.AuthRemote.Port, SHA256.ComputeHash(GameConfig.Instance.AuthRemote.Password)));
break;
case "http":
_authRemoteClient = new RemoteClient(ERemoteBinding.Http, string.Format("{0}:{1}/AuthServer/{2}/", GameConfig.Instance.AuthRemote.Server, GameConfig.Instance.AuthRemote.Port, SHA256.ComputeHash(GameConfig.Instance.AuthRemote.Password)));
break;
default:
Logger.Error("Invalid remote binding '{0}' for AuthRemote", GameConfig.Instance.AuthRemote.Binding);
Environment.Exit(1);
break;
}
Logger.Info("Loading plugins... {0}",AppDomain.CurrentDomain.BaseDirectory);
_pluginManager.Load();
foreach (var plugin in _pluginManager.Plugins)
Logger.Info("Loaded {0}", plugin.Name);
}
protected virtual void Dispose(bool disposing)
{
// Check to see if Dispose has already been called.
if (!this.disposed)
{
// If disposing equals true, dispose all managed
// and unmanaged resources.
if (disposing)
{
// Dispose managed resources.
this._ActivePlayer = null;
this._CardsAvailable = null;
this._MessageRequestQueue = null;
this._MessageResponseQueue = null;
this._Players = null;
this._RNG = null;
this._Table = null;
this._TurnsTaken = null;
}
// Call the appropriate methods to clean up
// unmanaged resources here.
// If disposing is false,
// only the following code is executed.
// Note disposing has been done.
disposed = true;
}
}
public Ethic()
{
m_Players = new PlayerCollection();
}
public override void DisplayKingsReward( PlayerCollection players )
{
//Displays the confirmation that the players in the playerlist have received a 1VP bonus.
switch( this.Mode )
{
case graphicsMode.CLI:
foreach( Player p in players )
{
Console.WriteLine( "{0} receives the King's reward of 1 Victory Point.", p.Name );
}
break;
case graphicsMode.GUI:
throw new NotImplementedException();
}
}
/// <summary>
/// Commits the player info changes to the player.chr file
/// </summary>
/// <param name="playerInfo"></param>
/// <param name="playerFileRawData"></param>
public void Commit(PlayerCollection pc)
{
TQData.WriteIntAfter(pc.rawData, "playerLevel", pc.PlayerInfo.CurrentLevel);
TQData.WriteIntAfter(pc.rawData, "money", pc.PlayerInfo.Money);
TQData.WriteIntAfter(pc.rawData, "masteriesAllowed", pc.PlayerInfo.MasteriesAllowed);
// first "temp" / first "block"
var difficultyUnlocked = TQData.WriteIntAfter(pc.rawData, "temp", pc.PlayerInfo.DifficultyUnlocked);
TQData.WriteIntAfter(pc.rawData, "currentStats.charLevel", pc.PlayerInfo.CurrentLevel);
TQData.WriteIntAfter(pc.rawData, "currentStats.experiencePoints", pc.PlayerInfo.CurrentXP);
TQData.WriteIntAfter(pc.rawData, "modifierPoints", pc.PlayerInfo.AttributesPoints);
TQData.WriteIntAfter(pc.rawData, "skillPoints", pc.PlayerInfo.SkillPoints);
var baseStrength = TQData.WriteFloatAfter(pc.rawData, "temp", pc.PlayerInfo.BaseStrength, difficultyUnlocked.nextOffset);
var baseDexterity = TQData.WriteFloatAfter(pc.rawData, "temp", pc.PlayerInfo.BaseDexterity, baseStrength.nextOffset);
var baseIntelligence = TQData.WriteFloatAfter(pc.rawData, "temp", pc.PlayerInfo.BaseIntelligence, baseDexterity.nextOffset);
var baseHealth = TQData.WriteFloatAfter(pc.rawData, "temp", pc.PlayerInfo.BaseHealth, baseIntelligence.nextOffset);
var baseMana = TQData.WriteFloatAfter(pc.rawData, "temp", pc.PlayerInfo.BaseMana, baseHealth.nextOffset);
if (pc.PlayerInfo.MasteriesAllowed_OldValue.HasValue && pc.PlayerInfo.MasteriesAllowed < pc.PlayerInfo.MasteriesAllowed_OldValue ||
pc.PlayerInfo.MasteriesResetRequiered)
{
pc.PlayerInfo.ResetMasteries();
#region Override skill lines block after reset
// Find skill section boundaries
var firstblock = TQData.ReadIntAfter(pc.rawData, "begin_block");
var secondblock = TQData.ReadIntAfter(pc.rawData, "begin_block", firstblock.nextOffset);
var max = TQData.ReadIntAfter(pc.rawData, "max", secondblock.nextOffset); // Boundary top
var end_block = TQData.ReadIntAfter(pc.rawData, "end_block", max.nextOffset);
var masteriesAllowed = TQData.ReadIntAfter(pc.rawData, "masteriesAllowed", max.nextOffset); // Boundary bottom
// Split file
var startfile = pc.rawData.Take(max.nextOffset).ToArray();
var endfile = pc.rawData.Skip(masteriesAllowed.indexOf - 4).ToArray(); // -4 include key name length
// make binary section
var section = pc.PlayerInfo.SkillRecordList.SelectMany(s => s.ToBinary(secondblock.valueAsInt, end_block.valueAsInt)).ToArray();
// put pieces back together
pc.rawData = new[] {
startfile,
section,
endfile,
}.SelectMany(a => a).ToArray();
// Adjust "max" value
var found = TQData.WriteIntAfter(pc.rawData, "max", pc.PlayerInfo.SkillRecordList.Count, max.indexOf);
// Adjust "skillPoints"
var skillpointsToRestore = pc.PlayerInfo.ReleasedSkillPoints;
if (skillpointsToRestore > 0)
{
TQData.WriteIntAfter(pc.rawData, "skillPoints", pc.PlayerInfo.SkillPoints + skillpointsToRestore);
}
#endregion
}
//if this value is set to true, the TQVaultAE program will know save the player.chr file
pc.PlayerInfo.Modified = true;
}
public abstract void DisplayPlayerOrder(PlayerCollection order);
/// <summary>
/// Updates the list of client names in the window
/// </summary>
/// <param name="players">The list of players to add</param>
public void UpdateClientList(List<Player> players)
{
if (InvokeRequired)
{
Invoke(new PlayerListCallback(UpdateClientList), players);
}
else
{
if (dgvPlayers.DataSource == null)
dgvPlayers.DataSource = pc;
string selected = null;
if (pc.Count > 0 && dgvPlayers.SelectedRows.Count > 0)
{
selected = (from DataGridViewRow row in dgvPlayers.Rows where row.Selected select pc[row.Index]).First().name;
}
dgvPlayers.SuspendLayout();
pc = new PlayerCollection(new PlayerListView());
Player.players.ForEach(p => pc.Add(p));
dgvPlayers.Invalidate();
dgvPlayers.DataSource = pc;
if (selected != null)
{
foreach (Player t in Player.players)
for (int j = 0; j < dgvPlayers.Rows.Count; j++)
if (Equals(dgvPlayers.Rows[j].Cells[0].Value, selected))
dgvPlayers.Rows[j].Selected = true;
}
dgvPlayers.Refresh();
dgvPlayers.ResumeLayout();
}
}
public Controller()
{
Players = new PlayerCollection();
}
public static bool HasYears(this PlayerCollection <LifeCardGamePlayerItem> thisList)
{
return(thisList.Any(thisPlayer => thisPlayer.MainHandList.Any(thisCard => thisCard.Points == 0)));
}
/// <summary>
/// Searches all loaded player files
/// </summary>
/// <param name="predicate">Predicate that the items should match</param>
/// <param name="quality">Quality filter</param>
/// <param name="searchByType">flag for whether we are searching by type or name</param>
/// <param name="results">List holding the search results.</param>
private void SearchPlayers(IItemPredicate predicate, List <Result> results)
{
if (this.UserContext.Players == null || this.UserContext.Players.Count == 0)
{
return;
}
foreach (KeyValuePair <string, PlayerCollection> kvp in this.UserContext.Players)
{
string playerFile = kvp.Key;
PlayerCollection player = kvp.Value;
if (player == null)
{
// Make sure the name is valid and we have a player.
Log.DebugFormat(CultureInfo.InvariantCulture, "playerFile={0} returned null player.", playerFile);
continue;
}
string playerName = GetNameFromFile(playerFile);
if (playerName == null)
{
Log.DebugFormat(CultureInfo.InvariantCulture, "playerFile={0} returned null playerName.", playerFile);
continue;
}
int sackNumber = -1;
foreach (SackCollection sack in player)
{
sackNumber++;
if (sack == null)
{
Log.DebugFormat(CultureInfo.InvariantCulture, "playerFile={0}", playerFile);
Log.DebugFormat(CultureInfo.InvariantCulture, "sack({0}) returned null.", sackNumber);
continue;
}
// Query the sack for the items containing the search string.
foreach (var fnames in QuerySack(predicate, sack))
{
results.Add(new Result(
playerFile,
playerName,
sackNumber,
SackType.Player,
fnames
));
}
}
// Now search the Equipment panel
SackCollection equipmentSack = player.EquipmentSack;
if (equipmentSack == null)
{
Log.DebugFormat(CultureInfo.InvariantCulture, "playerFile={0} Equipment Sack returned null.", playerFile);
continue;
}
foreach (var fnames in QuerySack(predicate, equipmentSack))
{
results.Add(new Result(
playerFile,
playerName,
0,
SackType.Equipment,
fnames
));
}
}
}
public Ethic()
{
m_Players = new PlayerCollection();
}
/// <summary>
/// Handles moving on to the next duel, this will also check for the end of the game as set the GAME_OVER param to true if needed
/// </summary>
/// <param name="server">The server to excecute on</param>
public static void MoveNextDuel(GameServer server)
{
GameState state = server.GameState;
PlayerCollection players = server.Players;
if (!state.GetValueBool(Names.GAME_OVER))
{
// Start by determining the number of active players
int activePlayers = players.Where(X => X.Hand.Count > 0).Count();
// If there are more than 1 players left, keep playing
if (activePlayers > 1)
{
// Clear the battle-specific states
state.Set(Names.IS_ATTACKING, true);
state.Set(Names.ATTACKER_FORFEIT, false);
state.Set(Names.DEFENDER_FORFEIT, false);
// Clear the match-specific states
state.Set(Names.CURRENT_ROUND, 0);
// Get the ID of the attacking player, this is the first person to get new cards
byte id = state.GetValueByte(Names.ATTACKING_PLAYER);
byte startId = id;
// Get the deck off the state
Deck deck = new Deck(state.GetValueCardCollection(Names.DECK));
bool go = true;
while (go)
{
Player player = players[id];
if (player != null)
{
while (player.Hand.Count < 6)
{
if (deck.Cards.Count > 0)
{
player.Hand.Add(deck.Draw());
}
else if (!state.GetValueBool(Names.TRUMP_CARD_USED))
{
player.Hand.Add(state.GetValueCard(Names.TRUMP_CARD));
state.Set <bool>(Names.TRUMP_CARD_USED, true);
go = false;
break;
}
else
{
break;
}
}
}
id++;
if (id >= players.Count)
{
id = 0;
}
if (id == startId)
{
break;
}
}
// Start by getting a round idea of the new attackers and defenders
byte attackingPlayerId = (byte)(state.GetValueByte(Names.ATTACKING_PLAYER) + 1);
// Iterate over each player until we come across a valid attacker
for (byte index = attackingPlayerId, iterations = 0; iterations < players.Count; index++, iterations++)
{
index = (byte)(index >= players.Count ? players.Count - index : index);
if (players[index] != null && players[index].Hand.Count > 0)
{
attackingPlayerId = index;
break;
}
}
byte defendingPlayerId = (byte)(attackingPlayerId + 1 >= players.Count ? players.Count - (attackingPlayerId + 1) : attackingPlayerId + 1);
// Iterate over each player until we come across a valid defender
for (byte index = defendingPlayerId, iterations = 0; iterations < players.Count; index++, iterations++)
{
index = (byte)(index >= players.Count ? players.Count - index : index);
if (players[index] != null && players[index].Hand.Count > 0)
{
defendingPlayerId = index;
break;
}
}
// Update the attacker and defenders
state.Set(Names.ATTACKING_PLAYER, attackingPlayerId);
state.Set(Names.DEFENDING_PLAYER, defendingPlayerId);
state.Set(Names.DECK, deck.Cards);
state.Set(Names.DECK_COUNT, deck.CardsInDeck);
}
else
{
if (activePlayers == 1)
{
state.Set <byte>(Names.LOSER_ID, players.Where(X => X.Hand.Count > 0).ElementAt(0).PlayerId);
state.Set <bool>(Names.IS_TIE, false);
state.Set <bool>(Names.GAME_OVER, true);
}
else if (activePlayers == 0)
{
state.Set <bool>(Names.IS_TIE, true);
state.Set <bool>(Names.GAME_OVER, true);
}
}
}
}
private void RefreshPlayersGrid()
{
playersDataGridView.DataSource = null;
playersDataGridView.DataSource = PlayerCollection.Instance().Players;
}
internal TeamRosterPlayerCollection(Team team, PlayerCollection<Player> players, int week)
{
if (team == null) { throw new ArgumentNullException("team"); }
if (players == null) { throw new ArgumentNullException("players"); }
this.Team = team;
this.Players = players;
this.Week = week;
}
public abstract void DisplayKingsReward(PlayerCollection players);
public AddPlayerWindow(PlayerCollection PlayerList)
{
initAddPlayerWindow(PlayerList);
}
/// <summary>
/// Parses the raw binary data for use within TQVault
/// </summary>
private void ParseRawData(PlayerCollection pc)
{
// First create a memory stream so we can decode the binary data as needed.
using (MemoryStream stream = new MemoryStream(pc.rawData, false))
{
using (BinaryReader reader = new BinaryReader(stream))
{
// Find the block pairs until we find the block that contains the item data.
int blockNestLevel = 0;
int currentOffset = 0;
int itemOffset = 0;
int equipmentOffset = 0;
var playerReader = new PlayerInfoReader(this.TQData);
// vaults start at the item data with no crap
bool foundItems = pc.IsVault;
bool foundEquipment = pc.IsVault;
while ((!foundItems || !foundEquipment) && (currentOffset = FindNextBlockDelim(pc, currentOffset)) != -1)
{
if (pc.rawData[currentOffset] == beginBlockPattern[0])
{
// begin block
++blockNestLevel;
currentOffset += beginBlockPattern.Length;
// skip past the 4 bytes of noise after begin_block
currentOffset += 4;
// Seek our stream to the correct position
stream.Seek(currentOffset, SeekOrigin.Begin);
// Now get the string for pc block
string blockName = TQData.ReadCString(reader).ToUpperInvariant();
// Assign loc to our new stream position
currentOffset = (int)stream.Position;
// See if we accidentally got a begin_block or end_block
if (blockName.Equals("BEGIN_BLOCK"))
{
blockName = "(NONAME)";
currentOffset -= beginBlockPattern.Length;
}
else if (blockName.Equals("END_BLOCK"))
{
blockName = "(NONAME)";
currentOffset -= endBlockPattern.Length;
}
else if (blockName.Equals("ITEMPOSITIONSSAVEDASGRIDCOORDS"))
{
currentOffset += 4;
itemOffset = currentOffset; // skip value for itemPositionsSavedAsGridCoords
foundItems = true;
}
else if (blockName.Equals("USEALTERNATE"))
{
currentOffset += 4;
equipmentOffset = currentOffset; // skip value for useAlternate
foundEquipment = true;
}
else if (!pc.IsVault && playerReader.Match(blockName))
{
playerReader.Record(blockName, currentOffset);
}
}
else
{
// end block
--blockNestLevel;
currentOffset += endBlockPattern.Length;
}
}
if (foundItems)
{
try
{
ParseItemBlock(pc, itemOffset, reader);
}
catch (ArgumentException exception)
{
var ex = new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Error parsing player file Item Block- '{0}'", pc.PlayerName), exception);
Log.ErrorFormat(CultureInfo.InvariantCulture, "Error parsing player file Item Block - '{0}'", pc.PlayerName);
Log.ErrorException(exception);
throw ex;
}
try
{
string outfile = string.Concat(Path.Combine(GamePathResolver.TQVaultSaveFolder, pc.PlayerName), " Export.txt");
using (StreamWriter outStream = new StreamWriter(outfile, false))
{
outStream.WriteLine("Number of Sacks = {0}", pc.numberOfSacks);
int sackNumber = 0;
if (pc.sacks != null)
{
foreach (SackCollection sack in pc.sacks)
{
if (!sack.IsEmpty)
{
outStream.WriteLine();
outStream.WriteLine("SACK {0}", sackNumber);
int itemNumber = 0;
foreach (Item item in sack)
{
object[] params1 = new object[20];
params1[0] = itemNumber;
params1[1] = ItemProvider.ToFriendlyName(item);
params1[2] = item.PositionX;
params1[3] = item.PositionY;
params1[4] = item.Seed;
////params1[5] =
outStream.WriteLine(" {0,5:n0} {1}", params1);
itemNumber++;
}
}
sackNumber++;
}
}
}
}
catch (IOException exception)
{
Log.ErrorFormat(exception, "Error writing Export file - '{0}'"
, string.Concat(Path.Combine(GamePathResolver.TQVaultSaveFolder, pc.PlayerName), " Export.txt")
);
}
}
// Process the equipment block
if (foundEquipment && !pc.IsVault)
{
try
{
ParseEquipmentBlock(pc, equipmentOffset, reader);
}
catch (ArgumentException exception)
{
var ex = new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Error parsing player file Equipment Block - '{0}'", pc.PlayerName), exception);
Log.ErrorFormat(ex, "Error parsing player file Equipment Block - '{0}'", pc.PlayerName);
throw ex;
}
try
{
string outfile = string.Concat(Path.Combine(GamePathResolver.TQVaultSaveFolder, pc.PlayerName), " Equipment Export.txt");
using (StreamWriter outStream = new StreamWriter(outfile, false))
{
if (!pc.EquipmentSack.IsEmpty)
{
int itemNumber = 0;
foreach (Item item in pc.EquipmentSack)
{
object[] params1 = new object[20];
params1[0] = itemNumber;
params1[1] = ItemProvider.ToFriendlyName(item);
params1[2] = item.PositionX;
params1[3] = item.PositionY;
params1[4] = item.Seed;
////params1[5] =
outStream.WriteLine(" {0,5:n0} {1}", params1);
itemNumber++;
}
}
}
}
catch (IOException exception)
{
Log.ErrorFormat(exception, "Error writing Export file - '{0}'"
, string.Concat(Path.Combine(GamePathResolver.TQVaultSaveFolder, pc.PlayerName), " Equipment Export.txt")
);
}
}
if (playerReader.FoundPlayerInfo && !pc.IsVault)
{
try
{
playerReader.Read(reader);
pc.PlayerInfo = playerReader.GetPlayerInfo();
}
catch (ArgumentException exception)
{
var rethrowex = new ArgumentException(string.Format(CultureInfo.InvariantCulture, "Error parsing player player info Block - '{0}'", pc.PlayerName), exception);
Log.ErrorException(rethrowex);
throw rethrowex;
}
}
}
}
}
/// <summary>
/// Find character data in player.chr file
/// </summary>
public PlayerInfo ReadPlayerInfo(PlayerCollection pc)
{
var pi = new PlayerInfo();
pi.Modified = false;
var headerVersion = TQData.ReadIntAfter(pc.rawData, "headerVersion");
pi.HeaderVersion = headerVersion.valueAsInt;
var playerCharacterClass = TQData.ReadCStringAfter(pc.rawData, "playerCharacterClass");
pi.PlayerCharacterClass = playerCharacterClass.valueAsString;
var playerClassTag = TQData.ReadCStringAfter(pc.rawData, "playerClassTag");
pi.Class = playerClassTag.valueAsString;
var money = TQData.ReadIntAfter(pc.rawData, "money", playerClassTag.nextOffset);
pi.Money = money.valueAsInt;
var masteriesAllowed = TQData.ReadIntAfter(pc.rawData, "masteriesAllowed", money.nextOffset);
pi.MasteriesAllowed = masteriesAllowed.valueAsInt;
var difficultyUnlocked = TQData.ReadIntAfter(pc.rawData, "temp"); // first "temp" / first "block"
pi.DifficultyUnlocked = difficultyUnlocked.valueAsInt;
var hasBeenInGame = TQData.ReadIntAfter(pc.rawData, "hasBeenInGame", difficultyUnlocked.nextOffset);
pi.HasBeenInGame = hasBeenInGame.valueAsInt;
var currentStatscharLevel = TQData.ReadIntAfter(pc.rawData, "currentStats.charLevel", hasBeenInGame.nextOffset);
pi.CurrentLevel = currentStatscharLevel.valueAsInt;
var currentStatsexperiencePoints = TQData.ReadIntAfter(pc.rawData, "currentStats.experiencePoints", currentStatscharLevel.nextOffset);
pi.CurrentXP = currentStatsexperiencePoints.valueAsInt;
var modifierPoints = TQData.ReadIntAfter(pc.rawData, "modifierPoints", currentStatsexperiencePoints.nextOffset);
pi.AttributesPoints = modifierPoints.valueAsInt;
var skillPoints = TQData.ReadIntAfter(pc.rawData, "skillPoints", modifierPoints.nextOffset);
pi.SkillPoints = skillPoints.valueAsInt;
var baseStrength = TQData.ReadFloatAfter(pc.rawData, "temp", difficultyUnlocked.nextOffset); // first "temp" after first one (difficultyUnlocked)
pi.BaseStrength = Convert.ToInt32(baseStrength.valueAsFloat);
var baseDexterity = TQData.ReadFloatAfter(pc.rawData, "temp", baseStrength.nextOffset); // second "temp" after first one
pi.BaseDexterity = Convert.ToInt32(baseDexterity.valueAsFloat);
var baseIntelligence = TQData.ReadFloatAfter(pc.rawData, "temp", baseDexterity.nextOffset); // third "temp" after first one
pi.BaseIntelligence = Convert.ToInt32(baseIntelligence.valueAsFloat);
var baseHealth = TQData.ReadFloatAfter(pc.rawData, "temp", baseIntelligence.nextOffset); // fourth "temp" after first one
pi.BaseHealth = Convert.ToInt32(baseHealth.valueAsFloat);
var baseMana = TQData.ReadFloatAfter(pc.rawData, "temp", baseHealth.nextOffset); // fifth "temp" after first one
pi.BaseMana = Convert.ToInt32(baseMana.valueAsFloat);
var playTimeInSeconds = TQData.ReadIntAfter(pc.rawData, "playTimeInSeconds", baseMana.nextOffset);
pi.PlayTimeInSeconds = playTimeInSeconds.valueAsInt;
var numberOfDeaths = TQData.ReadIntAfter(pc.rawData, "numberOfDeaths", playTimeInSeconds.nextOffset);
pi.NumberOfDeaths = numberOfDeaths.valueAsInt;
var numberOfKills = TQData.ReadIntAfter(pc.rawData, "numberOfKills", numberOfDeaths.nextOffset);
pi.NumberOfKills = numberOfKills.valueAsInt;
var experienceFromKills = TQData.ReadIntAfter(pc.rawData, "experienceFromKills", numberOfKills.nextOffset);
pi.ExperienceFromKills = experienceFromKills.valueAsInt;
var healthPotionsUsed = TQData.ReadIntAfter(pc.rawData, "healthPotionsUsed", experienceFromKills.nextOffset);
pi.HealthPotionsUsed = healthPotionsUsed.valueAsInt;
var manaPotionsUsed = TQData.ReadIntAfter(pc.rawData, "manaPotionsUsed", healthPotionsUsed.nextOffset);
pi.ManaPotionsUsed = manaPotionsUsed.valueAsInt;
var maxLevel = TQData.ReadIntAfter(pc.rawData, "maxLevel", manaPotionsUsed.nextOffset);
pi.MaxLevel = maxLevel.valueAsInt;
var numHitsReceived = TQData.ReadIntAfter(pc.rawData, "numHitsReceived", maxLevel.nextOffset);
pi.NumHitsReceived = numHitsReceived.valueAsInt;
var numHitsInflicted = TQData.ReadIntAfter(pc.rawData, "numHitsInflicted", numHitsReceived.nextOffset);
pi.NumHitsInflicted = numHitsInflicted.valueAsInt;
var greatestDamageInflicted = TQData.ReadIntAfter(pc.rawData, "greatestDamageInflicted", numHitsInflicted.nextOffset);
pi.GreatestDamageInflicted = greatestDamageInflicted.valueAsInt;
var greatestMonsterKilledName = TQData.ReadUnicodeStringAfter(pc.rawData, "(*greatestMonsterKilledName)[i]", greatestDamageInflicted.nextOffset);
pi.GreatestMonster = greatestMonsterKilledName.valueAsString;
var greatestMonsterKilledLevel = TQData.ReadIntAfter(pc.rawData, "(*greatestMonsterKilledLevel)[i]", greatestMonsterKilledName.nextOffset);
pi.GreatestMonsterKilledLevel = greatestMonsterKilledLevel.valueAsInt;
var greatestMonsterKilledLifeAndMana = TQData.ReadIntAfter(pc.rawData, "(*greatestMonsterKilledLifeAndMana)[i]", greatestMonsterKilledLevel.nextOffset);
pi.GreatestMonsterKilledLifeAndMana = greatestMonsterKilledLevel.valueAsInt;
var greatestMonsterKilledName2 = TQData.ReadUnicodeStringAfter(pc.rawData, "(*greatestMonsterKilledName)[i]", greatestMonsterKilledLifeAndMana.nextOffset);
var greatestMonsterKilledLevel2 = TQData.ReadIntAfter(pc.rawData, "(*greatestMonsterKilledLevel)[i]", greatestMonsterKilledName2.nextOffset);
var greatestMonsterKilledLifeAndMana2 = TQData.ReadIntAfter(pc.rawData, "(*greatestMonsterKilledLifeAndMana)[i]", greatestMonsterKilledLevel2.nextOffset);
var greatestMonsterKilledName3 = TQData.ReadUnicodeStringAfter(pc.rawData, "(*greatestMonsterKilledName)[i]", greatestMonsterKilledLifeAndMana2.nextOffset);
var greatestMonsterKilledLevel3 = TQData.ReadIntAfter(pc.rawData, "(*greatestMonsterKilledLevel)[i]", greatestMonsterKilledName3.nextOffset);
var greatestMonsterKilledLifeAndMana3 = TQData.ReadIntAfter(pc.rawData, "(*greatestMonsterKilledLifeAndMana)[i]", greatestMonsterKilledLevel3.nextOffset);
var criticalHitsInflicted = TQData.ReadIntAfter(pc.rawData, "criticalHitsInflicted", greatestMonsterKilledLifeAndMana3.nextOffset);
pi.CriticalHitsInflicted = criticalHitsInflicted.valueAsInt;
var criticalHitsReceived = TQData.ReadIntAfter(pc.rawData, "criticalHitsReceived", criticalHitsInflicted.nextOffset);
pi.CriticalHitsReceived = criticalHitsReceived.valueAsInt;
// Parse skills collection
var firstblock = TQData.BinaryFindKey(pc.rawData, "begin_block");
var secondblock = TQData.BinaryFindKey(pc.rawData, "begin_block", firstblock.nextOffset);
var max = TQData.ReadIntAfter(pc.rawData, "max", secondblock.nextOffset);
// Loop of sub block
int nextOffset = max.nextOffset;
for (var i = 0; i < max.valueAsInt; i++)
{
var begin_block = TQData.ReadIntAfter(pc.rawData, "begin_block", nextOffset);
var skillName = TQData.ReadCStringAfter(pc.rawData, "skillName", nextOffset);
var skillLevel = TQData.ReadIntAfter(pc.rawData, "skillLevel", nextOffset);
var skillEnabled = TQData.ReadIntAfter(pc.rawData, "skillEnabled", nextOffset);
var skillSubLevel = TQData.ReadIntAfter(pc.rawData, "skillSubLevel", nextOffset);
var skillActive = TQData.ReadIntAfter(pc.rawData, "skillActive", nextOffset);
var skillTransition = TQData.ReadIntAfter(pc.rawData, "skillTransition", nextOffset);
pi.SkillRecordList.Add(new SkillRecord()
{
skillActive = skillActive.valueAsInt,
skillEnabled = skillEnabled.valueAsInt,
skillLevel = skillLevel.valueAsInt,
skillName = skillName.valueAsString,
skillSubLevel = skillSubLevel.valueAsInt,
skillTransition = skillTransition.valueAsInt,
});
nextOffset = skillTransition.nextOffset;
}
return(pi);
}
void initAddPlayerWindow(PlayerCollection playerList)
{
this.Players = playerList;
Players.Clear();
Player one = new Player("Frank", "Furters", "Necrons",false,0);
Players.Add(one);
Player two = new Player("Joe (AI:4)", "Shmoes", "Orks",true,4);
Players.Add(two);
InitializeComponent();
initIconSets();
lbxPlayerList.ItemsSource = Players;
lbxPlayerList.UpdateLayout();
}
public void AddKingdomSupply(PlayerCollection players, Type cardType)
{
// Minimum required -- Need to do this first to figure out what kind of card it is (silly, I know)
Supply newSupply = new Supply(this._Game, players, cardType, 8);
if ((newSupply.Category & Category.Victory) == Category.Victory)
{
// Victory supply piles should be 12 in 3+ player games
if (NumPlayers > 2)
newSupply.AddTo(_BaseVictoryCards - 8);
}
else // Not a Victory card, so there should be 10
{
newSupply.AddTo(2);
}
_SupplyPiles[cardType] = newSupply;
_SupplyKeys = null;
}
public override PlayerCollection DisplayGetPlayers()
{
PlayerCollection toReturn = new PlayerCollection();
switch( this.Mode )
{
case graphicsMode.CLI:
bool dbg = true;
string data = String.Empty;
string cancelChar = "d";
Console.WriteLine( "Enter the names of the players. Press <ENTER> after every player. Type '{0}' when done.", cancelChar );
do
{
data = Console.ReadLine();
if( ( data.Equals( cancelChar, StringComparison.OrdinalIgnoreCase ) || data.Equals( String.Empty ) ) && toReturn.Count == 0 )
{
Console.WriteLine( "You must enter at least 1 valid player name." );
data = cancelChar + "crap";
}
else if( !data.Equals( cancelChar, StringComparison.OrdinalIgnoreCase ) && !data.Equals( String.Empty ) )
{
toReturn.Add( new Player( data, "" ) );
Console.WriteLine( "{0} has joined the game!", data );
Console.WriteLine();
}
//bool a = !data.Equals( String.Empty );
bool b = !data.Equals( cancelChar, StringComparison.OrdinalIgnoreCase );
bool c = toReturn.Count <= 5;
dbg = b & c;
}
while( dbg );
break;
}
return toReturn;
}
private void StartSingle()
{
//_thisData.NetworkStatus = EnumNetworkStatus.SinglePlayer;
_data.MultiPlayer = false;
_playerList = new PlayerCollection <P>();
}
public override void DisplayPlayerOrder( PlayerCollection order )
{
switch( this.Mode )
{
case graphicsMode.CLI:
Console.Write( "Turn order is: " );
foreach( Player p in order )
{
Console.Write( p.Name + ", " );
}
Console.WriteLine();
break;
}
}
public override void BeforeStart()
{
base.BeforeStart();
Players = new PlayerCollection();
Manager = new ResearchManager(this);
}
public Game(int numHumanPlayers, IEnumerable<String> playerNames, IEnumerable<Type> aiTypes, GameSettings settings)
{
this.State = GameState.Setup;
this.Settings = settings;
_Players = new PlayerCollection();
// Add human players
for (int i = 0; i < numHumanPlayers; i++)
_Players.Add(new Players.Human(this, playerNames.ElementAt(i)));
// Add AI players
for (int i = numHumanPlayers; i < playerNames.Count(); i++)
try
{
_Players.Add((Player)aiTypes.ElementAt(i).GetConstructor(new Type[] { typeof(Game), typeof(String) }).Invoke(new Object[] { this, playerNames.ElementAt(i) }));
}
catch (TargetInvocationException tie)
{
if (tie.InnerException != null)
throw tie.InnerException;
}
_Players.Setup(this);
Utilities.Shuffler.Shuffle<Player>(_Players);
if (playerNames.Count() > 4)
_EndgameSupplies = 4;
this.State = GameState.CardSelection;
}
public PlayerCollection PlayersWithHighestStrength( PlayerCollection PlayersToCheck )
{
PlayerCollection toReturn = new PlayerCollection();
toReturn.Add( PlayersToCheck[0] );
for( int i = 1; i < PlayersToCheck.Count; i++ )
{
if( PlayersToCheck[i].TotalStrength > toReturn[0].TotalStrength )
{
toReturn.Clear();
toReturn.Add( PlayersToCheck[i] );
}
else if( PlayersToCheck[i].NumBuildings == toReturn[0].NumBuildings )
{
toReturn.Add( PlayersToCheck[i] );
}
else
{
} // do nothing
}
return toReturn;
}
public void Load(String filename)
{
if (this.State != GameState.Unknown)
return;
//try
//{
XmlDocument xdGame = new XmlDocument();
xdGame.LoadXml(Utilities.StringUtility.Decrypt(Utilities.StringUtility.Unzip(System.IO.File.ReadAllBytes(filename))));
//xdGame.Load("gamedump.xml");
XmlNode xn = xdGame.SelectSingleNode("game/rng");
if (xn != null)
{
MemoryStream msRandom = new MemoryStream(Convert.FromBase64String(xn.InnerText));
BinaryFormatter bf = new BinaryFormatter();
this.RNG = (Random)bf.Deserialize(msRandom);
msRandom.Close();
}
xn = xdGame.SelectSingleNode("game/start_time");
if (xn != null)
this.StartTime = DateTime.Parse(xn.InnerText);
this.State = GameState.Setup;
xn = xdGame.SelectSingleNode("game/settings/GameSettings");
if (xn != null)
{
Cards.CardCollection allCards = Cards.CardCollection.GetAllCards(c => true);
XmlSerializer myDeserializer = new XmlSerializer(typeof(GameSettings), GetAllSerializingTypes(allCards).ToArray());
using (StringReader sr = new StringReader(xn.OuterXml))
{
this.Settings = (GameSettings)myDeserializer.Deserialize(sr);
}
}
_Table = new Table(this);
XmlNodeList xnl = xdGame.SelectNodes("game/players/player");
this._Players = new PlayerCollection();
foreach (XmlNode xnPlayer in xnl)
{
Player player = Player.Load(this, xnPlayer);
this._Players.Add(player);
this.Table.AddPlayer(player);
}
xn = xdGame.SelectSingleNode("game/table");
if (xn == null)
return;
this.Table.Load(xn);
this._Players.Setup(this);
xn = xdGame.SelectSingleNode("game/state");
if (xn != null)
this.State = (GameState)Enum.Parse(typeof(GameState), xn.InnerText, true);
this.TurnsTaken.Load(this, xdGame.SelectSingleNode("game/turns"));
xn = xdGame.SelectSingleNode("game/activeplayer");
if (xn != null && !String.IsNullOrEmpty(xn.InnerText))
{
this.ActivePlayer = this.Players.FirstOrDefault(p => p.UniqueId == new Guid(xn.InnerText));
this.ActivePlayer.SetCurrentTurn(this.TurnsTaken.Last());
}
//}
//catch (Exception ex)
//{
// throw ex;
//}
}
public PlayerCollection PlayersWithLowestBuildingCount( PlayerCollection PlayersToCheck )
{
PlayerCollection toReturn = new PlayerCollection();
toReturn.Add( PlayersToCheck[0] );
for( int i = 1; /* skipping the first player in the list */ i < PlayersToCheck.Count; i++ )
{
if( PlayersToCheck[i].NumBuildings < toReturn[0].NumBuildings )
{
toReturn.Clear();
toReturn.Add( PlayersToCheck[i] );
}
else if( PlayersToCheck[i].NumBuildings == toReturn[0].NumBuildings )
{
toReturn.Add( PlayersToCheck[i] );
}
else
{
} // do nothing
}
return toReturn;
}
public PlayerCollection PlayersWithLowestGoodsCount( PlayerCollection PlayersToCheck )
{
PlayerCollection toReturn = new PlayerCollection();
toReturn.Add( PlayersToCheck[0] );
for( int i = 1; /* skipping the first player in the list */ i < PlayersToCheck.Count; i++ )
{
if( PlayersToCheck[i].GoodsCount < toReturn[0].GoodsCount )
{
toReturn.Clear();
toReturn.Add( PlayersToCheck[i] );
}
else if( PlayersToCheck[i].GoodsCount == toReturn[0].GoodsCount )
{
toReturn.Add( PlayersToCheck[i] );
}
else // do nothing
{
}
}
return toReturn;
}
/// <summary>
/// Attempts to save the file.
/// </summary>
/// <param name="fileName">Name of the file to save</param>
public void Save(PlayerCollection pc, string fileName)
{
byte[] data = Encode(pc);
File.WriteAllBytes(fileName, data);
}
/// <summary>
/// Updates the list of client names in the window
/// </summary>
/// <param name="players">The list of players to add</param>
public void UpdateClientList(List<Player> players)
{
if (this.InvokeRequired)
{
PlayerListCallback d = UpdateClientList;
Invoke(d, new List<Player>[] { players });
}
else
{
if (dgvPlayers.DataSource == null)
dgvPlayers.DataSource = pc;
// Try to keep the same selection on update
string selected = null;
if (pc.Count > 0 && dgvPlayers.SelectedRows.Count > 0)
{
selected = (from DataGridViewRow row in dgvPlayers.Rows where row.Selected select pc[row.Index]).First().name;
}
// Update the data source and control
//dgvPlayers.SuspendLayout();
pc = new PlayerCollection(new PlayerListView());
Player.players.ForEach(p => pc.Add(p));
//dgvPlayers.Invalidate();
dgvPlayers.DataSource = pc;
// Reselect player
if (selected != null)
{
for (int i = 0; i < Player.players.Count; i++)
for (int j = 0; j < dgvPlayers.Rows.Count; j++)
if (String.Equals(dgvPlayers.Rows[j].Cells[0].Value, selected))
dgvPlayers.Rows[j].Selected = true;
}
dgvPlayers.Refresh();
//dgvPlayers.ResumeLayout();
}
}
public void LoadLists <P>(PlayerCollection <P> thisList) where P : class, IPlayerItem, new()
{
int x = 0;
int y;
GridHelper.AddAutoRows(_mainGrid !, thisList.Count());
co.TrueFalseConverter thisT = null !;
co.CurrencyConverter thisC = null !;
if (_rowList.Any(Items => Items.UseTrueFalseConverter == true))
{
thisT = new co.TrueFalseConverter();
thisT.UseAbb = UseAbbreviationForTrueFalse;
}
if (_rowList.Any(Items => Items.UseCurrencyConverter == true))
{
thisC = new co.CurrencyConverter();
}
foreach (var thisItem in thisList)
{
x += 1;
y = 0;
foreach (var thisBind in _rowList !)
{
Label thisLabel = new Label();
thisLabel.BindingContext = thisItem;
thisLabel.TextColor = Color.Aqua;
if (thisBind.UseTrueFalseConverter == true)
{
Binding tss = new Binding(thisBind.MainPath);
tss.Converter = thisT;
thisLabel.SetBinding(Label.TextProperty, tss);
}
else if (thisBind.UseCurrencyConverter == true)
{
Binding css = new Binding(thisBind.MainPath);
css.Converter = thisC;
thisLabel.SetBinding(Label.TextProperty, css);
}
else
{
thisLabel.SetBinding(Label.TextProperty, new Binding(thisBind.MainPath));
}
if (thisBind.VisiblePath != "")
{
Binding otherBind = new Binding(thisBind.VisiblePath);
thisLabel.SetBinding(IsVisibleProperty, otherBind);
}
if (thisBind.RightMargin > 0)
{
thisLabel.Margin = new Thickness(0, 0, thisBind.RightMargin, 0);
}
else
{
thisLabel.HorizontalOptions = LayoutOptions.Start;
thisLabel.HorizontalTextAlignment = TextAlignment.Start;
}
GridHelper.AddControlToGrid(_mainGrid !, thisLabel, x, y);
y += 1;
}
}
}
