#include "sol.h"
VSZASSERT


/* Klondike init stuff */
LRESULT KlondGmProc(GM *pgm, INT msgg, WPARAM wp1, LPARAM wp2);
LRESULT DeckColProc(COL *pcol, INT msgc, WPARAM wp1, LPARAM wp2);
LRESULT DiscardColProc(COL *pcol, INT msgc, WPARAM wp1, LPARAM wp2);
LRESULT TabColProc(COL *pcol, INT msgc, WPARAM wp1, LPARAM wp2);
LRESULT FoundColProc(COL *pcol, INT msgc, WPARAM wp1, LPARAM wp2);



// Imported from Win3.1
BOOL FInitKlondGm()
{
    COLCLS *pcolcls;
    GM *pgm;
    DX dxCrdOffUp;
    DX dyCrdOffUp;
    DX dyCrdOffDn;
    int icol;
    int icrdMax;

    /* KLUDGE to get klondike going */
    FreeGm(pgmCur);

    if((pgm = pgmCur = PAlloc(sizeof(GM)+(13-1)*sizeof(COL *))) == NULL)
        return fFalse;

    pgm->lpfnGmProc = KlondGmProc;
    SendGmMsg(pgm, msggInit, fTrue, 0);
    pgm->icolMax = 13;
    pgm->dqsecScore = 10*4;

    if(!FInitUndo(&pgm->udr))
        goto OOM;

    /* Initialize all the column types but don't position yet */
    for(icol = 0; icol < pgm->icolMax; icol++)
    {
        switch(icol)
        {
        case icolDeck:
            pcolcls = PcolclsCreate(tclsDeck, (COLCLSCREATEFUNC)DeckColProc,
                            0, 0, 2, 1, 1, 10);
            icrdMax = icrdDeckMax;
            break;

        case icolDiscard:
            dxCrdOffUp = dxCrd / 5;
            pcolcls = PcolclsCreate(tclsDiscard, (COLCLSCREATEFUNC)DiscardColProc,
                            dxCrdOffUp, 1, 2, 1, 1, 10);
            icrdMax = icrdDiscardMax;
            break;

        case icolFoundFirst:
            pcolcls = PcolclsCreate(tclsFound, (COLCLSCREATEFUNC)FoundColProc,
                            2, 1, 0, 0, 4, 1);
            Assert(icol - 1 == icolDiscard);
            icrdMax = icrdFoundMax;
            break;

        case icolTabFirst:
            Assert(fHalfCards == 1 || fHalfCards == 0);
            dyCrdOffUp = dyCrd * 4 / 25 - fHalfCards;
            dyCrdOffDn = dyCrd / 25;
            pgm->dyDragMax = dyCrd + 12 * dyCrdOffUp;
            pcolcls = PcolclsCreate(tclsTab, (COLCLSCREATEFUNC)TabColProc,
                        0, dyCrdOffUp, 0, dyCrdOffDn, 1, 1);
            icrdMax = icrdTabMax;
            break;
        }

        if(pcolcls == NULL)
        {
OOM:
            OOM();
            FreeGm(pgmCur);
            Assert(pgmCur == NULL);
            return fFalse;
        }

        if((pgm->rgpcol[icol] = PcolCreate(pcolcls, 0, 0, 0, 0, icrdMax))
            == NULL)
        {
            FreeP(pcolcls);
            goto OOM;
        }
        pgm->icolMac++;
    }

    /* Return without positioning the cards.  This will be done at
     *  WM_SIZE message time.
     */
    return TRUE;
}


/*  PositionCols
 *      Positions the card columns.  Note that this has been revised to
 *      allow card positioning at times other than at the start of the
 *      game.
 */

