Пример #1
0
        public void ReloadSessionGames(DataRow session)
        {
            if (schedule == null)
            {
                return;
            }

            // clear all my games.
            this.Clear();
            // hmm...
            {
                DataRow[] SessionGames = session.GetChildRows("session_has_game");

                if (SessionGames != null)
                {
                    foreach (DataRow session_game in SessionGames)
                    {
                        int game_number = Convert.ToInt32(session_game[SessionGame.NumberColumn]);
                        if (session_game.RowState == DataRowState.Deleted)
                        {
                            continue;
                        }
                        foreach (BingoGame test_game in this)
                        {
                            if (test_game.game_number == game_number)
                            {
                                test_game.Extend(this, session_game);
                                game_number = 0;
                                break;
                            }
                        }
                        if (game_number > 0)
                        {
                            BingoGame game = new BingoGame(this, session_game);
                            //new BingoGame( patterns.ToArray() );
                            Add(game);
                            game.game_list = this;
                            game.game_ID   = IndexOf(game);
                            DataRow[] games_game_groups = session_game.GetChildRows("session_game_has_session_pack_group");
                            foreach (DataRow game_game_group in games_game_groups)
                            {
                                DataRow session_pack_group = game_game_group.GetParentRow("session_pack_group_in_session_game");
                                DataRow pack_group_info    = session_pack_group.GetParentRow("pack_group_in_session");
                                //DataRow pack_group = session_pack_group.GetParentRow( "pack_group_in_session" );
                                BingoGameGroup bgg = this.game_group_list.GetGameGroup(pack_group_info);
                                bgg.Add(game);
                            }
                            game.session_game_id = session_game[SessionGame.PrimaryKey];
                        }
                    }
                }
            }
            if (pack_list == null)
            {
                pack_list = new BingoPacks(this, schedule, session);
            }
            UpdateCardCounts();
        }
Пример #2
0
        /// <summary>
        /// Create a new BingoPack from a PackTable datarow
        /// </summary>
        /// <param name="dataRow">A row from PackTable</param>
        public BingoPack(BingoGameGroup game_group, DataRow dataRow)
        {
            if (dataRow != null)
            {
                this.schedule_row = dataRow;
                ScheduleDataSet schedule = dataRow.Table.DataSet as ScheduleDataSet;

                if (game_group != null)
                {
                    this.game_groups.Add(game_group);
                    this.cols  = Convert.ToInt32(dataRow["width"]);
                    this.rows  = Convert.ToInt32(dataRow["height"]);
                    this.count = cols * rows;
                    this.name  = dataRow[PackTable.NameColumn].ToString();
                }

                if (schedule != null)
                {
                    DataRow[]      possible_game_group_prize = dataRow.GetChildRows("pack_has_prize_level");
                    List <DataRow> game_group_prize          = new List <DataRow>();
                    foreach (DataRow prize in possible_game_group_prize)
                    {
                        this.prize_levels.Add(game_group.GetPrize(prize[PrizeLevelNames.PrimaryKey]));
                    }
                }
                this.ID = dataRow[PackTable.PrimaryKey];
                if (count == 0)
                {
                    Log.log("Pack " + dataRow[PackTable.NameColumn] + " has 0 faces defined by length and strips(rows,cols:height,width).");
                }

                object tmp = dataRow["_3_number"];
                if (tmp == DBNull.Value)
                {
                    flags.big3 = false;
                }
                else
                {
                    flags.big3 = Convert.ToBoolean(tmp);
                }
                tmp = dataRow["double_action"];
                if (tmp == DBNull.Value)
                {
                    flags.double_action = false;
                }
                else
                {
                    flags.double_action = Convert.ToBoolean(tmp);
                }
            }
        }
