breakout.cpp

LBreakout a breakout-style arcade game for Linux Requirements: X11, SDL[1.0 or better] Inst

                    break;
                case 's':
                    lev_map[i + 1][j + 1].extra = EX_SLIME;
                    break;
                case 'm':
                    lev_map[i + 1][j + 1].extra = EX_METAL;
                    break;
                case 'b':
                    lev_map[i + 1][j + 1].extra = EX_BALL;
                    break;
                case 'w':
                    lev_map[i + 1][j + 1].extra = EX_WALL;
                    break;
                case 'f':
                    lev_map[i + 1][j + 1].extra = EX_FROZEN;
                    break;
                case 'p':
                    lev_map[i + 1][j + 1].extra = EX_WEAPON;
                    break;
                case '?':
                    lev_map[i + 1][j + 1].extra = EX_RANDOM;
                    break;
                case '>':
                    lev_map[i + 1][j + 1].extra = EX_FAST;
                    break;
                case '<':
                    lev_map[i + 1][j + 1].extra = EX_SLOW;
                    break;
                default:
                    lev_map[i + 1][j + 1].extra = EX_NONE;
                    break;
            }
        }

    // count bricks //
    lev_bricks = 0;
    for (i = 1; i < lev_w - 1; i++)
        for (j = 1; j < lev_h - 1; j++)
            if (lev_map[i][j].type == MAP_BRICK)
                lev_bricks++;
}

HiScore* BreakOut::GetHiScore()
{
    return hiscore;
}

int BreakOut::BuyContinue()
{
    if (player.score < diff[init_data.diff].con_cost) return 0;

    if (init_data.warp && init_data.control != 0)
    	SDL_SetCursor(original_cur);
    	
    SDL_Surface *buffer = SSur_Create(sdl.scr->w, sdl.scr->h, SDL_HWSURFACE);
    SDL_SetColorKey(buffer, 0, 0);

    DR_SETFULLDST(buffer);
    DR_SETFULLSRC(sdl.scr);
    SSur_Blit();
    DR_SETFULLDST(sdl.scr);
    SSur_Fill(0x0);
    DR_SETFULLSRC(buffer);
    SSur_AlphaBlit(128);
    char    str[64];
    sprintf(str, "Continue? y/n");
    SFnt_Write(font, sdl.scr, sdl.scr->w / 2, sdl.scr->h / 2, str, 0);
    sprintf(str, "(costs %i points)", diff[init_data.diff].con_cost);
    SFnt_Write(font, sdl.scr, sdl.scr->w / 2, sdl.scr->h / 2 + font->lh, str, 0);
    Sdl_FullUpdate();

    SDL_Event e;
    int go_on = 1;
    int ret = 0;
    while (go_on && !fast_quit) {
        SDL_WaitEvent(&e);
        if (e.type == SDL_QUIT) {
            fast_quit = 1;
            break;
        }
        if (e.type == SDL_KEYUP)
            switch (e.key.keysym.sym) {
                case SDLK_y:
                    player.lives = 0;
                    player.score -= diff[init_data.diff].con_cost;
                    cur_score = player.score;
                    DR_SETFULLDST(sdl.scr);
                    DR_SETFULLSRC(buffer);
                    SSur_Blit();
                    Sdl_FullUpdate();
                    go_on = 0;
                    ret = 1;
                    break;
                case SDLK_n:
                    go_on = 0;
                    ret = 0;
                    break;
                default:
                    break;
            }
    }
    SDL_FreeSurface(buffer);
    if (init_data.warp && init_data.control != 0)
       	SDL_SetCursor(empty_cur);
#ifdef SOUND
    SndSrv_Play(snd_click, 0);
    if (ret)
        SndSrv_Play(snd_wontgiveup, 1);
#endif
    return ret;
}