BOOL PositionCols(void)
{
    DX dxMarg;
    DY dyMarg;
    DX dx;
    X xLeft;
    X xRight;
    Y yTop;
    Y yBot;
    int icol;
    DY dyCrdOffUp;
    DY dyCrdOffDn;
    COL *pcol;
    GM *pgm;
    WORD i;

    /* The game we're using is always the current one */
    pgm = pgmCur;

    /* Before doing the column classes, replace all card X coordinates with
     *  offsets from the column class.
     */
    for (icol = 0 ; icol < 13 ; ++icol)
    {
        /* Get a pointer to this COL structure */
        pcol = pgm->rgpcol[icol];

        /* Loop through all the cards in this column */
        for (i = 0 ; i < pcol->icrdMax ; ++i)
            pcol->rgcrd[i].pt.x -= pcol->rc.xLeft;
    }

    /* Set the card margins.  Note that xCardMargin is computed in SOL.C
     *  at the time the original window is created and is changed on
     *  WM_SIZE messages.
     */
    dxMarg = xCardMargin;
    dyMarg = MulDiv(dyCrd, 5, 100);

    /* Loop through all column types */
    for(icol = 0 ; icol < 13 ; icol++)
    {
        switch(icol)
        {
        case icolDeck:
            xLeft = dxMarg;
            yTop = dyMarg;
            xRight = xLeft + dxCrd + icrdDeckMax / 10 * 2;
            yBot = yTop + dyCrd + icrdDeckMax / 10;
            dx = 0;
            break;

        case icolDiscard:
            xLeft += dxMarg + dxCrd;
            xRight = xLeft + 7 * dxCrd / 5 + icrdDiscardMax / 10 * 2;
            break;

        case icolFoundFirst:
            xLeft = 4 * dxMarg + 3 * dxCrd;
            xRight = xLeft + dxCrd + icrdFoundMax / 4 * 2;
            dx = dxMarg + dxCrd;
            break;

        case icolTabFirst:
            dyCrdOffUp = dyCrd * 4 / 25 - fHalfCards;
            dyCrdOffDn = dyCrd / 25;
            xLeft = dxMarg;
            xRight = xLeft + dxCrd;
            yTop = yBot + 1;
            yBot = yTop + 12 * dyCrdOffUp + dyCrd + 6 * dyCrdOffDn;
            break;
        }

        /* Set this information into the structure */
        pcol = pgm->rgpcol[icol];
        pcol->rc.xLeft = xLeft;
        pcol->rc.yTop = yTop;
        pcol->rc.xRight = xRight;
        pcol->rc.yBot = yBot;

        /* Prepare for the next loop */
        xLeft += dx;
        xRight += dx;
    }

    /* Now that the column offsets are correct, move the cards back */
    for (icol = 0 ; icol < 13 ; ++icol)
    {
        /* Get a pointer to this COL structure */
        pcol = pgm->rgpcol[icol];

        /* Loop through all the cards in this column */
        for (i = 0 ; i < pcol->icrdMax ; ++i)
            pcol->rgcrd[i].pt.x += pcol->rc.xLeft;
    }

    return TRUE;
}




/* TABLEAU col Proc stuff */


BOOL FTabValidMove(COL *pcolDest, COL *pcolSrc)
{
    RA raSrc, raDest;
    SU suSrc, suDest;
    INT icrdSel;
    CD cd;

    Assert(pcolSrc->pmove != NULL);
    icrdSel = pcolSrc->pmove->icrdSel;

    Assert(icrdSel < pcolSrc->icrdMac);
    Assert(pcolSrc->icrdMac > 0);
    cd = pcolSrc->rgcrd[icrdSel].cd;
    raSrc = RaFromCd(cd);
    suSrc = SuFromCd(cd);
    if(raSrc == raKing)
        return (pcolDest->icrdMac == 0);
    if(pcolDest->icrdMac == 0)
        return fFalse;
    if(!pcolDest->rgcrd[pcolDest->icrdMac-1].fUp)
        return fFalse;
    cd = pcolDest->rgcrd[pcolDest->icrdMac-1].cd;
    raDest = RaFromCd(cd);
    suDest = SuFromCd(cd);
    /* invalid moves */
    Assert((suClub ^ suSpade) == 0x03);
    Assert((suHeart ^ suDiamond) == 0x03);
    /* valid moves */
    Assert((suClub ^ suDiamond) < 0x03);
    Assert((suClub ^ suHeart) < 0x03);
    Assert((suSpade ^ suDiamond) < 0x03);
    Assert((suSpade ^ suHeart) < 0x03);

    return (((suSrc ^ suDest) < 0x03) && suSrc != suDest && raSrc+1 == raDest);
}


INT TabHit(COL *pcol, PT *ppt, INT icrdMin)
{
    CRD *pcrd;

    if(pcol->icrdMac > 0 && !(pcrd=&pcol->rgcrd[pcol->icrdMac-1])->fUp && FPtInCrd(pcrd, *ppt))
    {
        SendGmMsg(pgmCur, msggKillUndo, 0, 0);
        SendColMsg(pcol, msgcSel, icrdEnd, 1);
        SendColMsg(pcol, msgcFlip, fTrue, 0);
        SendColMsg(pcol, msgcComputeCrdPos, pcol->icrdMac-1, fFalse);
        SendColMsg(pcol, msgcRender, pcol->icrdMac-1, icrdToEnd);
        SendGmMsg(pgmCur, msggChangeScore, csKlondTabFlip, 0);
        SendColMsg(pcol, msgcEndSel, fFalse, 0);
        /* should I return this? */
        return icrdNil;
    }
    return DefColProc(pcol, msgcHit, (INT_PTR) ppt, icrdMin);
}


BOOL TabDiscardDblClk(COL *pcol, PT *ppt, INT icol)
{
    CRD *pcrd;
    INT icolDest;
    COL *pcolDest;
    BOOL fResult;

    fResult = fFalse;
    if(pcol->icrdMac > 0 && (pcrd=&pcol->rgcrd[pcol->icrdMac-1])->fUp && FPtInCrd(pcrd, *ppt))
    {
        if(pcol->pmove == NULL)
            SendColMsg(pcol, msgcSel, icrdEnd, ccrdToEnd);
        Assert(pcol->pmove != NULL);
        for(icolDest = icolFoundFirst; icolDest < icolFoundFirst+ccolFound; icolDest++)
        {
            pcolDest = pgmCur->rgpcol[icolDest];
            if(SendColMsg(pcolDest, msgcValidMove, (INT_PTR)pcol, 0))
            {
                SendGmMsg(pgmCur, msggSaveUndo, icolDest, icol);
                fResult = SendColMsg(pcolDest, msgcMove, (INT_PTR) pcol, icrdToEnd) &&
                    (fOutlineDrag || SendColMsg(pcol, msgcRender, pcol->icrdMac-1, icrdToEnd)) &&
                    SendGmMsg(pgmCur, msggScore, (INT_PTR) pcolDest, (INT_PTR) pcol);
                if(SendGmMsg(pgmCur, msggIsWinner, 0, 0))
                    SendGmMsg(pgmCur, msggWinner, 0, 0);
                goto Return;
            }
        }
        SendColMsg(pcol, msgcEndSel, fFalse, 0);
    }

Return:
    return fResult;
}