Пример #3
0
        /// <summary>
        /// Search for a pack already created by said name, if it doesn't exist, create a BingoPack as defined by PackTable Row.
        /// </summary>
        /// <param name="dataRow">a DataRow from PackTable</param>
        /// <returns></returns>
        public BingoPack MakePack(BingoGameGroup game_group, DataRow dataRow)
        {
            foreach (BingoPack pack in pack_skel)
            {
                if (String.Compare(pack.name, dataRow[PackTable.NameColumn].ToString(), true) == 0 &&
                    pack.game_groups.Contains(game_group))
                {
                    return(pack);
                }
            }

            foreach (BingoPack pack in pack_skel)
            {
                // found the pack, but it's not in this game group, so it's not really a pack.
                if (String.Compare(pack.name, dataRow[PackTable.NameColumn].ToString(), true) == 0)
                {
                    return(pack);
                }
            }

            BingoPack newpack = new BingoPack(game_group, dataRow);

            if (dataRow != null)
            {
                DataRow[] ranges = dataRow.GetChildRows("pack_has_cardset_range");
                if (ranges.Length == 0)
                {
                    MessageBox.Show("Pack " + dataRow[PackTable.NameColumn] + " does not have any cardset ranges...");
                    OpenSkieScheduler3.Controls.Forms.PackEditor pe = new OpenSkieScheduler3.Controls.Forms.PackEditor(dataRow);
                    pe.ShowDialog();
                    pe.Dispose();
                    ranges = dataRow.GetChildRows("pack_has_cardset_range");
                }
                if (ranges != null && ranges.Length > 0)
                {
                    foreach (DataRow cardset_range in ranges)
                    {
                        DataRow range = cardset_range.GetParentRow("cardset_range_in_pack");
                        newpack.dealers.Add(BingoDealers.GetDealer(range));
                    }
                }

                this.pack_skel.Add(newpack);
                newpack.pack_type = this.pack_skel.IndexOf(newpack);

                game_group.packs.Add(newpack);
            }
            return(newpack);
        }
Пример #4
0
 public BingoPacks(BingoGameList game_list, ScheduleDataSet schedule, DataRow session_info)
 {
     this.schedule  = schedule;
     this.game_list = game_list;
     //Session
     if (session_info != null)
     {
         DataRow[] pack_groups = session_info.GetChildRows("session_has_pack_group");
         foreach (DataRow pack_group in pack_groups)
         {
             DataRow        pack_group_info = pack_group.GetParentRow("pack_group_in_session");
             BingoGameGroup group           = game_list.game_group_list.GetGameGroup(pack_group_info);
             DataRow[]      packs           = pack_group_info.GetChildRows("pack_group_has_pack");
             foreach (DataRow pack in packs)
             {
                 DataRow   pack_info = pack.GetParentRow("pack_in_pack_group");
                 BingoPack made_pack = this.MakePack(group, pack_info);
                 this.Add(made_pack);
             }
         }
     }
 }