int BreakOut::ConfirmQuit()
{
#ifdef SOUND
    SndSrv_Play(snd_click, 0);
#endif

    SDL_Surface *buffer = SSur_Create(sdl.scr->w, sdl.scr->h, SDL_HWSURFACE);
    SDL_SetColorKey(buffer, 0, 0);

    if (init_data.warp && init_data.control != 0)
    	SDL_SetCursor(original_cur);
    	
    DR_SETFULLDST(buffer);
    DR_SETFULLSRC(sdl.scr);
    SSur_Blit();
    DR_SETFULLDST(sdl.scr);
    SSur_Fill(0x0);
    DR_SETFULLSRC(buffer);
    SSur_AlphaBlit(128);
    char    str[64];
    sprintf(str, "Exit game? y/n");
    SFnt_Write(font, sdl.scr, sdl.scr->w / 2, sdl.scr->h / 2, str, 0);
    Sdl_FullUpdate();

    SDL_Event e;
    int go_on = 1;
    int ret = 0;
    while (go_on && !fast_quit) {
        SDL_WaitEvent(&e);
        if (e.type == SDL_QUIT) {
            fast_quit = 1;
            break;
        }
        if (e.type == SDL_KEYUP)
            switch (e.key.keysym.sym) {
                case SDLK_ESCAPE:
                case SDLK_y:
		  case SDLK_SPACE: 	/* kdhong */
                    go_on = 0;
                    ret = 1;
                    break;
                case SDLK_n:
		  case SDLK_RETURN:	/* kdhong */
                    DR_SETFULLDST(sdl.scr);
                    DR_SETFULLSRC(buffer);
                    SSur_Blit();
                    Sdl_FullUpdate();
                    go_on = 0;
                    ret = 0;
                default:
                    break;
            }
    }
    SDL_FreeSurface(buffer);

    if (init_data.warp && init_data.control != 0)
    	SDL_SetCursor(empty_cur);
    	
#ifdef SOUND
    SndSrv_Play(snd_click, 0);
#endif
    return ret;
}

void BreakOut::GameOver()
{
    char    str[64];
    sprintf(str, "Game Over");
    SFnt_Write(font, sdl.scr, sdl.scr->w / 2, sdl.scr->h / 2, str, 0);
    sprintf(str, "Your score: %i\n", player.score);
    SFnt_Write(font, sdl.scr, sdl.scr->w / 2, sdl.scr->h / 2 + font->lh, str, 0);
    Sdl_FullUpdate();

#ifdef SOUND
    if (rand() % 2)
        SndSrv_Play(snd_damn1, 1);
    else
        SndSrv_Play(snd_damn2, 1);
#endif

    Sdl_WaitForClick();
}

// club //
void BreakOut::Club_Reset()
{
    club.len = diff[init_data.diff].club_size;
    club.max_len = diff[init_data.diff].club_max_size;
    club.w = (club.len + 2) * club_cw;
    club.h = club_ch;
    club.y = (lev_h - 2) * brick_h;
    club.x = ((lev_w * brick_w) - club.w) / 2; // centered //
    club.cur_x = club.x;
    club.friction = 0.3;
    club.time = 0;
}

void BreakOut::Club_Hide()
{
    int h = club.h;
    int y = club.y;
    if (cur_extras[EX_WEAPON]) {
        y -= wpn_y_off;
        h = wpn_h;
    }
    DR_SETDST(sdl.scr, club.x, y, club.w, h);
    DR_SETSRC(ss_bkgnd, club.x, y);
    SSur_Blit();
    AddRefreshRect(club.x, y, club.w, h);
}

