public static void ComputePrizes(BingoGameEvent game_event, BingoGame game, List <wininfo> winners) { foreach (wininfo winner in winners) { foreach (BingoPrize prize in winner.prize_levels) { int total = 0; foreach (wininfo winner_with_prize in winners) { if (winner == winner_with_prize) { continue; } foreach (BingoPrize winner2_prize in winner.prize_levels) { if (winner2_prize.level.Equals(prize.level)) { total++; break; } } } long change; long value = prize.amount / total; if ((change = value % 100) > 0) { value += 100; value -= change; } winner.amount += value; } } }
public BingoCardState(byte[, ,] CardData, BingoPlayer _Player, PlayerPack pack, int unit_card, int real_card, BingoGameEvent game) { this.card = CardData; this.player = _Player; this.pack = pack; this.unit_card_number = unit_card; this.cardset_card_number = real_card; this.game = game; }
public static BingoGameEvent Continue(BingoGameEvent prior_event, BingoGame new_game) { if (prior_event != null) { //this.game_event_row = game_event_data_table_row; prior_event.games.Add(new_game); } return(prior_event); }
// 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); }
// all cards in the session? the game lists should maintain this good enough? //public card_list playing_cards; /// <summary> /// This completes final initialization fo a bingo game state, including loading the cards for each player /// </summary> /// <param name="game_index">if game== null, index will be used to get the GameList entry at the index.</param> /// <param name="result">this is the partial state we're going to use...</param> /// <returns>result or NULL if fails</returns> public BingoGameState StepToUsing(int game_index, BingoGameState result, BallDataInterface bdi = null) { // setup a play state for an absolute game number... // get one game of all the ones defined in the bingo core state... lock (this.step_lock) { BingoGame game = null; result.game_needs_balls = false; // no games in state. if (session.GameList == null || session.GameList.Count == 0) { // return an early result (no process) return(result); } result.session_event = this; { { // if game is already set, no reason to use game_index if (result.game == null) { if (game_index >= session.GameList.Count) { Log.log("StepTo passed a game number beyond the current list."); return(result); // need to do a step of session. // setup some hotballs .... } // new session, played all players and all their cards game = session.GameList[game_index]; } else { game = result.game; } // should wait before running the NEXT game... // for that game to finish... while (game.playing) { Thread.SpinWait(1); } if (result.game == null) { // though at this point I should have result.session_event... and we should have // been progressing through that... // with events, I need to know the prior event .... // but the threaded nature of this makes this impossible... since we are // not really within a session container... it's really an observation of // game by game... if (prior_game_event != null && game.prior_game != null && game.into) { result.game_event = BingoGameEvent.Continue(prior_game_event, game); result.game_event_index = result.game_event.games.Count - 1; } else { result.game_event = new BingoGameEvent(game, bdi); prior_game_event = result.game_event; } string[] str = game.Name.Split('\t'); if (my_store_to_database) { game.ID = Local.bingo_tracking.OpenGame(game_index + 1, game.ballset_number, str[1]); //game.Name ); } if (game.number_colored > 0) { int[] newballs = new int[game.number_colored]; int n; for (n = 0; n < game.number_colored; n++) { newballs[n] = -1 - n; } result.game_event.balls.AddExtraBalls(newballs); } if (game.cashballs == 5) { byte[] card = result.game_event.card_factory.Create5Card(); result.game_event.playing_hotballs = new int[card.Length]; for (int n = 0; n < card.Length; n++) { result.game_event.playing_hotballs[n] = card[n]; } } else { result.game_event.playing_hotballs = result.game_event.balls.CallBalls(game.cashballs); } } } } result.bestwin = session.max_balls; // game.bestwin; // start at more than any level... // this is indexed with -1... soo [card, ball-1] == count away. result.winning_cards = new List <wininfo>(); // this resultset is the whole sess's cards? result.playing_cards = new List <BingoCardState>(); // playing_cards; result.playing_packs = new List <PlayerPack>(); result.valid = true; result.session_event = this; List <object> game_pack_set_ids = new List <object>(); if (opened) { if (my_store_to_database) //foreach( BingoGameGroup group in result.game.game_groups ) { game_pack_set_ids.Add(result.game.game_group.group_pack_set_id = Local.bingo_tracking.AddPackSetToGame(result.game.game_group.pack_set_id)); } } else { game_pack_set_ids.Add(Guid.Empty); } /* * if( _PlayerList != null ) * { * foreach( BingoPlayer player in _PlayerList ) * { * LoadPlayerCards( player, game_pack_set_ids, result ); * } * } */ // return this state so we can unlock it. // with these balls and cards referenced // we should not have a problem with multi-threading this. return(result); } }