Пример #5
0
        bool LoadGameInfoFromGrid()
        {
            if (!Loaded)
            {
                int game_number = 1;
                //int maxid = 0;
                OddsRunInfo.GameInfo prior_game = null;
                GameList = new BingoGameList();

                foreach (DataRow row in GamePatternTable.Rows)
                {
                    bool rate;
                    if (!(rate = row["Rate Game"].Equals(DBNull.Value) ? false : Convert.ToBoolean(row["Rate Game"])))
                    {
                        continue;
                    }

                    OddsRunInfo.GameInfo game = new OddsRunInfo.GameInfo();

                    game.patterns = new List <Pattern>();
                    int pattern_col = GamePatternTable.Columns.IndexOf("Pattern 1");
                    ori.flags.lastBall = row["Last Ball"].Equals(DBNull.Value) ? false : Convert.ToBoolean(row["Last Ball"]);
                    game.starburst     = row["Starburst"].Equals(DBNull.Value) ? false : Convert.ToBoolean(row["Starburst"]);
                    if (game.starburst)
                    {
                        ori.flags.starburst = true;
                    }
                    game.rate = rate;
                    //game.rate = row["Rate Game"].Equals( DBNull.Value ) ? false : Convert.ToBoolean( row["Rate Game"] );
                    game.ignore_b_balls = row["Ignore Bs"].Equals(DBNull.Value) ? false : Convert.ToBoolean(row["Ignore Bs"]);
                    game.ignore_i_balls = row["Ignore Is"].Equals(DBNull.Value) ? false : Convert.ToBoolean(row["Ignore Is"]);
                    game.ignore_n_balls = row["Ignore Ns"].Equals(DBNull.Value) ? false : Convert.ToBoolean(row["Ignore Ns"]);
                    game.ignore_g_balls = row["Ignore Gs"].Equals(DBNull.Value) ? false : Convert.ToBoolean(row["Ignore Gs"]);
                    game.ignore_o_balls = row["Ignore Os"].Equals(DBNull.Value) ? false : Convert.ToBoolean(row["Ignore Os"]);
                    //if( !game.rate )
                    //	continue;
                    //game.hotball = row["Hotball"].Equals( DBNull.Value ) ? false : Convert.ToBoolean( row["Hotball"] );
                    game.cashballs   = row["# Cash Ball"].Equals(DBNull.Value) ? 0 : Convert.ToInt32(row["# Cash Ball"]);
                    game.progressive = row["Progressive"].Equals(DBNull.Value) ? false : Convert.ToBoolean(row["Progressive"]);
                    //game.double_action = row["Double Action"].Equals( DBNull.Value ) ? false : Convert.ToBoolean( row["Double Action"] );
                    game.overlapped = row["Overlapped"].Equals(DBNull.Value) ? false : Convert.ToBoolean(row["Overlapped"]);
                    game.extension  = row["Extension"].Equals(DBNull.Value) ? false : Convert.ToBoolean(row["Extension"]);

                    game.upick_size     = row["Upick Count"].Equals(DBNull.Value) ? 0 : Convert.ToInt32(row["Upick Count"]);
                    game.number_colored = row["Colored Ball Count"].Equals(DBNull.Value) ? 0 : Convert.ToInt32(row["Colored Ball Count"]);
                    // extended games have a prior_game.

                    if (game.extension)
                    {
                        if (prior_game == null)
                        {
                            game.extension = false;
                        }
                        game.prior_game = prior_game;
                    }

                    // if there is a prior game, then check that game to see if it was progressive or overlapped... if it is, then this has a prior.

                    else if (prior_game != null && (prior_game.progressive || prior_game.overlapped))
                    {
                        game.prior_game = prior_game;
                        game.into       = true;                   // set that we are the inot part of a progressive...
                    }
                    else
                    {
                        game.prior_game = null;
                    }

                    prior_game = game;

                    // game group is 5...

                    // okay pattern is found by name and added offset... good.

                    if (game.cashballs == 1)
                    {
                        ori.flags.hotball = true;
                    }

                    if (game.cashballs == 5)
                    {
                        ori.flags._5cashball = true;
                    }

                    Patterns tmp = new Patterns(schedule);
                    for (int i = 0; i < 1; i++)
                    {
                        object pattern_id = row[pattern_col + i];

                        if (pattern_id != DBNull.Value)
                        {
                            DataRow[] rows = schedule.patterns.Select("pattern_id='" + pattern_id + "'");
                            if (rows.Length > 0)
                            {
                                tmp.Add(new Pattern(rows[0], patterns));
                            }
                        }
                    }
                    if (tmp.Count == 0)
                    {
                        // otherwise we don't need (or want) patterns
                        if (game.upick_size == 0)
                        {
                            // no pattern, and not upick, drop the issue
                            continue;                             // next game.
                        }
                        game.Name = "Upickem " + game.upick_size;
                    }
                    else
                    {
                        game.Name = tmp[0].Name;
                        if (game.upick_size > 0)
                        {
                            // this is a conflict.
                        }
                        game.SetPatterns(tmp.ToArray());
                    }

                    game.game_number = game_number;

                    bool found_match = false;

                    // this shouldn't have to be initialized to zero here.

                    // there won't be any in the list

                    // so it will end up being assigned before the

                    // location that the compiler throws a stupid warning

                    game.game_ID = 0;
                    int game_pattern_count = game.patterns.Count;

                    // gamelist as null is okay, and just bails the loop.
                    foreach (OddsRunInfo.GameInfo checkgame in GameList)
                    {
                        int i = 0;
                        if (checkgame.patterns.Count == game_pattern_count)
                        {
                            for ( ; i < game_pattern_count; i++)
                            {
                                if (!checkgame.patterns[i].ID.Equals(game.patterns[i].ID))
                                {
                                    break;
                                }
                            }
                        }

                        if (i == game_pattern_count)
                        {
                            found_match       = true;
                            game.game_ID      = checkgame.game_ID;
                            game.pattern_list = checkgame.pattern_list;
                            game.stats        = checkgame.stats;
                            lock (game.stats)
                            {
                                game.stats.games++;
                            }
                            break;
                        }
                    }

                    if (!found_match)
                    // if it's still zero, didn't find one, so set one.
                    {
                        OddsRunInfo.GameTypeInfo stats = new OddsRunInfo.GameTypeInfo();
                        ///if( !ori.GameTypeList )
                        if (ori.GameTypeList == null)
                        {
                            ori.GameTypeList = new List <OddsRunInfo.GameTypeInfo>();
                        }
                        stats.best_wins = new int[ori.bestwins.Length];
                        stats.aways     = new int[5];
                        stats.games     = 1;                     // one same game.
                        stats.name      = game.Name;
                        stats.lastBalls = new int[90];
                        if (ori.colored_balls > 0)
                        {
                            stats.colored_ball_hit = new int[ori.colored_balls];
                        }
                        ori.GameTypeList.Add(stats);
                        game.stats   = stats;
                        game.game_ID = ori.GameTypeList.IndexOf(stats);
                    }

                    game.quickshot = ori.flags.quickshot;

                    if ((game.patterns.Count > 0) || (game.upick_size > 0))
                    {
                        GameList.Add(game);
                    }
                    else
                    {
                        game = null;                         // just make sure we auto destruct this...
                    }
                    game_number++;
                }

                //-------------------------------------------------------------
                // Check if user has selected a game/pattern
                //-------------------------------------------------------------
                if (GameList.Count <= 0)
                {
                    MessageBox.Show("Please select a Pattern and Game to Rate from the Game Grid before pressing 'Go'", "Missing Pattern");
                    return(false);
                }

                ori.Games = GameList.Count;

                BingoGameGroup bgg = null;                // new BingoGameGroup( Guid.NewGuid() );
                BingoDealer    dealer;
                if (ori.dealer != null)
                {
                    dealer = ori.dealer;
                }
                else
                {
                    dealer = BingoDealers.CreateSimpleDealer();
                }
                foreach (BingoGame game in GameList)
                {
                    if (bgg == null || !game.into)
                    {
                        bgg = new BingoGameGroup(Guid.NewGuid());
                        GameList.game_group_list.AddGameGroup(bgg);
                        // add some packs to the game_group
                        if (game.upick_size > 0)
                        {
                            BingoDealer upick_dealer = BingoDealers.CreateUpickDealer(game.upick_size);
                            BingoPack   upick_pack   = GameList.CreatePack(upick_dealer, "Fictional UPick " + game.upick_size, ori.Cards);
                            upick_pack.face_size     = game.upick_size;
                            upick_pack.flags.upickem = true;
                            if (!upick_pack.game_groups.Contains(bgg))
                            {
                                upick_pack.game_groups.Add(bgg);
                            }
                            bgg.packs.Add(upick_pack);
                        }
                        else
                        {
                            BingoPack pack = GameList.CreatePack(dealer, "Fictional Pack", ori.PackSize);
                            pack.game_groups.Add(bgg);
                            bgg.packs.Add(pack);
                        }
                    }
                    bgg.Add(game);
                    game.game_group = bgg;
                    if (game.pack_card_counts.Count < 1)
                    {
                        game.pack_card_counts.Add(ori.Cards);
                    }
                }
                ori.bingo_session = new BingoSession(GameList);
                ori.bingo_session.session_name = "Odds Run Info";
            }
            return(true);
        }
