Changeset 384


Ignore:
Timestamp:
Feb 7, 2011, 3:23:40 AM (10 years ago)
Author:
sam
Message:

Make the Board class more generic by allowing non-48x48 tiles.

Location:
trunk/monsterz
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/monsterz/board.cpp

    r354 r384  
    3737    Board::game_t game;
    3838
    39     int2 dim;
     39    int2 dim, size;
    4040    int minnpieces, npieces, maxnpieces;
    4141
     
    8888{
    8989    data->game = game;
     90
     91    switch (data->game)
     92    {
     93    case GAME_HUNT:
     94        data->size = 48;
     95        break;
     96    case GAME_FUSION:
     97        data->size = 40;
     98        break;
     99    }
    90100
    91101    data->dim = dim;
     
    94104    data->maxnpieces = maxnpieces;
    95105    data->board = Tiler::Register(PNG_BOARD, 384, 384, 1.0f);
    96     data->tiles = Tiler::Register(PNG_TILES, 48, 48, 1.0f);
     106    data->tiles = Tiler::Register(PNG_TILES, data->size.x, data->size.y, 1.0f);
    97107    data->icons = Tiler::Register(PNG_ICONS, 24, 24, 1.0f);
    98108    data->click = Sampler::Register(WAV_CLICK);
     
    120130        data->current[0].id = GetRandomId();
    121131        data->current[1].id = GetRandomId();
    122         data->current[0].piece = new Piece(data->emitter, int2(3, 8),
    123                                            80 + 20 * data->current[0].id);
    124         data->current[1].piece = new Piece(data->emitter, int2(4, 8),
    125                                            80 + 20 * data->current[1].id);
     132        data->current[0].piece = new Piece(Piece::PIECE_FUSION,
     133                                           data->emitter, int2(3, 8),
     134                                           data->current[0].id);
     135        data->current[1].piece = new Piece(Piece::PIECE_FUSION,
     136                                           data->emitter, int2(4, 8),
     137                                           data->current[1].id);
    126138        Ticker::Ref(data->current[0].piece);
    127139        Ticker::Ref(data->current[1].piece);
    128         data->current[0].piece->SetPos(int2(3, 7) * 48);
    129         data->current[1].piece->SetPos(int2(4, 7) * 48);
     140        data->current[0].piece->SetPos(int2(3, 7) * data->size);
     141        data->current[1].piece->SetPos(int2(4, 7) * data->size);
    130142
    131143        data->next[0] = GetRandomId();
     
    184196        if (buttons[0] && !data->oldbuttons[0] && mousepos.x != -1)
    185197        {
    186             int2 cell = mousepos / 48;
     198            int2 cell = mousepos / data->size;
    187199            if (data->pairs[cell.x][cell.y].piece->Grab(int2(0, 0)))
    188200            {
    189201                Sampler::PlaySample(data->click);
    190202                data->grabbed = data->pairs[cell.x][cell.y];
    191                 data->src_cell = mousepos / 48;
     203                data->src_cell = mousepos / data->size;
    192204                data->dst_cell = int2(-1);
    193205                data->state = BoardData::HUNT_GRAB;
     
    204216            data->grabbed.piece->Grab(mousepos - data->oldmouse);
    205217            int2 cur_pos = data->grabbed.piece->GetPos();
    206             int2 cur_cell = (cur_pos + 24) / 48;
     218            int2 cur_cell = (cur_pos + data->size / 2) / data->size;
    207219            if (cur_cell.i < 0 || cur_cell.i >= data->dim.i
    208220                 || cur_cell.j < 0 || cur_cell.j >= data->dim.j
    209                  || (cur_pos - cur_cell * 48).sqlen() > 24 * 24
     221                 || (cur_pos - cur_cell * data->size).sqlen() > data->size.sqlen() / 8
    210222                 || (cur_cell - data->src_cell).sqlen() != 1)
    211223                cur_cell = int2(-1);
     
    220232                if (data->dst_cell != int2(-1))
    221233                    data->pairs[data->dst_cell.i]
    222                                [data->dst_cell.j].piece->Ungrab(data->dst_cell * 48);
     234                               [data->dst_cell.j].piece->Ungrab(data->dst_cell * data->size);
    223235                if (cur_cell != int2(-1))
    224236                    data->pairs[cur_cell.i]
    225                                [cur_cell.j].piece->Ungrab(data->src_cell * 48);
     237                               [cur_cell.j].piece->Ungrab(data->src_cell * data->size);
    226238                data->dst_cell = cur_cell;
    227239            }
    228240        }
    229241        if (!buttons[0] || mousepos.x == -1
    230              || (data->src_cell * 48
     242             || (data->src_cell * data->size
    231243                  - data->grabbed.piece->GetPos()).sqlen() > 100 * 100)
    232244        {
    233245            /* Mouse released, or exited window, or dragged too far. */
    234             data->grabbed.piece->Ungrab(data->grabbed.piece->GetCell() * 48);
     246            data->grabbed.piece->Ungrab(data->grabbed.piece->GetCell() * data->size);
    235247            if (data->dst_cell != int2(-1))
    236248                Switch(data->src_cell, data->dst_cell);
     
    264276        }
    265277
    266         if (mousepos.x != -1
    267             && mousepos.x / 48 != data->current[0].piece->GetCell().x)
    268         {
    269             column = mousepos.x / 48;
     278        if (mousepos.x != -1 &&
     279            mousepos.x / data->size.x != data->current[0].piece->GetCell().x)
     280        {
     281            column = mousepos.x / data->size.x;
    270282            column = column < 0 ? 0 : column > data->dim.i - 2 + data->rotation ? data->dim.i - 2 + data->rotation : column;
    271283        }
     
    284296            }
    285297
    286             data->current[0].piece->Move(data->current[0].piece->GetCell() * 48);
    287             data->current[1].piece->Move(data->current[1].piece->GetCell() * 48);
     298            data->current[0].piece->Move(data->current[0].piece->GetCell() * data->size);
     299            data->current[1].piece->Move(data->current[1].piece->GetCell() * data->size);
    288300        }
    289301
     
    297309                    {
    298310                        data->current[t].piece->SetCell(int2(i, j));
    299                         data->current[t].piece->Move(int2(i, j) * 48);
     311                        data->current[t].piece->Move(int2(i, j) * data->size);
    300312                        data->pairs[i][j] = data->current[t];
    301313                        data->thumbs->AddCount(data->current[t].id, 1);
     
    306318            data->current[0].id = data->next[0];
    307319            data->current[1].id = data->next[1];
    308             data->current[0].piece = new Piece(data->emitter, int2(3, 7),
    309                                                80 + 20 * data->current[0].id);
    310             data->current[1].piece = new Piece(data->emitter, int2(4, 7),
    311                                                80 + 20 * data->current[1].id);
     320            data->current[0].piece = new Piece(Piece::PIECE_FUSION,
     321                                               data->emitter, int2(3, 7),
     322                                               data->current[0].id);
     323            data->current[1].piece = new Piece(Piece::PIECE_FUSION,
     324                                               data->emitter, int2(4, 7),
     325                                               data->current[1].id);
    312326            Ticker::Ref(data->current[0].piece);
    313327            Ticker::Ref(data->current[1].piece);
    314             data->current[0].piece->SetPos(int2(3, 8) * 48);
    315             data->current[1].piece->SetPos(int2(4, 8) * 48);
    316             data->current[0].piece->Move(data->current[0].piece->GetCell() * 48);
    317             data->current[1].piece->Move(data->current[1].piece->GetCell() * 48);
     328            data->current[0].piece->SetPos(int2(3, 8) * data->size);
     329            data->current[1].piece->SetPos(int2(4, 8) * data->size);
     330            data->current[0].piece->Move(data->current[0].piece->GetCell() * data->size);
     331            data->current[1].piece->Move(data->current[1].piece->GetCell() * data->size);
    318332            data->next[0] = GetRandomId();
    319333            data->next[1] = GetRandomId();
     
    368382        for (int i = 0; i < data->dim.i; i++)
    369383        {
    370             int2 newpos = int2(i, j + data->dim.j) * 48;
    371             int id = 80 + 20 * data->pairs[i][j].id;
    372             data->pairs[i][j].piece = new Piece(data->emitter, int2(i, j), id);
     384            int2 newpos = int2(i, j + data->dim.j) * data->size;
     385            int id = data->pairs[i][j].id;
     386            data->pairs[i][j].piece = new Piece(Piece::PIECE_HUNT,
     387                                                data->emitter, int2(i, j), id);
    373388            data->pairs[i][j].piece->SetPos(newpos);
    374             data->pairs[i][j].piece->Move(int2(i, j) * 48);
     389            data->pairs[i][j].piece->Move(int2(i, j) * data->size);
    375390            if (j)
    376391                data->pairs[i][j].piece->SetBelow(data->pairs[i][j - 1].piece);
     
    394409        data->pairs[cell_a.i][cell_a.j] = a;
    395410        data->pairs[cell_b.i][cell_b.j] = b;
    396         a.piece->Ungrab(cell_a * 48);
    397         b.piece->Ungrab(cell_b * 48);
     411        a.piece->Ungrab(cell_a * data->size);
     412        b.piece->Ungrab(cell_b * data->size);
    398413        return;
    399414    }
     
    401416    /* Perform the swap */
    402417    a.piece->SetCell(cell_b);
    403     a.piece->Ungrab(cell_b * 48);
     418    a.piece->Ungrab(cell_b * data->size);
    404419    b.piece->SetCell(cell_a);
    405     b.piece->Ungrab(cell_a * 48);
     420    b.piece->Ungrab(cell_a * data->size);
    406421
    407422    /* Swap above and below cells */
     
    458473                int id = 1 + rand() % data->npieces;
    459474                data->pairs[i][j].id = id;
    460                 data->pairs[i][j].piece = new Piece(data->emitter, int2(i, j), 80 + 20 * id);
     475                data->pairs[i][j].piece = new Piece(Piece::PIECE_HUNT, data->emitter, int2(i, j), id);
    461476                data->pairs[i][j].piece->SetBelow(old->GetBelow());
    462477                data->pairs[i][j].piece->SetAbove(old->GetAbove());
     
    474489                    data->pairs[i][j2 - 1] = data->pairs[i][j2];
    475490                    data->pairs[i][j2 - 1].piece->SetCell(int2(i, j2 - 1));
    476                     data->pairs[i][j2 - 1].piece->Move(int2(i, j2 - 1) * 48);
     491                    data->pairs[i][j2 - 1].piece->Move(int2(i, j2 - 1) * data->size);
    477492                    list[i][j2 - 1] = list[i][j2];
    478493                }
     
    480495                /* Spawn a new piece above all the others and attach it to
    481496                 * the board. */
    482                 int2 newpos = int2(i * 48, below->GetPos().y + 48);
     497                int2 newpos = int2(i * data->size.x,
     498                                   below->GetPos().y + data->size.y);
    483499                int2 newcell = int2(i, data->dim.j - 1);
    484500                int id = 1 + rand() % data->npieces;
    485                 Piece *tmp = new Piece(data->emitter, newcell, 80 + 20 * id);
     501                Piece *tmp = new Piece(Piece::PIECE_HUNT, data->emitter,
     502                                       newcell, id);
    486503                tmp->SetBelow(below);
    487504                tmp->SetPos(newpos);
    488                 tmp->Move(newcell * 48);
     505                tmp->Move(newcell * data->size);
    489506                Ticker::Ref(tmp);
    490507                data->pairs[i][data->dim.j - 1].id = id;
     
    717734            data->thumbs->SetMax(data->npieces);
    718735        }
    719         data->pairs[i][j].piece = new Piece(data->emitter, int2(i, j), 80 + 20 * data->pairs[i][j].id);
     736        data->pairs[i][j].piece = new Piece(Piece::PIECE_FUSION,
     737                                            data->emitter, int2(i, j),
     738                                            data->pairs[i][j].id);
    720739        Ticker::Ref(data->pairs[i][j].piece);
    721         data->pairs[i][j].piece->SetPos(int2(i, j) * 48);
     740        data->pairs[i][j].piece->SetPos(int2(i, j) * data->size);
    722741        data->thumbs->AddCount(data->pairs[i][j].id, 1);
    723742        count[list[i][j]] = 0;
     
    737756            {
    738757                data->pairs[i][j2 - 1].piece->SetCell(int2(i, j2 - 1));
    739                 data->pairs[i][j2 - 1].piece->Move(int2(i, j2 - 1) * 48);
     758                data->pairs[i][j2 - 1].piece->Move(int2(i, j2 - 1) * data->size);
    740759            }
    741760            list[i][j2 - 1] = list[i][j2];
  • trunk/monsterz/mash.cpp

    r314 r384  
    8686        for (int n = 0; n < data->npieces && allready; n++)
    8787        {
    88             int2 dest = data->pieces[n]->GetCell() * 48;
    89             int2 cur = data->pieces[n]->GetPos();
    90 
    9188            /* If piece is still too high, don't start the animation */
    92             if (cur.y - dest.y > 2 || abs(cur.x - dest.x) > 2)
     89            int2 shift = data->pieces[n]->GetShift();
     90            if (shift.y > 2 || abs(shift.x) > 2)
    9391                allready = 0;
    9492        }
  • trunk/monsterz/monsterz.h

    r354 r384  
    1616static char const * const PNG_LOGO = "monsterz/gfx/logo.png";
    1717static char const * const PNG_TILES = "monsterz/gfx/tiles.png";
     18static char const * const PNG_ELEMENTS = "monsterz/gfx/elements.png";
    1819static char const * const PNG_ICONS = "monsterz/gfx/icons.png";
    1920static char const * const PNG_TITLE = "monsterz/gfx/title0.png";
  • trunk/monsterz/piece.cpp

    r354 r384  
    2929
    3030private:
     31    Piece::piece_t piece;
     32
     33    int tiler;
    3134    Emitter *emitter;
    3235    Piece *above, *below;
    33     int tiler;
    34     int2 cell, pos, src, dst;
     36    int2 size, cell, pos, src, dst;
    3537    int id;
    3638    float speed, timer, blink, idle;
     
    5355 */
    5456
    55 Piece::Piece(Emitter *emitter, int2 cell, int id)
     57Piece::Piece(piece_t piece, Emitter *emitter, int2 cell, int id)
    5658  : data(new PieceData())
    5759{
     60    data->piece = piece;
     61
    5862    data->emitter = emitter;
    5963    Ticker::Ref(emitter);
    6064    data->above = NULL;
    6165    data->below = NULL;
    62     data->tiler = Tiler::Register(PNG_TILES, 48, 48, 1.0f);
    6366    data->cell = cell;
    64     data->pos = cell * 48;
    65     data->id = id;
    6667    data->state = PieceData::IDLE;
    6768    data->timer = RandF(DELAY_IDLE);
    6869    data->blink = RandF(DELAY_BLINK);
    6970    data->idle = RandF(DELAY_IDLE, 2 * DELAY_IDLE);
     71
     72    switch (data->piece)
     73    {
     74    case PIECE_HUNT:
     75        data->size = 48;
     76        data->tiler = Tiler::Register(PNG_TILES,
     77                                      data->size.x, data->size.y, 1.0f);
     78        data->id = 80 + 20 * id;
     79        break;
     80    case PIECE_FUSION:
     81        data->size = 40;
     82        data->tiler = Tiler::Register(PNG_ELEMENTS,
     83                                      data->size.x, data->size.y, 1.0f);
     84        data->id = id - 1;
     85        break;
     86    }
     87
     88    data->pos = data->cell * data->size;
    7089}
    7190
     
    88107{
    89108    return data->pos;
     109}
     110
     111int2 Piece::GetSize() const
     112{
     113    return data->size;
     114}
     115
     116int2 Piece::GetShift() const
     117{
     118    return data->pos - data->cell * data->size;
    90119}
    91120
     
    168197    case PieceData::MOVE:
    169198        /* Only allow swaps when piece is close enough to its target cell. */
    170         if ((data->cell * 48 - data->pos).sqlen() > 24 * 24)
     199        if ((data->cell * data->size - data->pos).sqlen()
     200              > data->size.sqlen() / 8)
    171201            return 0;
    172202        /* Fall through */
     
    261291         * start falling again. */
    262292        if (data->state == PieceData::MOVE && data->below
    263              && data->pos.y < data->below->data->pos.y + 48)
     293             && data->pos.y < data->below->data->pos.y + data->size.y)
    264294        {
    265             data->pos.y = data->below->data->pos.y + 48;
     295            data->pos.y = data->below->data->pos.y + data->size.y;
    266296            data->src = data->pos;
    267297            data->timer = 0.0f;
     
    302332    Entity::TickDraw(deltams);
    303333
    304     int id = data->id;
     334    int id = data->id, off = 0;
    305335    int x = data->pos.x + 24;
    306336    int y = data->pos.y + 72;
     
    312342    case PieceData::IDLE:
    313343    {
    314         int off = data->timer * 3 / data->idle;
     344        off = data->timer * 3 / data->idle;
    315345        if (off < 0) off = 0;
    316346        if (off > 2) off = 2;
    317         id = data->id + off;
    318         break;
    319     }
    320     case PieceData::BLINK:
    321         id = data->id + 3;
    322         break;
    323     case PieceData::GRAB:
    324         id = data->id + 3;
     347        break;
     348    }
     349    case PieceData::BLINK:
     350        off = 3;
     351        break;
     352    case PieceData::GRAB:
     353        off = 3;
    325354        z = 4;
    326355        break;
    327356    case PieceData::UNGRAB:
    328         if ((data->cell * 48 - data->src).sqlen() > 24 * 24)
    329             id = data->id + 7;
     357        if ((data->cell * data->size - data->src).sqlen()
     358              > data->size.sqlen() / 8)
     359            off = 7;
    330360        z = 4;
    331361        break;
     
    335365    case PieceData::POP:
    336366    {
    337         int off = 4 - (int)(data->timer * 5 / DELAY_POP);
     367        off = 4 - (int)(data->timer * 5 / DELAY_POP);
    338368        if (off < 0) off = 0;
    339369        if (off > 4) off = 4;
    340         id = data->id + 7 + off;
     370        off += 7;
    341371        break;
    342372    }
    343373    case PieceData::DEAD:
     374        break;
     375    }
     376
     377    /* Only change image if the required frame is available */
     378    switch (data->piece)
     379    {
     380    case PIECE_HUNT:
     381        id += off;
     382        break;
     383    case PIECE_FUSION:
    344384        break;
    345385    }
  • trunk/monsterz/piece.h

    r354 r384  
    2424{
    2525public:
    26     Piece(Emitter *emitter, int2 cell, int id);
     26    typedef enum
     27    {
     28        PIECE_HUNT,
     29        PIECE_FUSION,
     30    }
     31    piece_t;
     32
     33    Piece(piece_t, Emitter *emitter, int2 cell, int id);
    2734    virtual ~Piece();
    2835
     
    3138    void SetPos(int2 pos);
    3239    int2 GetPos() const;
     40
     41    int2 GetSize() const;
     42    int2 GetShift() const;
    3343
    3444    void SetAbove(Piece *below);
Note: See TracChangeset for help on using the changeset viewer.