LRESULT TabColProc(COL *pcol, INT msgc, WPARAM wp1, LPARAM wp2)
{

    switch(msgc)
    {
        case msgcHit:
        /* should this go in DefProc? */
            return TabHit(pcol, (PT *)wp1, (INT)wp2);

        case msgcDblClk:
            return TabDiscardDblClk(pcol, (PT *)wp1, (INT)wp2);

        case msgcValidMove:
            return FTabValidMove(pcol, (COL *) wp1);
    }
    return DefColProc(pcol, msgc, wp1, wp2);
}



BOOL FFoundRender(COL *pcol, INT icrdFirst, INT icrdLast)
{
#define dxFoundDn 2
#define dyFoundDn 1

    if(pcol->icrdMac == 0 || icrdLast == 0)
        {
        if(!FGetHdc())
            return fFalse;
        DrawCardExt((PT *)(&pcol->rc.xLeft), 0, GHOST);
        DrawBackExcl(pcol, (PT *) &pcol->rc);
        ReleaseHdc();
        return fTrue;
        }
    else
        return DefColProc(pcol, msgcRender, icrdFirst, icrdLast);
}





BOOL FFoundValidMove(COL *pcolDest, COL *pcolSrc)
{
    RA raSrc;
    SU suSrc;
    INT icrdSel;

    Assert(pcolSrc->pmove != NULL);
    icrdSel = pcolSrc->pmove->icrdSel;
    Assert(icrdSel < pcolSrc->icrdMac);
    Assert(pcolSrc->icrdMac > 0);
    if(pcolSrc->pmove->ccrdSel != 1)
        return fFalse;
    raSrc = RaFromCd(pcolSrc->rgcrd[icrdSel].cd);
    suSrc = SuFromCd(pcolSrc->rgcrd[icrdSel].cd);
    if(pcolDest->icrdMac == 0)
        return(raSrc == raAce);
    return (raSrc == RaFromCd(pcolDest->rgcrd[pcolDest->icrdMac-1].cd)+1 &&
                 suSrc == SuFromCd(pcolDest->rgcrd[pcolDest->icrdMac-1].cd));

}



/* Foundation stuff */
LRESULT FoundColProc(COL *pcol, INT msgc, WPARAM wp1, LPARAM wp2)
{
        switch(msgc)
        {
        case msgcValidMove:
            return FFoundValidMove(pcol, (COL *) wp1);

        case msgcRender:
            return FFoundRender(pcol, (INT)wp1, (INT)wp2);
        }
    return DefColProc(pcol, msgc, wp1, wp2);
}




/* DeckStuff */


BOOL DeckInit(COL *pcol)
{
    CRD *pcrd;
    INT icrd;

    Assert(pcol->icrdMax == icrdDeckMax);
    for(icrd = 0; icrd < icrdDeckMax; icrd++)
        {
        pcrd = &pcol->rgcrd[icrd];
        pcrd->cd = (unsigned short)icrd;
        pcrd->pt = *(PT *)&pcol->rc;
        pcrd->fUp = fFalse;
        }
    pcol->icrdMac = icrdDeckMax;
    SendColMsg(pcol, msgcShuffle, 0, 0);
    SendColMsg(pcol, msgcComputeCrdPos, 0, fFalse);
    return fTrue;
}







INT DeckHit(COL *pcol, PT *ppt, INT icrdMin)
{
    RC rc;
    INT ccrd;

    if(pcol->icrdMac == 0)
    {
        CrdRcFromPt((PT *) &pcol->rc, &rc);
        if(PtInRect((LPRECT) &rc, *(POINT *)ppt))
            return icrdEmpty;
        else
            return icrdNil;
    }
    else
        if(!FPtInCrd(&pcol->rgcrd[pcol->icrdMac-1], *ppt))
            return icrdNil;

    ccrd = ((GetKeyState(VK_SHIFT) & GetKeyState(VK_CONTROL) & GetKeyState(VK_MENU)) < 0) ? 1 : pgmCur->ccrdDeal;

    move.icrdSel = WMax(pcol->icrdMac-ccrd, 0);
    move.ccrdSel = pcol->icrdMac - move.icrdSel;
    Assert(pcol->pmove == NULL);
    pcol->pmove = &move;
    return move.icrdSel;
}