void BreakOut::Club_Update(int ms)
{
    // old position //
    int old_x = club.x;
    int off_x;
    int moved = 0;
    SDL_Event event;
    int n;

    if (!init_data.warp)
        SDL_GetMouseState(&mx, 0);

    if (cur_extras[EX_FROZEN]) {
        club.v_x = 0;
        if (init_data.warp) {
            // reset the mouse pointer //
            SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE);
            SDL_WarpMouse(sdl.scr->w >> 1, sdl.scr->h >> 1);
            SDL_EventState(SDL_MOUSEMOTION, SDL_ENABLE);
        }
        return;
    }

    if (mouse_moved && init_data.control != 0) {
        if (init_data.warp)
            club.cur_x += mx;
        else
            club.cur_x = mx;
        club.time = 200;
        moved = 1;
    }
    if (keystate[init_data.k_left] && init_data.control != 1) {
        club.cur_x -= init_data.key_speed * ms;
        club.time = 0;
        moved = 1;
    }
    if (keystate[init_data.k_right] && init_data.control != 1) {
        club.cur_x += init_data.key_speed * ms;
        club.time = 0;
        moved = 1;
    }

    if (club.time > 0) {
        club.time -= ms;
        if (club.time < 0) {
            club.time = 0;
            club.v_x = 0.0;
        }
    }
    else
        club.v_x = 0.0;

    if (moved) {
        //check range//
        if (club.cur_x < brick_w)
            club.cur_x = brick_w;
        if (club.cur_x + club.w >= sdl.scr->w - brick_w)
            club.cur_x = sdl.scr->w - brick_w - club.w;

        club.x = (int)club.cur_x;

        off_x = club.x - old_x;

        // speed //
        club.v_x = (float)(off_x) / ms;

        if (mouse_moved) {
            // limit mouse speed //
            if (club.v_x > 5.0) club.v_x = 5.0;
            if (club.v_x < -5.0) club.v_x = -5.0;
            club.v_x /= 5;
            if (init_data.warp) {
                // reset the mouse pointer //
                // although only mouse motion is filtered it seems to handicap button events //
                SDL_EventState(SDL_MOUSEMOTION, SDL_IGNORE);
                SDL_WarpMouse(sdl.scr->w >> 1, sdl.scr->h >> 1);
                SDL_EventState(SDL_MOUSEMOTION, SDL_ENABLE);
            }
        }

        // we need another ball reflection check here //
//        Club_CheckBallReflection(old_x);
    }
}

void BreakOut::Club_Show()
{
    int i, off, cy = 0;
    if (cur_extras[EX_FROZEN])
        cy = club_ch * 2;
    else
        if (cur_extras[EX_SLIME])
            cy = club_ch;
    DR_SETDST(sdl.scr, club.x, club.y, club_cw, club_ch);
    DR_SETSRC(ss_club, 0, cy);
    SSur_Blit();
    for (i = 0, off = club_cw; i < club.len; i++, off += club_cw) {
        DR_SETDST(sdl.scr, club.x + off, club.y, club_cw, club_ch);
        DR_SETSRC(ss_club, club_cw, cy);
        SSur_Blit();
    }
    DR_SETDST(sdl.scr, club.x + off, club.y, club_cw, club_ch);
    DR_SETSRC(ss_club, club_cw * 2, cy);
    SSur_Blit();
    if (cur_extras[EX_WEAPON]) {
        wpn_x = club.x + (club.w - wpn_w) / 2;
        wpn_y = club.y - wpn_y_off;
        DR_SETDST(sdl.scr, wpn_x, wpn_y, wpn_w, wpn_h);
        DR_SETSRC(ss_weapon, (int)wpn_cur * wpn_w, 0);
        SSur_Blit();
        AddRefreshRect(club.x, wpn_y, club.w, wpn_h);
    }
    else
        AddRefreshRect(club.x, club.y, club.w, club.h);
}

