public wininfo(int card_id, BingoCardState card)
{
this.ball_win_count = card.BallCount;
this.playing_card = card;
this.card_number = card.unit_card_number;
this.card_index = card_id;
this.mask = card.BestMask();
this.player = card.player;
this.pack = card.pack;
}
public BingoCardState Clone()
{
BingoCardState card = new BingoCardState(this.card);
card.player = player;
card.pack = pack;
card.unit_card_number = unit_card_number;
card.game = game;
card.pack_card_index = pack_card_index;
card.ID = ID; // Local.bingo_tracking.AddCard( game_group.group_pack_set_id, pack.ID, game.ballset_number, unit_card_number, this.card );
//card.ID = original.ID;
//card.
return(card);
}
// double action determines whether card[X,,] goes from 0-0 or 0-1 (triple action? 0-2?)
// check one card, get the best mask, and the best count_away
// return the number of balls in ball array it won on.
public static bool check_single_card(
BingoCardState card
, BingoGameEvent game_event
, int game_index
, int[] playing_balls
, int faces
, int columns
, int pattern_index
)
{
int mark_count = 0;
if (card.pack.pack_info.flags.big3)
{
card.CheckBig3(card.marks[0]);
}
else
{
//foreach( BingoGame game in game_event.games )
BingoGame game = game_event.games[game_index];
{
foreach (Pattern pattern in game.patterns)
{
BingoCardState.BingoCardPatternMarkInfo marks = card.GetCurrentMark(pattern_index);
switch (pattern.algorithm)
{
case PatternDescriptionTable.match_types.ExternalJavaEngine:
break;
default:
if (card.MarkNew(marks, faces, columns, playing_balls))
{
mark_count++;
}
break;
}
}
}
if (mark_count == 0)
{
return(false);
}
{
// get last marked cardmask
//foreach( BingoGame game in game_event.games )
{
if (game.patterns[0].algorithm == PatternDescriptionTable.match_types.CrazyMark)
{
return(card.CheckCrazy(card.marks[0], game.patterns[0].repeat_count));
}
else if (game.patterns[0].algorithm == PatternDescriptionTable.match_types.ExternalJavaEngine)
{
//return
}
else
{
List <int> patterns = game.pattern_list.pattern_bitmask_list;
//foreach ( int check_mask in patterns )
{
if (card.CheckPattern(card.marks[0], patterns))
{
card.WinningGame = game;
card.WinningGameEvent = game_event;
return(true);
}
} // end of foreach( pattern )
}
}
}
}
return(false);
}
/// <summary>
/// This literally loads the packs each player is playing into the bingo game state
/// </summary>
/// <param name="_Player"></param>
/// <param name="s"></param>
void LoadPlayerCards(BingoPlayer _Player, List <object> game_pack_set_ids, BingoGameState s)
{
int pack_number = 0;
BingoGameGroup game_group = s.game.game_group;
while (_Player._played_cards.Count <= game_group.game_group_ID)
{
_Player._played_cards.Add(new List <BingoCardState>());
}
List <BingoCardState> player_card_list = _Player._played_cards[game_group.game_group_ID];
// already loaded these cards?
if (player_card_list.Count > 0)
{
return;
}
//player_card_list.Clear();
//foreach( PlayerTransaction trans in _Player.transactions )
{
foreach (PlayerPack _pack in _Player.played_packs)
{
bool skip_pack = true;
if (_pack.pack_info.game_groups.Count > 0)
{
foreach (BingoGameGroup group in _pack.pack_info.game_groups)
{
if (group.Contains(s.game))
{
// this pack is in this game, load cards for it.
game_group = group;
skip_pack = false;
break;
}
}
if (skip_pack)
{
continue;
}
}
while (_pack.Cards.Count <= s.game.game_ID)
{
_pack.Cards.Add(new List <BingoCardState>());
}
pack_number++;
_pack.played = true;
int card_count = _pack.pack_info.count; // s.game.GetCardCount( _pack.pack_info );
if (_pack.pack_info.count == 0)
{
// pack does not play this game, skip it.
continue;
}
s.playing_packs.Add(_pack);
List <BingoCardState> game_cards = _pack.Cards[s.game.game_ID];
if (game_cards.Count < card_count)
{
if (_pack.dealer == null)
{
Log.log("Fatality, dealer not assigned on pack.");
continue;
}
int base_real_card = _pack.dealer.Add((_pack.start_card),
!_pack.paper
? s.game.ballset_number
: s.game.page_skip);
//if( base_real_card > 320000 )
{
// MessageBox.Show( "Card is out of range!" );
}
int col = 0;
int row = 0;
for (int card = 0; card < card_count; card++)
{
byte[, ,] card_faces;
row++;
if (row >= _pack.pack_info.rows)
{
col++;
row = 0;
}
//if( col == _pack.pack_info.
// dealer does a subtract 1, this is a 0 based physical card index.
if (base_real_card == 512301)
{
int a = 3;
}
int unit_card = _pack.dealer.GetNext(base_real_card, row, col, card);
int real_card = _pack.dealer.GetPhysicalNext(base_real_card, row, col, card);
if (_pack.dealer.card_data == null)
{
card_faces = new byte[1, 5, 5] {
{ { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 }, { 0, 0, 0, 0, 0 } }
};
}
else
{
if (_pack.pack_info.name == "Double Double" || _pack.pack_info.name == "Dual Daub")
{
int a = 3;
}
card_faces = _pack.dealer.card_data.Create(
real_card
, _pack.pack_info.flags.double_action ? 2 : 1
, _pack.pack_info.flags.starburst
);
}
BingoCardState cs = new BingoCardState(card_faces);
cs.player = _Player;
cs.pack = _pack;
//cs.prize_level_id = _pack.pack_info._dealer.prize_level_id;
cs.unit_card_number = unit_card;
cs.cardset_card_number = real_card;
cs.game = s.game_event;
game_cards.Add(cs);
cs.pack_card_index = game_cards.IndexOf(cs);
player_card_list.Add(cs);
s.playing_cards.Add(cs);
if (s.session_event.opened)
{
cs.ID = Local.bingo_tracking.AddCard(game_group.group_pack_set_id, _pack.ID, s.game.ballset_number, cs.unit_card_number, cs.CardData);
}
}
}
else
{
for (int card = 0; card < card_count; card++)
{
BingoCardState cs = _pack.Cards[s.game.game_ID][card];
s.playing_cards.Add(cs);
player_card_list.Add(cs);
if (s.session_event.opened)
{
cs.ID = Local.bingo_tracking.AddCard(null, _pack.ID, s.game.ballset_number, cs.unit_card_number, cs.CardData);
}
}
}
}
}
}