BOOL FDeckRender(COL *pcol, INT icrdFirst, INT icrdLast)
{
    INT mode;
    BOOL f;
    PT pt;

    /* to avoid redrawing the deck multiple times during dealing */
    if(!pgmCur->fDealt && pcol->icrdMac%10 != 9)
        return fTrue;
    if(!FGetHdc())
        return fFalse;
    if(pcol->icrdMac == 0)
        {
        mode = (smd == smdVegas && pgmCur->irep == ccrdDeal-1) ? DECKX : DECKO;
        DrawCardExt((PT *) &pcol->rc, 0, mode);
        DrawBackExcl(pcol, (PT *) &pcol->rc);
        f = fTrue;
        }
    else
        {
        f = DefColProc(pcol, msgcRender, icrdFirst, icrdLast);
        if((icrdLast == pcol->icrdMac || icrdLast == icrdToEnd) && !fHalfCards)
            {
            pt.x = pcol->rgcrd[pcol->icrdMac-1].pt.x+dxCrd-1;
            pt.y = pcol->rgcrd[pcol->icrdMac-1].pt.y+dyCrd-1;
            SetPixel(hdcCur, pt.x-xOrgCur, pt.y-yOrgCur, rgbTable);
            SetPixel(hdcCur, pt.x-1-xOrgCur, pt.y-yOrgCur, rgbTable);
            SetPixel(hdcCur, pt.x-xOrgCur, pt.y-1-yOrgCur, rgbTable);
            }
        }
    ReleaseHdc();
    return f;
}


VOID DrawAnimate(INT cd, PT *ppt, INT iani)
{

    if(!FGetHdc())
        return;
    cdtAnimate(hdcCur, cd, ppt->x, ppt->y, iani);
    ReleaseHdc();
}


BOOL DeckAnimate(COL *pcol, INT iqsec)
{
    INT iani;
    PT pt;

// we removed the older card decks that required Animation. The new
// card deck doesn't involve any animation.

#ifdef UNUSEDCODE

    if(pcol->icrdMac > 0 && !fHalfCards)
        {
        pt = pcol->rgcrd[pcol->icrdMac-1].pt;
        switch(modeFaceDown)
            {
        case IDFACEDOWN3:
            DrawAnimate(IDFACEDOWN3, &pt, iqsec % 4);
            break;
        case IDFACEDOWN10:  /* krazy kastle  */
            DrawAnimate(IDFACEDOWN10, &pt, iqsec % 2);
            break;

        case IDFACEDOWN11:  /* sanflipe */
            if((iani = (iqsec+4) % (50*4)) < 4)
                DrawAnimate(IDFACEDOWN11, &pt, iani);
            else
                /* if a menu overlapps an ani while it is ani'ing, leaves deck
                 bitmap in inconsistent state...  */
                if(iani % 6 == 0)
                    DrawAnimate(IDFACEDOWN11, &pt, 3);
            break;
        case IDFACEDOWN12:  /* SLIME  */
            if((iani = (iqsec+4) % (15*4)) < 4)
                DrawAnimate(IDFACEDOWN12, &pt, iani);
            else
                /* if a menu overlapps an ani while it is ani'ing, leaves deck
                 bitmap in inconsistent state... */
                if(iani % 6 == 0)
                    DrawAnimate(IDFACEDOWN12, &pt, 3);
            break;
            }
        }

#endif

    return fTrue;
}





LRESULT DeckColProc(COL *pcol, INT msgc, WPARAM wp1, LPARAM wp2)
{

    switch(msgc)
        {
    case msgcInit:
        return DeckInit(pcol);
    case msgcValidMove:
    case msgcDrawOutline:
        return fFalse;
    case msgcValidMovePt:
        return icrdNil;
    case msgcHit:                    									
        return DeckHit(pcol, (PT *) wp1, (INT)wp2);
    case msgcRender:
        return FDeckRender(pcol, (INT) wp1, (INT) wp2);
    case msgcValidKbdColSel:
        return !wp1;
    case msgcValidKbdCrdSel:
        return pcol->icrdMac == 0 || wp1 == (WPARAM) pcol->icrdMac-1;
    case msgcAnimate:
        return DeckAnimate(pcol, (INT)wp1);
        }
    return DefColProc(pcol, msgc, wp1, wp2);
}


BOOL DiscardRemove(COL *pcol, COL *pcolDest, LPARAM wp2)
{
        return DefColProc(pcol, msgcRemove, (INT_PTR) pcolDest, wp2);
}


BOOL DiscardMove(COL *pcolDest, COL *pcolSrc, INT icrd)
{
    BOOL fResult;

    SendColMsg(pcolDest, msgcComputeCrdPos, WMax(0, pcolDest->icrdMac-3), fTrue);

    /* YUCK: Default ComputeCrdPos doesn't quite work for discard because
        up cards are handled specially for Discard piles.  To keep
        code size down we have this global hack variable which DefComputeCrdPos
        uses.
    */
    fMegaDiscardHack = fTrue;
    fResult = DefColProc(pcolDest, msgcMove, (INT_PTR) pcolSrc, icrd);
    fMegaDiscardHack = fFalse;
    return fResult;
}



INT DiscardHit(COL *pcol, PT *ppt, INT icrdMin)
{
    return DefColProc(pcol, msgcHit, (INT_PTR) ppt, WMax(0, pcol->icrdMac-1));
}