Пример #6
0
        /// <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);
                            }
                        }
                    }
                }
            }
        }
Пример #7
0
        public BingoGame(BingoGameList game_list, DataRow group_game)
        {
            BingoGame       _game    = ((game_list.Count > 0) ? game_list[game_list.Count - 1] : null);
            ScheduleDataSet schedule = game_list.schedule;

            Init();

            Name        = group_game.ToString();
            game_number = Convert.ToInt32(group_game[SessionGame.NumberColumn]);

            //game_list.
            //dataRow_game_group_game = group_game;
            {
                DataRow[] tmp = group_game.GetChildRows("session_game_has_session_game_group");
                int       n   = 0;
                foreach (DataRow row in tmp)
                {
                    BingoGameGroup bgg;
                    this.game_group = bgg = game_list.game_group_list.GetGameGroup(row.GetParentRow("session_game_group_in_session_game"));
                    bgg.Add(this);
                    {
                        DataRow   session_game_group = row.GetParentRow("session_game_group_in_session_game");
                        DataRow[] game_prizes        = session_game_group.GetChildRows("game_group_has_pack");
                        //DataRow[] game_prizes = group_packs.
                        //DataRow[] game_group_prizes = game_group_row.GetChildRows( "game_group_has_prize_level" );
                        foreach (DataRow game_prize in game_prizes)
                        {
                            DataRow _prize = game_prize.GetParentRow("prize_level_in_game_group");
                            if (_prize[PrizeLevelNames.PrimaryKey] == null)
                            {
                                int a = 3;
                            }
                            prizes.Add(new BingoPrize(_prize[PrizeLevelNames.PrimaryKey], 50));
                        }
                        // should further check against overrides to get corrected prizes.
                    }
                }
            }

            {
                Patterns new_patterns = new Patterns(schedule);

                DataRow[] GamePatterns = schedule.game_patterns.GetPatterns(group_game);
                //Log.log( "Selected " + GamePatterns.Length + " game pattes for " + group["game_info_id"] );
                foreach (DataRow pattern in GamePatterns)
                {
                    object pattern_id = pattern[schedule.patterns.PrimaryKeyName];
                    Log.log("Looking up pattern " + pattern_id);

                    Pattern GamePattern = new Pattern(pattern, new_patterns);
                    new_patterns.Add(GamePattern);
                }
                SetPatterns(new_patterns.ToArray());
            }

            if (Convert.ToBoolean(group_game["single_hotball"]))
            {
                cashballs = 1;
            }

            //double_action = Convert.ToBoolean( group_game["double_action"] );

            // Load all of the packs defined in this session.
            // these are used to validate sales loaded into players....
            // they are also used to collect raw informatino to match by name
            // the pack sales to pack definitions such ad dealer parameters.
            DataRow[] game_group_packs;

            {
                game_group_packs = schedule.session_games.GetGameGroupPacks(group_game);
                BingoPack pack = null;
                if (game_group_packs != null)
                {
                    foreach (DataRow info in game_group_packs)
                    {
                        BingoGameGroup use_group = null;
                        bool           found     = false;
                        //foreach( BingoGameGroup game_group in game_groups )
                        {
                            DataRow real_game_group = info.GetParentRow("game_group_prize_level_has_pack");
                            if (game_group.ID.Equals(real_game_group[PackGroupTable.PrimaryKey]))
                            {
                                use_group = game_group;
                                found     = true;
                                break;
                            }
                        }
                        if (!found)
                        {
                            game_group = use_group = new BingoGameGroup(info[PackGroupTable.PrimaryKey]);
                        }

                        game_group_packs = schedule.session_games.GetPacks(group_game);
                        foreach (DataRow ggp in game_group_packs)
                        {
                            pack = game_list.pack_list.MakePack(use_group, ggp);
                            while (pack_card_counts.Count <= pack.pack_type)
                            {
                                pack_card_counts.Add(0);
                            }
                        }

                        if (pack == null)
                        {
                        }
                        if (pack != null)
                        {
                            pack_card_counts[pack.pack_type] = pack.count;
                        }
                    }
                }

                prior_group_game = null;
                foreach (BingoGame g in game_list)
                {
                    if (g == this)
                    {
                        continue;
                    }
                    //foreach( BingoGameGroup gamegroup in g.game_groups )
                    {
                        //foreach( BingoGameGroup this_group in this.game_groups )
                        if (g.game_group != null && this.game_group != null)                          // this isn't set during loading...
                        {
                            if (g.game_group.ID.Equals(this.game_group.ID))
                            {
                                prior_group_game = g;
                                break;
                            }
                        }
                    }
                }
                if (prior_group_game == null)
                {
                    page_skip = 0;
                    // this isn't really an into, prior game might be 'normal' progressive, but
                    // that's really into the next part, not this one.
                    into = false;
                }
                else
                if (into)
                {
                    page_skip = prior_group_game.page_skip;
                }
                else
                {
                    page_skip = prior_group_game.page_skip + 1;
                }

                //game_group_id = group_id;
            }
            // setup progressive game, and game skips (by page, and by absolute ball-set)
            {
                progressive = (Convert.ToInt32(group_game["progressive"]) != 0);
                if (_game != null)
                {
                    if (_game.progressive)
                    {
                        ballset_number = _game.ballset_number;
                        into           = true;
                    }
                    else
                    {
                        ballset_number = _game.ballset_number + 1;
                    }
                }
                else
                {
                    ballset_number = 0;
                }
            }

            // setup page_skip.
            {
                if (prior_group_game == null)
                {
                    page_skip = 0;
                    // this isn't really an into, prior game might be 'normal' progressive, but
                    // that's really into the next part, not this one.
                    into = false;
                }
                else
                if (into)
                {
                    page_skip = prior_group_game.page_skip;
                }
                else
                {
                    page_skip = prior_group_game.page_skip + 1;
                }
            }
            //game_number = game_number;
            prior_game = _game;

            //_game = game;
        }