void BreakOut::Club_AlphaShow(int a)
{
    int i, off, cy = 0;
    if (cur_extras[EX_FROZEN])
        cy = club_ch * 2;
    else
        if (cur_extras[EX_SLIME])
            cy = club_ch;
    DR_SETDST(sdl.scr, club.x, club.y, club_cw, club_ch);
    DR_SETSRC(ss_club, 0, cy);
    SSur_AlphaBlit(a);
    for (i = 0, off = club_cw; i < club.len; i++, off += club_cw) {
        DR_SETDST(sdl.scr, club.x + off, club.y, club_cw, club_ch);
        DR_SETSRC(ss_club, club_cw, cy);
        SSur_AlphaBlit(a);
    }
    DR_SETDST(sdl.scr, club.x + off, club.y, club_cw, club_ch);
    DR_SETSRC(ss_club, club_cw * 2, cy);
    SSur_AlphaBlit(a);
    if (cur_extras[EX_WEAPON]) {
        wpn_x = club.x + (club.w - wpn_w) / 2;
        wpn_y = club.y - wpn_y_off;
        DR_SETDST(sdl.scr, wpn_x, wpn_y, wpn_w, wpn_h);
        DR_SETSRC(ss_weapon, (int)wpn_cur * wpn_w, 0);
        SSur_AlphaBlit(a);
        AddRefreshRect(club.x, wpn_y, club.w, wpn_h);
    }
    else
        AddRefreshRect(club.x, club.y, club.w, club.h);
}

int BreakOut::Club_Resize(int c)
{
    DL_Entry *e;
    Ball *b;
    if (club.len + c > club.max_len || club.len + c < 1/*diff[init_data.diff].club_size*/)
        return 1;
#ifdef SOUND
    if (c < 0)
        SndSrv_Play(snd_shr, 0);
    else
        SndSrv_Play(snd_exp, 0);
#endif
    // move attached balls
    e = ball_list.head.next;
    while (e != &ball_list.tail) {
        b = (Ball*)e->data;
        if (b->attached) {
            if (c > 0 && b->x + ball_rad > club_cw)
                b->x += club_cw * c;
            else
                if (c < 0 && b->x + ball_rad > club_cw * 3)
                    b->x += club_cw * c;
        }
        e = e->next;
    }

    // resize
    club.cur_x -= (float)(c * club_cw) / 2;
    club.x = (int)club.cur_x;
    club.len += c;
    club.w = (club.len + 2) * club_cw;

    // check range
    if (club.x < brick_w)
        club.x = brick_w;
    if (club.x + club.w > sdl.scr->w - brick_w)
        club.x = sdl.scr->w - brick_w - club.w;
    return 0;
}

void BreakOut::Club_CheckBallReflection(int old_x)
{
    DL_Entry    *e = ball_list.head.next;
    Ball        *b;
    float       bx, by;
    float       cx, cy, cx_off;
    float       vlen, s;
    Vector      a;

    while (e != &ball_list.tail) {
        b = (Ball*)e->data;
        e = e->next;
        /* contact possible */
        if (!(club.v_x == 0 ||
            b->ign_club || b->club_con ||
            b->y + ball_dia - 1 < club.y ||
            b->y > club.y + club.h ||
            (club.v_x < 0 && b->cur_x > club.x + club.w && b->cur_x > old_x + club.w) ||
            (club.v_x > 0 && b->cur_x + ball_dia - 1 < club.x && b->cur_x + ball_dia - 1 < old_x)) ) {

            /* centre of ball */
            bx = b->cur_x + ball_rad;
            by = b->cur_y + ball_rad;

            /* maybe it just hit the club's top */
            if (b->cur_y + ball_dia < club.y + 1 && bx >= club.x + ball_rad - 1 && bx <= club.x + club.w - ball_rad) {
                a.y = 1;
                a.x = 0;
                Club_HandleContact(b, a);
                printf("club hits with top\n");
                break;
            }

            /* horizontal line in the middle of the club */
            cy = club.y + ball_rad;
            /*
                There are two points on C(cx+t|cy) which have a distance of ball_dia from B(bx|by)
                P1(bx+cx_off|cy) and P2(bx-cx_off|cy). t computes as follows:
                                ___
                    ball_dia = |BC|;
                    ball_dia