BOOL DiscardRender(COL *pcol, INT icrdFirst, INT icrdLast)
{
    PT pt;
    INT icrd;
    COLCLS *pcolcls;

    if(DefColProc(pcol, msgcRender, icrdFirst, icrdLast))
        {
        if(FGetHdc())
            {
            pcolcls = pcol->pcolcls;
            for(icrd = pcol->icrdMac-1; icrd >= 0 && icrd >= pcol->icrdMac-2; icrd--)
                {
                pt = pcol->rgcrd[icrd].pt;
                /* 3 is a kludge value here */
                DrawBackground(pt.x+dxCrd-pcolcls->dxUp, pt.y-pcolcls->dyUp*3,
                        			pt.x+dxCrd, pt.y);
                }
            ReleaseHdc();
            }
        return fTrue;
        }
    return fFalse;
}



/* Discard Stuff */
LRESULT DiscardColProc(COL *pcol, INT msgc, WPARAM wp1, LPARAM wp2)
{
    switch(msgc)
        {
    case msgcDblClk:
        return TabDiscardDblClk(pcol, (PT *)wp1, (INT)wp2);
    case msgcHit:
        return DiscardHit(pcol, (PT *)wp1, (INT)wp2);
    case msgcMove:
        return DiscardMove(pcol, (COL *) wp1, (INT)wp2);
    case msgcRemove:
        return DiscardRemove(pcol, (COL *) wp1, wp2);
    case msgcValidMovePt:
        return icrdNil;
    case msgcValidKbdColSel:
        return !wp1;
    case msgcRender:
        return DiscardRender(pcol, (INT)wp1, (INT)wp2);
    case msgcValidKbdCrdSel:
        return pcol->icrdMac == 0 || wp1 == (WPARAM) pcol->icrdMac-1;
        }

    return DefColProc(pcol, msgc, wp1, wp2);
}




/* GAME stuff */

BOOL KlondDeal(GM *pgm, BOOL fZeroScore)
{
    INT icrdSel;
    INT icol;
    INT irw;
    COL *pcolDeck;
    VOID StatString();

    if(!FGetHdc())
        {
        OOM();
        return fFalse;
        }

    EraseScreen();
    for(icol = 0; icol < pgm->icolMac; icol++)
        SendColMsg(pgm->rgpcol[icol], msgcClearCol, 0, 0);

    pcolDeck = pgm->rgpcol[icolDeck];
    SendColMsg(pcolDeck, msgcInit, 0, 0);

    SendGmMsg(pgm, msggKillUndo, 0, 0);
    SendGmMsg(pgm, msggInit, !(smd == smdVegas && fKeepScore) || fZeroScore, 0);

    StatString(idsNil);
    pgm->fDealt = fTrue;
    SendGmMsg(pgm, msggChangeScore, csKlondDeal, 0);
    SendColMsg(pcolDeck, msgcRender, 0, icrdToEnd);
    pgm->fDealt = fFalse;
    for(icol = icolFoundFirst; icol < icolFoundFirst+ccolFound; icol++)
        SendColMsg(pgm->rgpcol[icol], msgcRender, 0, icrdToEnd);

// BabakJ: What the %@!&$* is this?! irw is always less than irw + ccolTab!!!
//         Note: ccolTab if #ifdef'ed as 7
//    for(irw = 0; irw < irw+ccolTab; irw++)

    for(irw = 0; irw < ccolTab; irw++)
        for(icol = irw; icol < ccolTab; icol++)
            {
            icrdSel = SendColMsg(pcolDeck, msgcSel, icrdEnd, 0);
            if(icol == irw)
                SendColMsg(pcolDeck, msgcFlip, fTrue, 0);
            SendColMsg(pgm->rgpcol[icol+icolTabFirst], msgcMove, (INT_PTR) pcolDeck, icrdToEnd);
            SendColMsg(pcolDeck, msgcRender, icrdSel-1, icrdToEnd);
            }
    NewKbdColAbs(pgm, 0);
    pgm->fDealt = fTrue;
    ReleaseHdc();
    return fTrue;
}




BOOL KlondMouseDown(GM *pgm, PT *ppt)
{
    INT icrdSel;
    INT icrd;
    COL *pcolDeck, *pcolDiscard;

    /* Kbd sel already in effect */
    if(FSelOfGm(pgm) || !pgm->fDealt)
        return fFalse;
    /* place the next cards on discard pile */
    if((icrd = SendColMsg(pgm->rgpcol[icolDeck], msgcHit, (INT_PTR) ppt, 0)) != icrdNil)
        {
        pgm->fInput = fTrue;
        pcolDeck = pgm->rgpcol[icolDeck];
        pcolDiscard = pgm->rgpcol[icolDiscard];
        if(icrd == icrdEmpty)
            {
            /* repeat */
            if(SendColMsg(pcolDiscard, msgcNumCards, 0, 0) == 0)
                {
                /* both deck and discard are empty */
                Assert(pcolDeck->pmove == NULL);
                return fFalse;
                }
            if(smd == smdVegas && pgm->irep == ccrdDeal-1)
                return fFalse;

            pgm->irep++;
            pgm->udr.fEndDeck = TRUE;

            return SendGmMsg(pgm, msggSaveUndo, icolDiscard, icolDeck) &&
                SendColMsg(pcolDiscard, msgcSel, 0, ccrdToEnd) != icrdNil &&
                SendColMsg(pcolDiscard, msgcFlip, fFalse, 0) &&
                SendColMsg(pcolDiscard, msgcInvert, 0, 0) &&
                SendGmMsg(pgm, msggScore, (INT_PTR) pcolDeck, (INT_PTR) pcolDiscard) &&
                SendColMsg(pcolDeck, msgcMove, (INT_PTR) pcolDiscard, icrdToEnd) &&
                SendColMsg(pcolDiscard, msgcRender, 0, icrdToEnd);
            }
        else
            {
            icrdSel = pcolDeck->pmove->icrdSel-1;
            /* deal next cards to discard */
            return SendGmMsg(pgm, msggSaveUndo, icolDiscard, icolDeck) &&
                SendColMsg(pcolDeck, msgcFlip, fTrue, 0) &&
                SendColMsg(pcolDeck, msgcInvert, 0, 0) &&
                SendColMsg(pcolDiscard, msgcMove, (INT_PTR)pcolDeck, icrdToEnd) &&
                SendColMsg(pcolDeck, msgcRender, icrdSel, icrdToEnd);
            }
        }
    return DefGmProc(pgm, msggMouseDown, (INT_PTR) ppt, icolDiscard);
}


