public TriadDeckInstanceManual(TriadDeckInstanceManual copyFrom)
{
deck = copyFrom.deck;
numUnknownPlaced = copyFrom.numUnknownPlaced;
numPlaced = copyFrom.numPlaced;
availableCardMask = copyFrom.availableCardMask;
}
// special logic, covered by GUI
public static void StaticSwapCards(TriadGameData gameData, TriadCard swapFromBlue, int blueSlotIdx, TriadCard swapFromRed, int redSlotIdx)
{
// implement this rule only for manual mode, screen captures get everything automatically
TriadDeckInstanceManual deckBlueEx = gameData.deckBlue as TriadDeckInstanceManual;
TriadDeckInstanceManual deckRedEx = gameData.deckRed as TriadDeckInstanceManual;
if (deckBlueEx != null && deckRedEx != null)
{
bool bIsRedFromKnown = redSlotIdx < deckRedEx.deck.knownCards.Count;
if (gameData.bDebugRules)
{
TriadGameModifierSwap DummyOb = new TriadGameModifierSwap();
Logger.WriteLine(">> " + DummyOb.RuleName + "! blue[" + blueSlotIdx + "]:" + swapFromBlue.Name +
" <-> red[" + redSlotIdx + (bIsRedFromKnown ? "" : ":Opt") + "]:" + swapFromRed.Name);
}
TriadDeck blueDeckSwapped = new TriadDeck(deckBlueEx.deck.knownCards, deckBlueEx.deck.unknownCardPool);
TriadDeck redDeckSwapped = new TriadDeck(deckRedEx.deck.knownCards, deckRedEx.deck.unknownCardPool);
// ignore order in red deck
redDeckSwapped.knownCards.Add(swapFromBlue);
redDeckSwapped.knownCards.Remove(swapFromRed);
redDeckSwapped.unknownCardPool.Remove(swapFromRed);
// preserve order in blue deck
blueDeckSwapped.knownCards[blueSlotIdx] = swapFromRed;
gameData.deckBlue = new TriadDeckInstanceManual(blueDeckSwapped);
gameData.deckRed = new TriadDeckInstanceManual(redDeckSwapped);
}
}
// shared with three open
public static void StaticMakeKnown(TriadGameData gameData, List <int> redIndices)
{
const int deckSize = 5;
TriadDeckInstanceManual deckRedEx = gameData.deckRed as TriadDeckInstanceManual;
if (deckRedEx != null && redIndices.Count <= deckSize)
{
if (gameData.bDebugRules)
{
Logger.WriteLine(">> Open:{0}! red indices:{1}", redIndices.Count, string.Join(", ", redIndices));
}
TriadDeck redDeckVisible = new TriadDeck(deckRedEx.deck.knownCards, deckRedEx.deck.unknownCardPool);
for (int idx = 0; idx < redIndices.Count; idx++)
{
int cardIdx = redIndices[idx];
if (cardIdx < deckRedEx.deck.knownCards.Count)
{
// already known, ignore
}
else
{
int idxU = cardIdx - deckRedEx.deck.knownCards.Count;
var cardOb = deckRedEx.deck.unknownCardPool[idxU];
redDeckVisible.knownCards.Add(cardOb);
redDeckVisible.unknownCardPool.Remove(cardOb);
}
}
// safety for impossible state
for (int idx = 0; (idx < redDeckVisible.knownCards.Count) && (redDeckVisible.knownCards.Count > deckSize); idx++)
{
var cardOb = redDeckVisible.knownCards[idx];
int orgIdx = deckRedEx.GetCardIndex(cardOb);
if (!redIndices.Contains(orgIdx))
{
redDeckVisible.knownCards.RemoveAt(idx);
idx--;
}
}
gameData.deckRed = new TriadDeckInstanceManual(redDeckVisible);
}
}
public override TriadDeckInstance CreateCopy()
{
TriadDeckInstanceManual deckCopy = new TriadDeckInstanceManual(this);
return(deckCopy);
}
public override void OnAllCardsPlaced(TriadGameData gameData)
{
if (gameData.state == ETriadGameState.BlueDraw && gameData.numRestarts < 3)
{
// implement this rule only for manual mode, screen captures get everything automatically
TriadDeckInstanceManual deckBlueEx = gameData.deckBlue as TriadDeckInstanceManual;
TriadDeckInstanceManual deckRedEx = gameData.deckRed as TriadDeckInstanceManual;
if (deckBlueEx != null && deckRedEx != null)
{
List <TriadCard> blueCards = new List <TriadCard>();
List <TriadCard> redCards = new List <TriadCard>();
List <TriadCard> redUnknownCards = new List <TriadCard>();
string redCardsDebug = "";
for (int Idx = 0; Idx < gameData.board.Length; Idx++)
{
if (gameData.board[Idx].owner == ETriadCardOwner.Blue)
{
blueCards.Add(gameData.board[Idx].card);
}
else
{
redCards.Add(gameData.board[Idx].card);
}
gameData.board[Idx] = null;
}
if (deckBlueEx.numPlaced < deckRedEx.numPlaced)
{
// blue has cards on hand, all known
for (int Idx = 0; Idx < deckBlueEx.deck.knownCards.Count; Idx++)
{
bool bIsAvailable = !deckBlueEx.IsPlaced(Idx);
if (bIsAvailable)
{
blueCards.Add(deckBlueEx.deck.knownCards[Idx]);
break;
}
}
gameData.state = ETriadGameState.InProgressBlue;
}
else
{
// red has cards on hand, check known vs unknown
for (int Idx = 0; Idx < deckRedEx.deck.knownCards.Count; Idx++)
{
bool bIsAvailable = !deckRedEx.IsPlaced(Idx);
if (bIsAvailable)
{
redCards.Add(deckRedEx.deck.knownCards[Idx]);
redCardsDebug += deckRedEx.deck.knownCards[Idx].Name + ":K, ";
break;
}
}
if (redCards.Count < blueCards.Count)
{
for (int Idx = 0; Idx < deckRedEx.deck.unknownCardPool.Count; Idx++)
{
int cardIdx = Idx + deckRedEx.deck.knownCards.Count;
bool bIsAvailable = !deckRedEx.IsPlaced(cardIdx);
if (bIsAvailable)
{
redUnknownCards.Add(deckRedEx.deck.unknownCardPool[Idx]);
redCardsDebug += deckRedEx.deck.unknownCardPool[Idx].Name + ":U, ";
}
}
}
gameData.state = ETriadGameState.InProgressRed;
}
gameData.deckBlue = new TriadDeckInstanceManual(new TriadDeck(blueCards));
gameData.deckRed = new TriadDeckInstanceManual(new TriadDeck(redCards, redUnknownCards));
gameData.numCardsPlaced = 0;
gameData.numRestarts++;
for (int Idx = 0; Idx < gameData.typeMods.Length; Idx++)
{
gameData.typeMods[Idx] = 0;
}
if (gameData.bDebugRules)
{
redCardsDebug = (redCardsDebug.Length > 0) ? redCardsDebug.Remove(redCardsDebug.Length - 2, 2) : "(board only)";
ETriadCardOwner nextTurnOwner = (gameData.state == ETriadGameState.InProgressBlue) ? ETriadCardOwner.Blue : ETriadCardOwner.Red;
Logger.WriteLine(">> " + RuleName + "! next turn:" + nextTurnOwner + ", red:" + redCardsDebug);
}
}
}
}
