public string ToStringOldCamelUpFormat()
{
//White2->Y Yellow2 Blue3->O Orange3 Green4
//;;wy;bo;g
string retval = string.Empty;
if (GetUnrolledCamelByRank().Length == 0)
{
int caseIndex = 0;
for (int i = 0; i < BoardState.Length; i++)
{
if (BoardState[i] == GameRules.CASE_SEPARATOR)
{
caseIndex++;
}
else if (GameRules.IsCharIdentityCamel(BoardState[i]))
{
retval += GameRules.FullNameCamel(BoardState[i]) + caseIndex;
if (BoardState.Length - 1 > i && GameRules.IsCharIdentityCamel(BoardState[i + 1]))
{
retval += "->" + Char.ToUpper(BoardState[i + 1]) + " ";
}
retval += " ";
}
}
}
foreach (BoardDebug suBoard in m_SubBoard)
{
retval += suBoard.ToStringOldCamelUpFormat();
}
return(retval + "\t");
}
private Pattern PopulatePatternDict(string aParttern)
{
Pattern newPattern = GeneratePatternData(aParttern);
if (m_Patterns.ContainsKey(newPattern.Id))
{
GameRules.Log(newPattern.Id + " " + aParttern);
}
m_Patterns.Add(newPattern.Id, newPattern);
for (int i = 0; i < newPattern.ResultsInList.Count; i++)
{
List <string> formatedResults = GameRules.PatternResultToPattern(newPattern.ResultsInList[i]);
foreach (string formatedResult in formatedResults)
{
if (!m_Patterns.ContainsKey(formatedResult) && !m_PatternsToDiscover.Contains(formatedResult))
{
m_PatternsToDiscover.Add(formatedResult);
}
}
}
return(newPattern);
}
//todo find another place
public static List <string> PatternResultToPattern(string result)
{
List <string> retval = new List <string>();
CamelsMovement camelsMovement = new CamelsMovement(result);
string holePattern = camelsMovement.StartingCamelsInBoard;
//Before Camel A
while (!GameRules.IsCharPatternCamel(holePattern.Substring(1, 1)))
{
holePattern = holePattern.Substring(1, holePattern.Length - 1);
}
//BetweenCamel
int camelNb = 0;
int caseSinceLastCamel = 0;
int nbCamelsOnLastPile = 1;
bool isCamelSameCase = false;
for (int i = 0; i < holePattern.Length; i++)
{
if (holePattern[i] == GameRules.CASE_SEPARATOR)
{
caseSinceLastCamel++;
isCamelSameCase = false;
}
else if (holePattern[i] != GameRules.TRAP_MINUS && holePattern[i] != GameRules.TRAP_PLUS)
{
if (IsCamelsAreTooFar(nbCamelsOnLastPile, caseSinceLastCamel))
{
retval.Add(holePattern.Substring(0, i - caseSinceLastCamel));
holePattern = holePattern.Substring(i - 1, holePattern.Length - i + 1);
i = 1;
camelNb = 0;
}
if (!isCamelSameCase)
{
isCamelSameCase = true;
nbCamelsOnLastPile = 0;
}
nbCamelsOnLastPile++;
//Override Camel
StringBuilder sb = new StringBuilder(holePattern);
sb[i] = GameRules.PATTERN_CAMEL_NAME[camelNb++];
holePattern = sb.ToString();
caseSinceLastCamel = 0;
}
else
{
//TODO BUG ICI mauvais pattern ;A;+;+ -> ;A; pas sur si cest la bonne solution
caseSinceLastCamel = 0;
}
}
retval.Add(holePattern);
return(retval);
}
private byte[] GetCamelsNeighbouring(byte aCamel)
{
if (!m_Neighbouring.ContainsKey(aCamel))
{
List <byte> camels = new List <byte>();
List <byte[]> splittedBoard = SplitBoardByCase();
for (int i = 0; i < splittedBoard.Count; i++)
{
if (!GameRules.IsByteIdentityCamel(splittedBoard[i][0]))
{
continue;
}
if (IsByteArrayContainByte(splittedBoard[i], aCamel))
{
camels.AddRange(splittedBoard[i]);
continue;
}
int rolledCamelPos = GetCamelPos(aCamel);
int nbCaseBetweenSplittedAndRolledCamel = rolledCamelPos - GetCamelPos(splittedBoard[i][0]);
if (nbCaseBetweenSplittedAndRolledCamel > 0)
{
if (!GameRules.IsCamelsAreTooFar(splittedBoard[i].Length, nbCaseBetweenSplittedAndRolledCamel))
{
camels.AddRange(splittedBoard[i]);
}
else
{
camels = new List <byte>();
}
}
else
{
int lastSplitPos = Math.Abs(GetCamelPos(splittedBoard[i - 1][0]));
int currentSplitPos = Math.Abs(GetCamelPos(splittedBoard[i][0]));
if (!GameRules.IsCamelsAreTooFar(splittedBoard[i - 1].Length, currentSplitPos - lastSplitPos))
{
camels.AddRange(splittedBoard[i]);
}
else
{
break;
}
}
}
foreach (byte camel in camels)
{
m_Neighbouring.Add(camel, camels.ToArray());
}
}
return(m_Neighbouring[aCamel]);
}
private void CheckCamelLandOnAnotherCamel(Camel aCamel, bool aFromMinusTrap)
{
if (!aFromMinusTrap)
{
for (int i = 0; i < m_Camels.Count; i++)
{
if (m_Camels[i] != aCamel &&
m_Camels[i].Pos == aCamel.Pos &&
m_Camels[i].CamelOnTop == null)
{
m_Camels[i].CamelOnTop = aCamel;
}
}
}
else
{
//TODO faire des tests
string camelsOnTop = aCamel.Id.ToString();
string camelsOnPos = string.Empty;
List <Camel> orderedStartingCamel = SortCamelInOrderPos(m_Camels);
Camel tempCamel = aCamel.CamelOnTop;
while (tempCamel != null)
{
camelsOnTop += tempCamel.Id;
tempCamel = tempCamel.CamelOnTop;
}
foreach (Camel camel in orderedStartingCamel)
{
if (!camelsOnTop.Contains(camel.Id.ToString()) &&
camel.Pos == aCamel.Pos &&
!GetCurrentCamel(camel.Id).IsMoving)
{
camelsOnPos += camel.Id;
}
}
if (!string.IsNullOrEmpty(camelsOnPos))
{
Camel toppestCamel = aCamel;
while (toppestCamel.CamelOnTop != null)
{
toppestCamel = toppestCamel.CamelOnTop;
}
toppestCamel.CamelOnTop = GetCurrentCamel(camelsOnPos[camelsOnPos.Length - 1]);
if (aCamel.CamelOnTop == null || aCamel.CamelOnTop == aCamel)
{
GameRules.Log("Peut etre un bug....");
}
}
}
}
private void CamelInfo(List <Camel> aCamels, string aPreLog)
{
string log = aPreLog + '\n';
foreach (Camel camel in aCamels)
{
log += string.Format("{0}: {1} -> {2} {3}", camel.Id, camel.Pos, camel.CamelOnTop == null ? "null": camel.CamelOnTop.Id.ToString(), '\n');
}
GameRules.Log(log);
}
private Ev GenerateShortTermCardEv()
{
var highestCamelEv = m_CamelRankManager.GetHighestEv(m_CamelCards);
Ev retval = new Ev
{
m_PlayerAction = GameRules.PlayerAction.PickShortTermCard,
m_Ev = highestCamelEv.Item2,
m_Info = GameRules.FullNameCamel(highestCamelEv.Item1)
};
return(retval);
}
public float EVShortTerm(int aCardNb)
{
float retval = 0;
for (int i = 0; i < m_TimeFinish.Length; i++)
{
float rankPercentFinish = GetProportionByPosition(i);
retval += rankPercentFinish * GameRules.GetRankPrice(i, aCardNb);
}
return(retval);
}
public string GetRankString()
{
byte[] rankByte = GetRank();
string retval = string.Empty;
foreach (var rank in rankByte)
{
retval += GameRules.ByteToString(rank);
}
return(retval);
}
private bool IsCamelRolled(byte aCamel)
{
byte UnrollCamel = GameRules.ByteUnrollToRoll(aCamel);
foreach (var aByte in BoardState)
{
if (aByte == UnrollCamel)
{
return(true);
}
}
return(false);
}
private int GetNbCamelInPattern(string aPattern)
{
int nbOfCamelInPattern = 0;
foreach (char pattern in aPattern)
{
if (GameRules.IsCharPatternCamel(pattern))
{
nbOfCamelInPattern++;
}
}
return(nbOfCamelInPattern);
}
private List <Camel> SortCamelInOrderPos(List <Camel> aCamel)
{
List <Camel> newList = new List <Camel>();
List <Camel> remainingCamels = (List <Camel>)Extensions.Clone(aCamel);
for (int j = 0; j < aCamel.Count; j++)
{
char tempCamelName = 'x';
Camel higherCamel = new Camel(tempCamelName, -1, null);
foreach (Camel currentCamel in remainingCamels)
{
if (newList.Count > 0 && currentCamel.CamelOnTop != null && currentCamel.CamelOnTop.Id == newList[newList.Count - 1].Id)
{
//prend le camelOnTop du dernier camel entrer
higherCamel = currentCamel;
break;
}
else
{
//Prend le plus grosse pos + sans camel on top
if (currentCamel.CamelOnTop == null && currentCamel.Pos > higherCamel.Pos)
{
higherCamel = currentCamel;
}
}
}
for (int k = 0; k < remainingCamels.Count; k++)
{
if (remainingCamels[k].Id == higherCamel.Id)
{
remainingCamels.Remove(remainingCamels[k]);
}
}
if (higherCamel.Id == tempCamelName)
{
GameRules.Log("Didnt find higherCamel");
}
newList.Add(higherCamel);
}
if (remainingCamels.Count != 0)
{
GameRules.Log("We miss a Camel");
}
return(newList);
}
public string ToString(Dictionary <char, int> aCamelCards)
{
string retval = String.Empty;
foreach (var camelRank in m_CamelRanks)
{
char camel = char.ToUpper(camelRank.Key);
int cardNb = aCamelCards.ContainsKey(camel) ? aCamelCards[camel] : 0;
retval += string.Format("{0} {1} \tCarteST: {2} \n", camelRank.Value.EVShortTerm(cardNb).ToString("N2"), camelRank,
GameRules.GetRankPrice(0, cardNb));
}
return(retval);
}
public string GetRank()
{
if (string.IsNullOrWhiteSpace(m_Rank))
{
foreach (char token in BoardState)
{
if (GameRules.IsCharIdentityCamel(token))
{
m_Rank += token;
}
}
}
return(m_Rank);
}
private bool IsCamelLandEmptyCase(byte aCamel)
{
byte[] rank = GetRank();
aCamel = GameRules.ByteRollToUnroll(aCamel);
for (int i = 1; i < rank.Length; i++)
{
if (GameRules.ByteRollToUnroll(rank[i]) == aCamel)
{
return(GetCamelPos(aCamel) != GetCamelPos(rank[i - 1]));
}
}
return(true);
}
private byte[] GetUnrolledCamelByRank()
{
List <byte> retvalList = new List <byte>();
foreach (byte token in BoardState)
{
if (GameRules.IsByteIdentityCamelUnrolled(token))
{
retvalList.Add(token);
}
}
return(retvalList.ToArray());
}
private void SetAllCamelUnroll()
{
StringBuilder tempBoard = new StringBuilder(BoardState);
for (int i = 0; i < tempBoard.Length; i++)
{
if (GameRules.IsCharIdentityCamel(tempBoard[i]))
{
tempBoard[i] = Char.ToUpper(tempBoard[i]);
}
}
BoardState = tempBoard.ToString();
}
public string GetUnrolledCamelByRank()
{
string retval = string.Empty;
foreach (char token in BoardState)
{
if (GameRules.IsCharIdentityCamel(token) &&
Char.IsUpper(token))
{
retval += token;
}
}
return(retval);
}
public BoardByte(string aBoardId)
{
m_SubBoard = new List <IBoard>();
BoardState = GameRules.StringToByte(aBoardId);
CasesLandedOn = new int[GameRules.CASE_NUMBER];
Weight = 1;
m_DicesHistoriesByte.Add(new List <byte>());
PopulateNeighbouring();
if (!GameRules.USE_DICE_NB_IN_DICE_HSITORY)
{
PopulateSubBoard();
}
}
public Ev GetEv()
{
Dictionary <char, double[]> camelRanks = GetAverageCamelRankInfo();
Tuple <char, double> highestEvFirstPlace = new Tuple <char, double>('x', -10f);
Tuple <char, double> highestEvLastPlace = new Tuple <char, double>('x', -10f);
foreach (var cr in camelRanks)
{
double ev = LongTermCardGuesser.Instance.GetPriceForFirst(cr.Key) * cr.Value[0];
if (ev > highestEvFirstPlace.Item2)
{
highestEvFirstPlace = new Tuple <char, double>(cr.Key, ev);
}
ev = LongTermCardGuesser.Instance.GetPriceForLast(cr.Key) * cr.Value[4]; //todo magic number
if (ev > highestEvLastPlace.Item2)
{
highestEvLastPlace = new Tuple <char, double>(cr.Key, ev);
}
}
Tuple <char, double> highest;
bool isFirst;
if (highestEvFirstPlace.Item2 > highestEvLastPlace.Item2)
{
highest = highestEvFirstPlace;
isFirst = true;
}
else
{
highest = highestEvLastPlace;
isFirst = false;
}
string info = String.Format("{0} cards pour le {1}, avec une proportion de {2}",
isFirst? "First" : "Last", GameRules.FullNameCamel(highest.Item1), GetTotalProportionAllRankManagers);
Ev retval = new Ev
{
m_PlayerAction = GameRules.PlayerAction.PickLongTermCard,
m_Ev = (float)highest.Item2,
m_Info = info
};
return(retval);
}
public void PopulateSubBoard()
{
if (IsCamelReachEnd)
{
return;
}
byte[] unRollCamel = GetUnrolledCamelByRank();
if (unRollCamel.Length == 0)
{
SetAllCamelUnroll();
unRollCamel = GetUnrolledCamelByRank();
}
List <Pattern> patterns = ToPattern();
// i = pattern
// j = movingCamel in pattern
// k = result
foreach (Pattern pattern in patterns)
{
string unrolledCamels = string.Empty;
for (int j = 0; j < pattern.NbCamel && j < unRollCamel.Length; j++)
{
byte unrollCamel = unRollCamel[j];
if (!pattern.CamelsIdentity.ToUpper().Contains(GameRules.ByteToString(unrollCamel).ToString().ToUpper()))
{
continue;
}
List <string> results = pattern.GetResultsForDice(GameRules.ByteToString(unrollCamel));
unrolledCamels += GameRules.ByteToString(unRollCamel[j]);
for (int k = 0; k < results.Count; k++)
{
CreateSubboard(results[k], unrollCamel, k + 1);
}
}
foreach (char unrollCamel in unrolledCamels)
{
unRollCamel = RemoveByteFromBytesArray(unRollCamel, GameRules.StringToByte(unrollCamel));
}
unrolledCamels = string.Empty;
}
}
public void Save(List <Pattern> aPatterns, bool aAppend)
{
string save = string.Empty;
foreach (var pattern in aPatterns)
{
save += pattern.ToString() + '\n';
}
string path = CompletePath;
GameRules.Log(path);
TextWriter tw = new StreamWriter(path, aAppend);
tw.WriteLine(save);
tw.Close();
}
//METHOD
public LongTermBoardAnalyser(IBoard aBoard, Action aActionAfterManageBoard)
{
//TODO supporter plusieurs board...il y a un bug quand on ajoute boards avec 2 dés roulés
m_MaxDicesRoll = m_FinishBoard.Values.SelectMany(fb => fb.DicesHistories).Aggregate("", (max, cur) => max.Length > cur.Length ? max : cur).Length;
ManageBoards(new List <IBoard> {
aBoard
});
if (aActionAfterManageBoard != null)
{
aActionAfterManageBoard.Invoke();
}
if (m_FinishBoard.Values.Any())
{
AddCamelRankManager(m_FinishBoard.Values.ToList());
m_FinishBoard.Clear();
}
while (m_UncompleteBoards.Any() && IsContinueAnalyze())
{
try
{
CreateBoards();
}
catch (Exception ex)
{
m_IsMemoryFail = true;
}
if (m_FinishBoard.Values.Any())
{
AddCamelRankManager(m_FinishBoard.Values.ToList());
m_FinishBoard.Clear();
}
if (m_IsMemoryFail)
{
GameRules.Log(string.Format("\n\n Je fail at: {0} avec {1} UncompleteBoards \n\n", GetTotalProportionAllRankManagers, m_UncompleteBoards.Count));
}
m_UncompleteBoards = new Dictionary <string, IBoard>(m_UnfinishBoard);
m_UnfinishBoard.Clear();
m_MaxDicesRoll++;
}
}
private void SetAllCamelUnroll()
{
byte[] tempBoard = new byte[BoardState.Length];
for (int i = 0; i < tempBoard.Length; i++)
{
if (GameRules.IsByteIdentityCamel(BoardState[i]))
{
tempBoard[i] = GameRules.ByteRollToUnroll(BoardState[i]);
}
else
{
tempBoard[i] = BoardState[i];
}
}
BoardState = tempBoard;
}
private void CalculateWeightAndCasesLandedOn()
{
foreach (var board in m_Boards)
{
if (board.m_SubBoard.Count == 0)
{
m_TotalSubBoardWithWeight += board.Weight;
for (int j = 0; j < board.CasesLandedOn.Length; j++)
{
m_CasesLandedOn[j] += board.CasesLandedOn[j] * board.Weight;
}
}
else
{
GameRules.Log("");
}
}
}
private int GetCamelPos(byte aRolledCamel)
{
if (!m_Position.ContainsKey(aRolledCamel))
{
int retval = 0;
foreach (byte token in BoardState)
{
if (GameRules.IsByteIdentityCamel(token) && GameRules.ByteRollToUnroll(token) == GameRules.ByteRollToUnroll(aRolledCamel))
{
m_Position.Add(aRolledCamel, retval);
}
else if (token == GameRules.CASE_SEPARATOR_BYTE)
{
retval++;
}
}
}
return(m_Position[aRolledCamel]);
}
private char CamelToPattern(char aCamel)
{
int camelIndex = 0;
foreach (char token in BoardState)
{
char upperChar = char.ToUpper(token);
if (upperChar == char.ToUpper(aCamel))
{
break;
}
else if (GameRules.IsCharIdentityCamel(upperChar))
{
camelIndex++;
}
}
return(GameRules.PATTERN_CAMEL_NAME[camelIndex]);
}
private char CamelIdentityToPattern(char aIdentity)
{
int idIndex = CamelsIdentity.ToUpper().IndexOf(char.ToUpper(aIdentity));
int patternIndex = 0;
foreach (char t in Id)
{
if (GameRules.IsCharPatternCamel(t))
{
if (idIndex == patternIndex)
{
return(t);
}
patternIndex++;
}
}
return('0');
}
public byte[] GetRank()
{
if (m_Rank == null)
{
List <byte> tempByte = new List <byte>();
foreach (byte token in BoardState)
{
if (GameRules.IsByteIdentityCamel(token))
{
tempByte.Add(token);
}
}
m_Rank = new byte[tempByte.Count];
for (int i = 0; i < m_Rank.Length; i++)
{
m_Rank[i] = tempByte[i];
}
}
return(m_Rank);
}
private List <Pattern> ToPattern()
{
string board = string.Empty;
int camelIndex = 0;
foreach (byte token in BoardState)
{
if (GameRules.IsByteIdentityCamel(token))
{
board += GameRules.PATTERN_CAMEL_NAME[camelIndex++];
}
else
{
board += GameRules.ByteToString(token);
}
}
List <string> patterns = GameRules.PatternResultToPattern(board);
List <Pattern> retval = new List <Pattern>();
byte[] camels = GetRank();
int camelsIndex = 0;
foreach (string pattern in patterns)
{
if (!PatternGenerator.Instance.Patterns.ContainsKey(pattern))
{
PatternGenerator.Instance.StartGeneratePattern(pattern);
}
byte[] camelIdentity = SubByteArray(camels, camelsIndex, PatternGenerator.Instance.Patterns[pattern].NbCamel);
Pattern newPattern = new Pattern(PatternGenerator.Instance.Patterns[pattern], camelIdentity);
camelsIndex += newPattern.NbCamel;
retval.Add(newPattern);
}
return(retval);
}