BOOL KlondIsWinner(GM *pgm)
{
    INT icol;

    for(icol = icolFoundFirst; icol < icolFoundFirst+ccolFound; icol++)
        if(pgm->rgpcol[icol]->icrdMac != icrdFoundMax)
            return fFalse;
    return fTrue;
}


BOOL FAbort()
{
    MSG msg;

    if (MsgWaitForMultipleObjects(0, NULL, FALSE, 5, QS_ALLINPUT) != WAIT_OBJECT_0)
        return FALSE;

    if(PeekMessage(&msg, hwndApp, 0, 0, PM_NOREMOVE))
        {
        switch(msg.message)
            {
        case WM_LBUTTONDOWN:
        case WM_MBUTTONDOWN:
        case WM_RBUTTONDOWN:
        case WM_KEYDOWN:
        case WM_SYSKEYDOWN:
        case WM_MENUSELECT:
        case WM_NCLBUTTONDOWN:
        case WM_NCMBUTTONDOWN:
        case WM_NCRBUTTONDOWN:
            return fTrue;
            }

        PeekMessage(&msg, hwndApp, 0, 0, PM_REMOVE);
        TranslateMessage((LPMSG)&msg);
        DispatchMessage((LPMSG)&msg);
        }
    return fFalse;
}



// Hack for making winning animation faster:
// At cascading time we have: KlondWinner -> DrawCardPt ->cdtDrawExt
// so we set a flag so cdtDrawExt knows it is cascading and does not need
// to round up corners.
BOOL fKlondWinner = FALSE;

BOOL KlondWinner(GM *pgm)
{
    INT icol;
    INT icrd;
    CRD *pcrd;
    PT pt;
    PT ptV;
    INT dxp;
    INT dyp;
    RC rcT;
    INT dsco;
    TCHAR *pch;
    TCHAR szBonus[84];
    VOID StatString();
    UINT cchUsed, cchTmp;

    fKlondWinner = TRUE;

    dsco = (INT)SendGmMsg(pgmCur, msggChangeScore, csKlondWin, 0);
    pgm->udr.fAvail = fFalse;
    pgm->fDealt = fFalse;
    pgm->fWon = fTrue;

    if(smd == smdStandard)
    {
        cchUsed = CchString(szBonus, idsBonus, ARRAYSIZE(szBonus));
        pch =    &szBonus[cchUsed];

        cchTmp = CchDecodeInt(pch, dsco);
        pch += cchTmp;
        cchUsed += cchTmp;

        *pch++ = TEXT(' ');
        cchUsed++;

        *pch++ = TEXT(' ');
        cchUsed++;
    }
    else
    {
        pch = szBonus;
        cchUsed = 0;
    }
    if (cchUsed < ARRAYSIZE(szBonus))
    {
        CchString(pch, idsEndWinner, ARRAYSIZE(szBonus) - cchUsed);
    }

    StatStringSz(szBonus);
    if(!FGetHdc())
        goto ByeNoRel;
    Assert(xOrgCur == 0);
    Assert(yOrgCur == 0);
    GetClientRect(hwndApp, (RECT *)&rcT);
    dxp = rcT.xRight;
    dyp = rcT.yBot - dyCrd;

    for(icrd = icrdFoundMax-1; icrd >= 0; icrd--)
    {
        for(icol = icolFoundFirst; icol < icolFoundFirst+ccolFound; icol++)
        {
            ptV.x = rand() % 110 - 65;  /* favor up and to left */
            if(abs(ptV.x) < 15)  /* kludge so doesn't bounce forever */
                ptV.x = -20;
            ptV.y = rand() % 110 - 75;
            pt = (pcrd = &pgm->rgpcol[icol]->rgcrd[icrd])->pt;

            while(pt.x > -dxCrd && pt.x < dxp)
            {
                DrawCardPt(pcrd, &pt);
                pt.x += ptV.x/10;
                pt.y += ptV.y/10;
                ptV.y+= 3;
                if(pt.y > dyp && ptV.y > 0)
                    ptV.y = -(ptV.y*8)/10;
                if(FAbort())
                    goto ByeBye;
            }

       }
    }


ByeBye:
    ReleaseHdc();
ByeNoRel:
    StatString(idsNil);
    EraseScreen();

    fKlondWinner = FALSE;

    return DefGmProc(pgm, msggWinner, 0, 0);
}

