Changeset 352


Ignore:
Timestamp:
Feb 4, 2011, 1:20:53 AM (10 years ago)
Author:
sam
Message:

Merge the Fusion class back into Board.

Location:
trunk
Files:
2 deleted
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/monsterz/Makefile.am

    r340 r352  
    44monsterz_SOURCES = \
    55    monsterz.cpp monsterz.h title.cpp title.h interface.cpp interface.h \
    6     fusion.cpp fusion.h board.cpp board.h piece.cpp piece.h mash.cpp mash.h \
    7     thumbs.cpp thumbs.h
     6    board.cpp board.h piece.cpp piece.h mash.cpp mash.h thumbs.cpp thumbs.h
    87monsterz_CXXFLAGS = @LOL_CFLAGS@ @PIPI_CFLAGS@
    98monsterz_LDADD = $(top_builddir)/src/liblol.a
  • trunk/monsterz/board.cpp

    r348 r352  
    1717#include <cstdlib>
    1818#include <ctime>
     19#include <cstring>
    1920
    2021#include "core.h"
     
    3435
    3536private:
     37    Board::game_t game;
     38
    3639    int2 dim;
    37     int npieces;
    38     int board, tiles;
     40    int minnpieces, npieces, maxnpieces;
     41
     42    int board, tiles, icons;
    3943    int click, whip;
    4044
     
    4448        Piece *piece;
    4549    }
    46     pairs[MAX_WIDTH][MAX_HEIGHT], grabbed;
     50    pairs[MAX_WIDTH][MAX_HEIGHT];
     51
     52    /* Hunt */
     53    struct Pair grabbed;
    4754    int nmoves;
     55    int2 src_cell, dst_cell;
     56
     57    /* Fusion */
     58    struct Pair current[2];
     59    int next[2], rotation;
    4860
    4961    Text *scoretext;
     
    5365    Emitter *emitter;
    5466    Thumbs *thumbs;
    55     int2 src_cell, dst_cell;
    5667
    5768    int2 oldmouse;
     
    6172    enum
    6273    {
    63         IDLE,
    64         BADCLICK,
    65         GRAB,
     74        HUNT_IDLE,
     75        HUNT_BADCLICK,
     76        HUNT_GRAB,
     77        FUSION_IDLE,
    6678    }
    6779    state;
     
    7284 */
    7385
    74 Board::Board(int2 dim, int npieces)
     86Board::Board(game_t game, int2 dim, int minnpieces, int maxnpieces)
    7587  : data(new BoardData())
    7688{
     89    data->game = game;
     90
    7791    data->dim = dim;
    78     data->npieces = npieces;
     92    data->minnpieces = minnpieces;
     93    data->npieces = minnpieces;
     94    data->maxnpieces = maxnpieces;
    7995    data->board = Tiler::Register(PNG_BOARD, 384, 384, 1.0f);
    8096    data->tiles = Tiler::Register(PNG_TILES, 48, 48, 1.0f);
     97    data->icons = Tiler::Register(PNG_ICONS, 24, 24, 1.0f);
    8198    data->click = Sampler::Register(WAV_CLICK);
    8299    data->whip = Sampler::Register(WAV_WHIP);
     
    85102    Ticker::Ref(data->emitter);
    86103
    87     Fill();
     104    data->thumbs = new Thumbs(0);
     105    Ticker::Ref(data->thumbs);
     106
     107    switch (data->game)
     108    {
     109    case GAME_HUNT:
     110        Fill();
     111        data->thumbs->SetMax(data->npieces);
     112        data->state = BoardData::HUNT_IDLE;
     113        break;
     114
     115    case GAME_FUSION:
     116        for (int j = 0; j < data->dim.j; j++)
     117            for (int i = 0; i < data->dim.i; i++)
     118                data->pairs[i][j].id = 0;
     119
     120        data->current[0].id = GetRandomId();
     121        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);
     126        Ticker::Ref(data->current[0].piece);
     127        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);
     130
     131        data->next[0] = GetRandomId();
     132        data->next[1] = GetRandomId();
     133        data->rotation = 0;
     134
     135        data->thumbs->SetMax(data->npieces + 1);
     136        data->state = BoardData::FUSION_IDLE;
     137        break;
     138    }
    88139
    89140    data->mashes = NULL;
    90141    data->nextblink = 0.0f;
    91142    data->whipdelay = 0.0f;
    92     data->state = BoardData::IDLE;
    93 
    94     data->thumbs = new Thumbs(MAX_PIECES);
    95     Ticker::Ref(data->thumbs);
    96143
    97144    data->scoretext = new Text(NULL, "monsterz/gfx/font2.png");
     
    115162
    116163    /* If possible, make a random monster blink */
    117     if ((data->nextblink -= deltams) < 0.0f)
     164    if (data->game == Board::GAME_HUNT && (data->nextblink -= deltams) < 0.0f)
    118165    {
    119166        data->pairs[rand() % data->dim.i]
     
    142189    switch (data->state)
    143190    {
    144     case BoardData::IDLE:
     191    case BoardData::HUNT_IDLE:
    145192        /* Should we start dragging something? */
    146193        if (buttons[0] && !data->oldbuttons[0] && mousepos.x != -1)
     
    153200                data->src_cell = mousepos / 48;
    154201                data->dst_cell = int2(-1);
    155                 data->state = BoardData::GRAB;
     202                data->state = BoardData::HUNT_GRAB;
    156203            }
    157204            else
    158                 data->state = BoardData::BADCLICK;
    159         }
    160         break;
    161     case BoardData::GRAB:
     205                data->state = BoardData::HUNT_BADCLICK;
     206        }
     207        break;
     208
     209    case BoardData::HUNT_GRAB:
    162210        if (mousepos.x != -1)
    163211        {
     
    196244            if (data->dst_cell != int2(-1))
    197245                Switch(data->src_cell, data->dst_cell);
    198             data->state = BoardData::IDLE;
    199         }
    200         break;
    201     case BoardData::BADCLICK:
     246            data->state = BoardData::HUNT_IDLE;
     247        }
     248        break;
     249
     250    case BoardData::HUNT_BADCLICK:
    202251        if (!buttons[0])
    203             data->state = BoardData::IDLE;
    204         break;
     252            data->state = BoardData::HUNT_IDLE;
     253        break;
     254
     255    case BoardData::FUSION_IDLE:
     256    {
     257        int column = -1;
     258
     259        if (clicked[2])
     260        {
     261            column = data->current[0].piece->GetCell().x;
     262            data->rotation = (data->rotation + 1) % 2;
     263            if (column - data->rotation > data->dim.i - 1)
     264                column = data->dim.i - 1 - data->rotation;
     265            if (!data->rotation)
     266            {
     267                BoardData::Pair tmp = data->current[0];
     268                data->current[0] = data->current[1];
     269                data->current[1] = tmp;
     270                if (column == data->dim.i - 1)
     271                    column = 6;
     272            }
     273        }
     274
     275        if (mousepos.x != -1
     276            && mousepos.x / 48 != data->current[0].piece->GetCell().x)
     277        {
     278            column = mousepos.x / 48;
     279            column = column < 0 ? 0 : column > data->dim.i - 2 + data->rotation ? data->dim.i - 2 + data->rotation : column;
     280        }
     281
     282        if (column != -1)
     283        {
     284            if (data->rotation)
     285            {
     286                data->current[0].piece->SetCell(int2(column, 6));
     287                data->current[1].piece->SetCell(int2(column, 7));
     288            }
     289            else
     290            {
     291                data->current[0].piece->SetCell(int2(column, 7));
     292                data->current[1].piece->SetCell(int2(column + 1, 7));
     293            }
     294
     295            data->current[0].piece->Move(data->current[0].piece->GetCell() * 48);
     296            data->current[1].piece->Move(data->current[1].piece->GetCell() * 48);
     297        }
     298
     299        if (clicked[0])
     300        {
     301            for (int t = 0; t < 2; t++)
     302            {
     303                int i = data->current[t].piece->GetCell().i;
     304                for (int j = 0; j < 7; j++)
     305                    if (data->pairs[i][j].id == 0)
     306                    {
     307                        data->current[t].piece->SetCell(int2(i, j));
     308                        data->current[t].piece->Move(int2(i, j) * 48);
     309                        data->pairs[i][j] = data->current[t];
     310                        data->thumbs->AddCount(data->current[t].id, 1);
     311                        break;
     312                    }
     313            }
     314
     315            data->current[0].id = data->next[0];
     316            data->current[1].id = data->next[1];
     317            data->current[0].piece = new Piece(data->emitter, int2(3, 7),
     318                                               80 + 20 * data->current[0].id);
     319            data->current[1].piece = new Piece(data->emitter, int2(4, 7),
     320                                               80 + 20 * data->current[1].id);
     321            Ticker::Ref(data->current[0].piece);
     322            Ticker::Ref(data->current[1].piece);
     323            data->current[0].piece->SetPos(int2(3, 8) * 48);
     324            data->current[1].piece->SetPos(int2(4, 8) * 48);
     325            data->current[0].piece->Move(data->current[0].piece->GetCell() * 48);
     326            data->current[1].piece->Move(data->current[1].piece->GetCell() * 48);
     327            data->next[0] = GetRandomId();
     328            data->next[1] = GetRandomId();
     329            data->rotation = 0;
     330
     331            Resolve();
     332        }
     333        break;
     334    }
    205335    }
    206336
     
    215345    Scene::GetDefault()->AddTile((data->board << 16) | 0,
    216346                                 position.x, position.y, 1, 0);
     347
     348    switch (data->game)
     349    {
     350    case GAME_HUNT:
     351        break;
     352    case GAME_FUSION:
     353        Scene::GetDefault()->AddTile((data->icons << 16) | (data->next[0] - 1),
     354                                     350, 400, 11, 0);
     355        Scene::GetDefault()->AddTile((data->icons << 16) | (data->next[1] - 1),
     356                                     380, 400, 11, 0);
     357        break;
     358    }
    217359}
    218360
     
    502644}
    503645
    504 Board::~Board()
    505 {
    506     Input::UntrackMouse(this);
     646int Board::GetRandomId() const
     647{
     648    int max = data->npieces;
     649
     650    if (max > data->minnpieces)
     651        max--;
     652
     653    return 1 + rand() % max;
     654}
     655
     656void Board::Resolve()
     657{
     658    int list[MAX_PIECES][MAX_PIECES];
     659    int count[MAX_PIECES * MAX_PIECES];
    507660
    508661    for (int j = 0; j < data->dim.j; j++)
    509662        for (int i = 0; i < data->dim.i; i++)
    510         {
    511             data->pairs[i][j].piece->SetBelow(NULL);
    512             Ticker::Unref(data->pairs[i][j].piece);
    513         }
     663            list[i][j] = -1;
     664    memset(count, 0, sizeof(count));
     665
     666    int seq = 0, effect = 0;
     667
     668    /* Count connected tiles */
     669    for (int j = 0; j < data->dim.j; j++) for (int i = 0; i < data->dim.i; i++)
     670    {
     671        if (!data->pairs[i][j].id)
     672            continue;
     673
     674        if (data->pairs[i][j].id >= data->maxnpieces)
     675            continue;
     676
     677        if (list[i][j] != -1)
     678            continue;
     679
     680        list[i][j] = seq;
     681        count[seq] = TagNeighbours(list, i, j);
     682        if (count[seq] >= 3)
     683            effect = 1;
     684        seq++;
     685    }
     686
     687    /* Only continue if there is an effect */
     688    if (!effect)
     689        return;
     690
     691    /* Add tiles to a mash; add mash to our list */
     692    Mash *mash = new Mash(data->emitter);
     693    Ticker::Ref(mash);
     694
     695    for (int j = 0; j < data->dim.j; j++) for (int i = 0; i < data->dim.i; i++)
     696    {
     697        if (list[i][j] == -1)
     698            continue;
     699        if (count[list[i][j]] < 3)
     700            continue;
     701
     702        mash->AddPiece(data->pairs[i][j].piece);
     703        data->pairs[i][j].piece = NULL;
     704    }
     705
     706    mash->nextmash = data->mashes;
     707    data->mashes = mash;
     708
     709    /* Create new pieces where necessary */
     710    for (int j = 0; j < data->dim.j; j++) for (int i = 0; i < data->dim.i; i++)
     711    {
     712        if (list[i][j] == -1)
     713            continue;
     714        if (count[list[i][j]] < 3)
     715        {
     716            if (!data->pairs[i][j].piece)
     717                data->pairs[i][j].id = 0;
     718            continue;
     719        }
     720
     721        data->pairs[i][j].id++;
     722        if (data->pairs[i][j].id > data->npieces
     723                && data->pairs[i][j].id <= data->maxnpieces)
     724        {
     725            data->npieces++;
     726            data->thumbs->SetMax(data->npieces);
     727        }
     728        data->pairs[i][j].piece = new Piece(data->emitter, int2(i, j), 80 + 20 * data->pairs[i][j].id);
     729        Ticker::Ref(data->pairs[i][j].piece);
     730        data->pairs[i][j].piece->SetPos(int2(i, j) * 48);
     731        data->thumbs->AddCount(data->pairs[i][j].id, 1);
     732        count[list[i][j]] = 0;
     733        list[i][j] = -1;
     734    }
     735
     736    /* Move everything down */
     737    for (int j = data->dim.j; j--;) for (int i = 0; i < data->dim.i; i++)
     738    {
     739        if (list[i][j] == -1 || data->pairs[i][j].piece)
     740            continue;
     741
     742        for (int j2 = j + 1; j2 < data->dim.j; j2++)
     743        {
     744            data->pairs[i][j2 - 1] = data->pairs[i][j2];
     745            if (data->pairs[i][j2 - 1].id)
     746            {
     747                data->pairs[i][j2 - 1].piece->SetCell(int2(i, j2 - 1));
     748                data->pairs[i][j2 - 1].piece->Move(int2(i, j2 - 1) * 48);
     749            }
     750            list[i][j2 - 1] = list[i][j2];
     751        }
     752
     753        data->pairs[i][data->dim.j - 1].id = 0;
     754        list[i][data->dim.j - 1] = -1;
     755    }
     756
     757    /* Start again (FIXME: make this a while() loop) */
     758    Resolve();
     759}
     760
     761int Board::TagNeighbours(int list[MAX_PIECES][MAX_PIECES], int i, int j)
     762{
     763    int2 const off[] = { int2(-1, 0), int2(1, 0), int2(0, -1), int2(0, 1) };
     764
     765    int count = 1;
     766
     767    for (int n = 0; n < 4; n++)
     768    {
     769        int i2 = i + off[n].i;
     770        int j2 = j + off[n].j;
     771
     772        if (i2 >= 0 && i2 < data->dim.i && j2 >= 0 && j2 < data->dim.j
     773             && data->pairs[i2][j2].id == data->pairs[i][j].id
     774             && list[i2][j2] == -1)
     775        {
     776            list[i2][j2] = list[i][j];
     777            count += TagNeighbours(list, i2, j2);
     778        }
     779    }
     780    return count;
     781}
     782
     783Board::~Board()
     784{
     785    Input::UntrackMouse(this);
     786
     787    switch (data->game)
     788    {
     789    case GAME_HUNT:
     790        for (int j = 0; j < data->dim.j; j++)
     791            for (int i = 0; i < data->dim.i; i++)
     792            {
     793                data->pairs[i][j].piece->SetBelow(NULL);
     794                Ticker::Unref(data->pairs[i][j].piece);
     795            }
     796        break;
     797    case GAME_FUSION:
     798        for (int j = 0; j < data->dim.j; j++)
     799            for (int i = 0; i < data->dim.i; i++)
     800                if (data->pairs[i][j].id)
     801                    Ticker::Unref(data->pairs[i][j].piece);
     802        Ticker::Unref(data->current[0].piece);
     803        Ticker::Unref(data->current[1].piece);
     804        break;
     805    }
    514806    Ticker::Unref(data->thumbs);
    515807    Ticker::Unref(data->scoretext);
     
    525817    Tiler::Deregister(data->board);
    526818    Tiler::Deregister(data->tiles);
     819    Tiler::Deregister(data->icons);
    527820    Sampler::Deregister(data->click);
    528821    Sampler::Deregister(data->whip);
  • trunk/monsterz/board.h

    r314 r352  
    2424{
    2525public:
    26     Board(int2 dim, int npieces);
     26    typedef enum
     27    {
     28        GAME_HUNT,
     29        GAME_FUSION,
     30    }
     31    game_t;
     32
     33    Board(game_t, int2 dim, int minnpieces, int maxnpieces);
    2734    virtual ~Board();
    2835
     
    3138    virtual void TickDraw(float deltams);
    3239
     40    /* Hunt mode */
    3341    void Fill();
    3442    void Switch(int2 cell_a, int2 cell_b);
    3543    int ListMashes(int list[MAX_WIDTH][MAX_HEIGHT]);
    3644    int ListMoves(int list[MAX_WIDTH][MAX_HEIGHT]);
     45
     46    /* Fusion mode */
     47    int GetRandomId() const;
     48    void Resolve();
     49    int TagNeighbours(int list[MAX_PIECES][MAX_PIECES], int i, int j);
    3750
    3851private:
  • trunk/monsterz/interface.cpp

    r350 r352  
    2222#include "title.h"
    2323#include "board.h"
    24 #include "fusion.h"
    2524#include "monsterz.h"
    2625
     
    3635    Title *title;
    3736    Board *board;
    38     Fusion *fusion;
    3937    int screen, tiles;
    4038
     
    5755    data->title = NULL;
    5856    data->board = NULL;
    59     data->fusion = NULL;
    6057    data->screen = Tiler::Register(PNG_BACKGROUND, 640, 480, 1.0f);
    6158    data->tiles = Tiler::Register(PNG_TILES, 48, 48, 1.0f);
     
    8380            Ticker::Unref(data->title);
    8481            data->title = NULL;
    85             data->fusion = new Fusion(int2(6, 8), 3, 12);
    86             Ticker::Ref(data->fusion);
    87 #if 0
    88             data->board = new Board(int2(8, 8), 8);
     82            data->board = new Board(Board::GAME_FUSION, int2(6, 8), 3, 12);
     83            //data->board = new Board(Board::GAME_HUNT, int2(8, 8), 8, 8);
    8984            Ticker::Ref(data->board);
    90 #endif
    9185            data->state = InterfaceData::GAME;
    9286        }
     
    118112    if (data->board)
    119113        Ticker::Unref(data->board);
    120     if (data->fusion)
    121         Ticker::Unref(data->fusion);
    122114    Tiler::Deregister(data->tiles);
    123115    Tiler::Deregister(data->screen);
  • trunk/win32/monsterz.vcxproj

    r340 r352  
    1313  <ItemGroup>
    1414    <ClInclude Include="..\monsterz\board.h" />
    15     <ClInclude Include="..\monsterz\fusion.h" />
    1615    <ClInclude Include="..\monsterz\interface.h" />
    1716    <ClInclude Include="..\monsterz\mash.h" />
     
    5352  <ItemGroup>
    5453    <ClCompile Include="..\monsterz\board.cpp" />
    55     <ClCompile Include="..\monsterz\fusion.cpp" />
    5654    <ClCompile Include="..\monsterz\interface.cpp" />
    5755    <ClCompile Include="..\monsterz\mash.cpp" />
  • trunk/win32/monsterz.vcxproj.filters

    r340 r352  
    8989    </ClInclude>
    9090    <ClInclude Include="..\monsterz\board.h" />
    91     <ClInclude Include="..\monsterz\fusion.h" />
    9291    <ClInclude Include="..\monsterz\interface.h" />
    9392    <ClInclude Include="..\monsterz\piece.h" />
     
    177176    </ClCompile>
    178177    <ClCompile Include="..\monsterz\board.cpp" />
    179     <ClCompile Include="..\monsterz\fusion.cpp" />
    180178    <ClCompile Include="..\monsterz\interface.cpp" />
    181179    <ClCompile Include="..\monsterz\monsterz.cpp" />
Note: See TracChangeset for help on using the changeset viewer.