Ignore:
Timestamp:
Jan 31, 2011, 2:50:51 AM (10 years ago)
Author:
sam
Message:

Board size and number of available pieces is now a parameter of
the Board class ctor.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/monsterz/board.cpp

    r313 r314  
    3333
    3434private:
    35     Game *game;
     35    int2 dim;
     36    int npieces;
    3637    int screen, board, tiles;
    3738    int click, whip;
     
    4243        Piece *piece;
    4344    }
    44     pairs[8][8], grabbed;
     45    pairs[MAX_WIDTH][MAX_HEIGHT], grabbed;
    4546    int nmoves;
    4647
     
    6667 */
    6768
    68 Board::Board(Game *game)
     69Board::Board(int2 dim, int npieces)
    6970  : data(new BoardData())
    7071{
    71     data->game = game;
    72     Ticker::Ref(game);
     72    data->dim = dim;
     73    data->npieces = npieces;
    7374    data->screen = Tiler::Register(PNG_BACKGROUND, 640, 480, 1.0f);
    7475    data->board = Tiler::Register(PNG_BOARD, 384, 384, 1.0f);
     
    9899    if ((data->nextblink -= deltams) < 0.0f)
    99100    {
    100         data->pairs[rand() % 8][rand() % 8].piece->Blink();
     101        data->pairs[rand() % data->dim.i]
     102                   [rand() % data->dim.j].piece->Blink();
    101103        data->nextblink = (float)(200 + rand() % 500);
    102104    }
     
    125127            int x = mouse.x - 24;
    126128            int y = mouse.y - 72;
    127             if (x >= 0 && x < 8 * 48 && y >= 0 && y < 8 * 48)
     129            if (x >= 0 && x < data->dim.i * 48
     130                 && y >= 0 && y < data->dim.j * 48)
    128131            {
    129132                if (data->pairs[x / 48][y / 48].piece->Grab(int2(0, 0)))
     
    149152            int2 cur_pos = data->grabbed.piece->GetPos();
    150153            int2 cur_cell = (cur_pos + 24) / 48;
    151             if (cur_cell.i < 0 || cur_cell.i >= 8
    152                  || cur_cell.j < 0 || cur_cell.j >= 8
     154            if (cur_cell.i < 0 || cur_cell.i >= data->dim.i
     155                 || cur_cell.j < 0 || cur_cell.j >= data->dim.j
    153156                 || (cur_pos - cur_cell * 48).sqlen() > 24 * 24
    154157                 || (cur_cell - data->src_cell).sqlen() != 1)
     
    212215    srand(rand() ^ time(NULL));
    213216
    214     int list[8][8];
     217    int list[MAX_WIDTH][MAX_HEIGHT];
    215218    do
    216219    {
    217         for (int j = 0; j < 8; j++)
    218             for (int i = 0; i < 8; i++)
    219                 data->pairs[i][j].id = 1 + rand() % 9;
     220        for (int j = 0; j < data->dim.j; j++)
     221            for (int i = 0; i < data->dim.i; i++)
     222                data->pairs[i][j].id = 1 + rand() % data->npieces;
    220223    } while (ListMashes(list) || !(data->nmoves = ListMoves(list)));
    221224
    222225    /* Spawn pieces */
    223     for (int j = 0; j < 8; j++)
    224         for (int i = 0; i < 8; i++)
    225         {
    226             int2 newpos = int2(i, j + 8) * 48;
     226    for (int j = 0; j < data->dim.j; j++)
     227        for (int i = 0; i < data->dim.i; i++)
     228        {
     229            int2 newpos = int2(i, j + data->dim.j) * 48;
    227230            int id = 80 + 20 * data->pairs[i][j].id;
    228231            data->pairs[i][j].piece = new Piece(data->emitter, int2(i, j), id);
     
    244247    /* Check whether this is a valid move by testing all patterns.
    245248     * If the move is invalid, cancel the swap and bail out */
    246     int list[8][8];
     249    int list[MAX_WIDTH][MAX_HEIGHT];
    247250
    248251    if (!ListMashes(list))
     
    299302        Ticker::Ref(mash);
    300303
    301         for (int j = 8; j--;) for (int i = 0; i < 8; i++)
     304        for (int j = data->dim.j; j--;) for (int i = 0; i < data->dim.i; i++)
    302305        {
    303306            if (!list[i][j])
     
    311314            {
    312315                Piece *old = data->pairs[i][j].piece;
    313                 int id = 1 + rand() % 9;
     316                int id = 1 + rand() % data->npieces;
    314317                data->pairs[i][j].id = id;
    315318                data->pairs[i][j].piece = new Piece(data->emitter, int2(i, j), 80 + 20 * id);
     
    322325#endif
    323326            {
    324                 Piece *below = data->pairs[i][7].piece;
     327                Piece *below = data->pairs[i][data->dim.j - 1].piece;
    325328
    326329                /* Change coordinates for the whole column above */
    327                 for (int j2 = j + 1; j2 < 8; j2++)
     330                for (int j2 = j + 1; j2 < data->dim.j; j2++)
    328331                {
    329332                    data->pairs[i][j2 - 1] = data->pairs[i][j2];
     
    336339                 * the board. */
    337340                int2 newpos = int2(i * 48, below->GetPos().y + 48);
    338                 int id = 1 + rand() % 9;
    339                 data->pairs[i][7].id = id;
    340                 data->pairs[i][7].piece = new Piece(data->emitter, int2(i, 7), 80 + 20 * id);
    341                 data->pairs[i][7].piece->SetBelow(below);
    342                 data->pairs[i][7].piece->SetPos(newpos);
    343                 data->pairs[i][7].piece->Move(int2(i, 7) * 48);
    344                 Ticker::Ref(data->pairs[i][7].piece);
    345                 list[i][7] = 0;
     341                int2 newcell = int2(i, data->dim.j - 1);
     342                int id = 1 + rand() % data->npieces;
     343                Piece *tmp = new Piece(data->emitter, newcell, 80 + 20 * id);
     344                tmp->SetBelow(below);
     345                tmp->SetPos(newpos);
     346                tmp->Move(newcell * 48);
     347                Ticker::Ref(tmp);
     348                data->pairs[i][data->dim.j - 1].id = id;
     349                data->pairs[i][data->dim.j - 1].piece = tmp;
     350                list[i][data->dim.j - 1] = 0;
    346351            }
    347352        }
     
    359364        Ticker::Ref(mash);
    360365
    361         for (int j = 8; j--;) for (int i = 0; i < 8; i++)
     366        for (int j = data->dim.j; j--;) for (int i = 0; i < data->dim.i; i++)
    362367            mash->AddPiece(data->pairs[i][j].piece);
    363368
     
    365370        data->mashes = mash;
    366371
    367         Piece *below[8];
    368         for (int i = 0; i < 8; i++)
    369             below[i] = data->pairs[i][7].piece;
     372        Piece *below[MAX_WIDTH];
     373        for (int i = 0; i < data->dim.i; i++)
     374            below[i] = data->pairs[i][data->dim.j - 1].piece;
    370375
    371376        Fill();
    372377
    373         for (int i = 0; i < 8; i++)
     378        for (int i = 0; i < data->dim.i; i++)
    374379            data->pairs[i][0].piece->SetBelow(below[i]);
    375380    }
     
    378383/* Fill an array with the list of pieces that should disappear due to
    379384 * 3-piece or more alignments. */
    380 int Board::ListMashes(int list[8][8])
     385int Board::ListMashes(int list[MAX_WIDTH][MAX_HEIGHT])
    381386{
    382387    int ret = 0;
    383388
    384     for (int j = 0; j < 8; j++)
    385         for (int i = 0; i < 8; i++)
     389    for (int j = 0; j < data->dim.j; j++)
     390        for (int i = 0; i < data->dim.i; i++)
    386391            list[i][j] = 0;
    387392
    388     for (int j = 0; j < 8; j++)
    389         for (int i = 0; i < 8; i++)
     393    for (int j = 0; j < data->dim.j; j++)
     394        for (int i = 0; i < data->dim.i; i++)
    390395        {
    391396            int id = data->pairs[i][j].id;
    392397
    393             if (i + 2 < 8 && data->pairs[i + 1][j].id == id
     398            if (i + 2 < data->dim.i && data->pairs[i + 1][j].id == id
    394399                          && data->pairs[i + 2][j].id == id)
    395400            {
     
    400405            }
    401406
    402             if (j + 2 < 8 && data->pairs[i][j + 1].id == id
     407            if (j + 2 < data->dim.j && data->pairs[i][j + 1].id == id
    403408                          && data->pairs[i][j + 2].id == id)
    404409            {
     
    417422 * moved up, and a value of 3 means both moves are possible. The number
    418423 * of possible moves is returned. */
    419 int Board::ListMoves(int moves[8][8])
     424int Board::ListMoves(int moves[MAX_WIDTH][MAX_HEIGHT])
    420425{
    421426    int ret = 0;
    422427
    423     for (int j = 0; j < 8; j++)
    424         for (int i = 0; i < 8; i++)
     428    for (int j = 0; j < data->dim.j; j++)
     429        for (int i = 0; i < data->dim.i; i++)
    425430            moves[i][j] = 0;
    426431
    427     for (int j = 0; j < 8; j++)
    428         for (int i = 0; i < 8; i++)
     432    for (int j = 0; j < data->dim.j; j++)
     433        for (int i = 0; i < data->dim.i; i++)
    429434        {
    430435            /* Copy neighbourhood to a local buffer */
     
    433438            for (int dj = -2; dj <= 3; dj++)
    434439                for (int di = -2; di <= 3; di++)
    435                     if (j + dj >= 0 && j + dj < 8
    436                          && i + di >= 0 && i + di < 8)
     440                    if (j + dj >= 0 && j + dj < data->dim.j
     441                         && i + di >= 0 && i + di < data->dim.i)
    437442                        tmp[2 + di][2 + dj] = data->pairs[i + di][j + dj].id;
    438443                    else
     
    490495Board::~Board()
    491496{
    492     Ticker::Unref(data->game);
    493     for (int j = 0; j < 8; j++)
    494         for (int i = 0; i < 8; i++)
     497    for (int j = 0; j < data->dim.j; j++)
     498        for (int i = 0; i < data->dim.i; i++)
    495499        {
    496500            data->pairs[i][j].piece->SetBelow(NULL);
Note: See TracChangeset for help on using the changeset viewer.