BOOL KlondForceWin(GM *pgm)
{
    INT icol;
    CRD *pcrd;
    COL *pcol;
    RA ra;
    SU su;

    for(icol = 0; icol < pgm->icolMac; icol++)
        SendColMsg(pgm->rgpcol[icol], msgcClearCol, 0, 0);
    for(su = suFirst, icol = icolFoundFirst; icol < icolFoundFirst+ccolFound; icol++, su++)
    {
        Assert(raFirst == 0);
        for(ra = raFirst; ra < raMax; ra++)
        {
            pcol = pgm->rgpcol[icol];
            pcrd = &pcol->rgcrd[ra];
            pcrd->cd = Cd(ra, su);
            pcrd->pt.x = pcol->rc.xLeft;
            pcrd->pt.y = pcol->rc.yTop;
            pcrd->fUp = fTrue;
        }
        pgm->rgpcol[icol]->icrdMac = icrdFoundMax;
    }
    Assert(SendGmMsg(pgm, msggIsWinner, 0, 0));
    return (BOOL)SendGmMsg(pgm, msggWinner, 0, 0);
}


/* Note: assumes is called once a second */
/* if pcolDest == pcolSrc == NULL, then is a timer msg */
BOOL KlondScore(GM *pgm, COL *pcolDest, COL *pcolSrc)
{
    INT cs;
    INT tclsSrc, tclsDest;


    if(smd == smdNone)
        return fTrue;
    cs = csNil;

    Assert(FValidCol(pcolSrc));
    Assert(FValidCol(pcolDest));


    tclsSrc = pcolSrc->pcolcls->tcls;
    tclsDest = pcolDest->pcolcls->tcls;

    switch(tclsDest)
        {
    default:
        return fTrue;
    case tclsDeck:
        if(tclsSrc == tclsDiscard)
            cs = csKlondDeckFlip;
        break;
    case tclsFound:
        switch(tclsSrc)
            {
        default:
            return fTrue;
        case tclsDiscard:
        case tclsTab:
            cs = csKlondFound;
            break;
            }
        break;
    case tclsTab:
        switch(tclsSrc)
            {
        default:
            return fTrue;
        case tclsDiscard:
            cs = csKlondTab;
            break;
        case tclsFound:
            cs = csKlondFoundTab;
            break;
            }
        break;
         }

    SendGmMsg(pgm, msggChangeScore, cs, 0);
    return fTrue;
}

INT mpcsdscoStd[] = { -2, -20, 10, 5, 5, -15,   0,  0};
INT mpcsdscoVegas[] = {0,   0,  5, 0, 0,  -5, -52,  0};


BOOL KlondChangeScore(GM *pgm, INT cs, INT sco)
{
    INT dsco;
    INT csNew;
    INT *pmpcsdsco;
    INT ret;

    if(cs < 0)
        return DefGmProc(pgm, msggChangeScore, cs, sco);
    Assert(FInRange(cs, 0, csKlondMax-1));
    switch(smd)
    {
        default:
            Assert(smd == smdNone);
            return fTrue;
        case smdVegas:
            pmpcsdsco = mpcsdscoVegas;
            break;

        case smdStandard:
            pmpcsdsco = mpcsdscoStd;
            if(cs == csKlondWin && fTimedGame)
            {
    #ifdef DEBUG
                pgm->iqsecScore = WMax(120, pgm->iqsecScore);
    #endif
                /* check if timer set properly */
                if(pgm->iqsecScore >= 120)
                    dsco = (20000/(pgm->iqsecScore>>2))*(350/10);
                else
                    dsco = 0;
                goto DoScore;
            }
            if(cs == csKlondDeckFlip)
            {
                if(ccrdDeal == 1 && pgm->irep >= 1)
                {
                    dsco = -100;
                    goto DoScore;
                }
                else if(ccrdDeal == 3 && pgm->irep > 3)
                    break;
                else
                    return fTrue;
            }
            break;
    }

    dsco = pmpcsdsco[cs];
DoScore:
    csNew = smd == smdVegas ? csDel : csDelPos;
    ret = DefGmProc(pgm, msggChangeScore, csNew, dsco);
    if(cs == csKlondWin)
        return dsco;
    else
        return ret;
}



BOOL KlondTimer(GM *pgm, INT wp1, INT wp2)
{

    if(fTimedGame && pgm->fDealt && pgm->fInput && !fIconic)
    {
        pgm->iqsecScore = WMin(pgm->iqsecScore+1, 0x7ffe);
        if(pgm->icolSel == icolNil)
            SendColMsg(pgm->rgpcol[icolDeck], msgcAnimate, pgm->iqsecScore, 0);
        if(pgm->dqsecScore != 0 && (pgm->iqsecScore)%pgm->dqsecScore == 0)
        {
            SendGmMsg(pgm, msggChangeScore, csKlondTime, 0);
        }
        else
        {
            /* update status bar once as second */
            if(~(pgm->iqsecScore & 0x03))
                StatUpdate();
            return fTrue;
        }
   }
   return fFalse;
}

BOOL KlondDrawStatus(GM *pgm, RC *prc)
{
    TCHAR *pch;
    TCHAR sz[80];
    RC rc;
    LONG rgb;
    BOOL fNegSco;
    SIZE   iSize;
    extern INT iCurrency;
    extern TCHAR szCurrency[];
    HFONT  hFontOld = NULL;
    HFONT  hStatusFont = NULL;


    // store the old font and replace the status font by MS Shell Dlg
    // as it supports FE characters as well as euro characters.

    hStatusFont = CreateFont(-MulDiv(9, GetDeviceCaps(hdcCur, LOGPIXELSY), 72), 0, 0, 0, FW_BOLD, 0, 0, 0, 
                             DEFAULT_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS, DEFAULT_QUALITY, 
                             DEFAULT_PITCH, TEXT("MS Shell Dlg")); 

    if (hStatusFont && hdcCur)
        hFontOld = SelectObject(hdcCur, hStatusFont);

    pch = sz;
    if(fTimedGame)
    {
        pch += CchString(pch, idsTime, ARRAYSIZE(sz));
        pch += CchDecodeInt(pch, (pgm->iqsecScore>>2));
    }
#ifdef DEBUG
    if(!fScreenShots)
    {
        *pch++ = TEXT(' ');
        pch = PszCopy(TEXT("Game # "), pch);
        pch += CchDecodeInt(pch, igmCur);
    }
#endif
    if(pch != sz)
    {
        DrawText(hdcCur, sz, (INT)(pch-sz), (LPRECT) prc, DT_RIGHT|DT_NOCLIP|DT_SINGLELINE);
    }

    if(smd != smdNone)
    {
        rc = *prc;
        GetTextExtentPoint32(hdcCur, sz, (INT)(pch-sz), &iSize);
        rc.xRight -= iSize.cx;
        pch = sz;
        if(fNegSco = pgm->sco < 0)
            *pch++ = TEXT('-');
        if(smd == smdVegas)
        {
            if(!(iCurrency&1))
            {
                pch = PszCopy(szCurrency, pch);
                if(iCurrency == 2)
                    *pch++ = TEXT(' ');
            }
        }
        pch += CchDecodeInt(pch, fNegSco ? -pgm->sco : pgm->sco);
        if(smd == smdVegas)
        {
            if(iCurrency&1)
            {
                if(iCurrency == 3)
                    *pch++ = TEXT(' ');
                pch = PszCopy(szCurrency, pch);
            }
        }
        *pch++ = TEXT(' ');
        rgb = SetTextColor(hdcCur, (!fBW && fNegSco) ? RGB(0xff, 0, 0) : RGB(0, 0, 0));
        DrawText(hdcCur, sz, (INT)(pch-sz), (LPRECT) &rc, DT_RIGHT|DT_NOCLIP|DT_SINGLELINE);
        SetTextColor(hdcCur, rgb);

        GetTextExtentPoint32(hdcCur, sz, (INT)(pch-sz), &iSize);
        rc.xRight -= iSize.cx;
        pch = PszCopy(szScore, sz);
        DrawText(hdcCur, sz, (INT)(pch-sz), (LPRECT) &rc, DT_RIGHT|DT_NOCLIP|DT_SINGLELINE);
        GetTextExtentPoint32(hdcCur, sz, (INT)(pch-sz), &iSize);
        rc.xRight -= iSize.cx;
        rc.xLeft = rc.xRight - 4 * dxChar;
        PatBlt(hdcCur, rc.xLeft, rc.yTop, rc.xRight-rc.xLeft, rc.yBot-rc.yTop, PATCOPY);
        }


    // restore the font
    if (hFontOld)
        SelectObject(hdcCur, hFontOld);

    // close the created font handle
    if (hStatusFont)
        DeleteObject(hStatusFont);

    return fTrue;
}




LRESULT KlondGmProc(GM *pgm, INT msgg, WPARAM wp1, LPARAM wp2)
{
    switch(msgg)
        {
    case msggMouseDblClk:
        if(DefGmProc(pgm, msggMouseDblClk, wp1, wp2))
            return fTrue;
        /* fall thru so works for deck double clicks */
    case msggMouseDown:
        return KlondMouseDown(pgm, (PT *)wp1);

    case msggDeal:
        return KlondDeal(pgm, (BOOL)wp1);

    case msggIsWinner:
        return KlondIsWinner(pgm);

    case msggWinner:
        return KlondWinner(pgm);

    case msggForceWin:
        return KlondForceWin(pgm);

    case msggScore:
        return KlondScore(pgm, (COL *) wp1, (COL *)wp2);

    case msggChangeScore:
        return KlondChangeScore(pgm, (INT)wp1, (INT)wp2);

    case msggTimer:
        return KlondTimer(pgm, (INT)wp1, (INT)wp2);


    case msggDrawStatus:
        return KlondDrawStatus(pgm, (RC *) wp1);
        }
    return DefGmProc(pgm, msgg, wp1, wp2);
}