/*  ITVERB.C  no mod for V 1.43  */

#include "advent.h"

/*  Routines to process intransitive verbs  */

VOID PASCAL itverb PROTO((VOID))
{
    switch (G.verb)
    {
        case DROP:
        case SAY:
        case WAVE:
        case CALM:
        case RUB:
        case THROW:
        case FIND:
        case FEED:
        case BREAK:
        case WAKE:
            needobj();
            break;

        case TAKE:
            ivtake();
            break;

        case OPEN:
        case LOCK:
            ivopen();
            break;

        case NOTHING:
            rspeak(54);
            break;

        case ON:
        case OFF:
        case POUR:
            trverb();
            break;

        case WALK:
            actspk(G.verb);
            break;

        case KILL:
            ivkill();
            break;

#if 0
        case EAT:
            iveat();
            break;
#endif

        case DRINK:
            ivdrink();
            break;

        case QUIT:
            ivquit();
            break;

#if 0
        case FILL:
            ivfill();
            break;
#endif

        case BLAST:
            vblast();
            break;

        case SCORE:
            score();
            break;

        case FOO:
            ivfoo();
            break;

        case SUSPEND:
            saveflg = TRUE;
            break;

        case INVENTORY:
            inventory();
            break;

        case SAVE:
            saveadv();
            describe();
            descitem();
            break;

        case RESTORE:
            restore();
            game_restored = FALSE;
            describe();
            descitem();
            break;

        case BRIEF:
        case VERBOSE:
            G.brief_sw = (BRIEF == G.verb);
            rspeak(54);
            break;

        default:
            printf("This intransitive not implemented yet\n");
            break;
    }

    return;
}


/*  CARRY, TAKE etc.  */

VOID PASCAL ivtake PROTO((VOID))
{
    auto     SHORT      anobj, item;

    anobj = 0;
    for (item = 1; item < MAXOBJ; ++item)
    {
        if (G.place[item] == G.loc)
        {
            if (anobj != 0)
            {
                needobj();
                return;
            }

            anobj = item;
        }
    }

    if (anobj == 0 || (dcheck() && G.dflag >= 2))
    {
        needobj();
        return;
    }

    G.object = anobj;
    vtake();
    return;
}


/*  OPEN, LOCK, UNLOCK  */

VOID PASCAL ivopen PROTO((VOID))
{
    if (here(CLAM))
        G.object = CLAM;

    if (here(OYSTER))
        G.object = OYSTER;

    if (at(DOOR))
        G.object = DOOR;

    if (at(GRATE))
        G.object = GRATE;

    if (here(CHAIN))
    {
        if (G.object != 0)
        {
            needobj();
            return;
        }

        G.object = CHAIN;
    }

    if (G.object == 0)
    {
        rspeak(28);
        return;
    }

    vopen();
    return;
}


/*  ATTACK, KILL etc  */

VOID PASCAL ivkill PROTO((VOID))
{
    G.object1 = 0;
    if (dcheck() && G.dflag >= 2)
        G.object = DWARF;

    if (here(SNAKE))
        addobj(SNAKE);

    if (at(DRAGON) && G.prop[DRAGON] == 0)
        addobj(DRAGON);

    if (at(TROLL))
        addobj(TROLL);

    if (here(BEAR) && G.prop[BEAR] == 0)
        addobj(BEAR);

    if (G.object1 != 0)
    {
        needobj();
        return;
    }

    if (G.object != 0)
    {
        vkill();
        return;
    }

    if (here(BIRD) && G.verb != THROW)
        G.object = BIRD;

    if (here(CLAM) || here(OYSTER))
        addobj(CLAM);

    if (G.object1 != 0)
    {
        needobj();
        return;
    }

    vkill();
    return;
}


/*  EAT  */

VOID PASCAL iveat PROTO((VOID))
{
    if (!here(FOOD))
        needobj();
    else
    {
        G.object = FOOD;
        veat();
    }

    return;
}


/*  DRINK  */

VOID PASCAL ivdrink PROTO((VOID))
{
    if (liqloc(G.loc) != WATER && (liq() != WATER || !here(BOTTLE)))
        needobj();
    else
    {
        G.object = WATER;
        vdrink();
    }

    return;
}

/*  QUIT  */

VOID PASCAL ivquit PROTO((VOID))
{
    if (G.gaveup = yes(22, 54, 54))
        normend();

    return;
}

/*  FILL  */

VOID PASCAL ivfill PROTO((VOID))
{
    if (!here(BOTTLE))
        needobj();
    else
    {
        G.object=BOTTLE;
        vfill();
    }

    return;
}

/*  Handle fee fie foe foo...  */

VOID PASCAL ivfoo PROTO((VOID))
{
    auto     SHORT       k, msg;

    k   = vocab(word1, 3000);
    msg = 42;
    if (G.foobar != 1 - k)
    {
        if (G.foobar != 0)
            msg = 151;

        rspeak(msg);
        return;
    }

    G.foobar = k;
    if (k != 4)
        return;

    G.foobar = 0;
    if (G.place[EGGS] == 92 || (toting(EGGS) && G.loc == 92))
    {
        rspeak(msg);
        return;
    }

    if (G.place[EGGS] == 0 && G.place[TROLL] == 0 && G.prop[TROLL] == 0)
        G.prop[TROLL] = 1;

    if (here(EGGS))
        k = 1;
    else
    {
        if (G.loc == 92)
            k = 0;
        else
            k = 2;
    }

    move(EGGS, 92);
    pspeak(EGGS, k);
    return;
}


/*  read etc...  */

VOID PASCAL ivread PROTO((VOID))
{
    if (here(MAGAZINE))
        G.object = MAGAZINE;

    if (here(TABLET))
        G.object = G.object * 100 + TABLET;

    if (here(MESSAGE))
        G.object = G.object * 100 + MESSAGE;

    if (G.object > 100 || G.object == 0 || dark())
    {
        needobj();
        return;
    }

    vread();
    return;
}


/*  INVENTORY  */

VOID PASCAL inventory PROTO((VOID))
{
    auto     SHORT         msg;
    auto     SHORT         i;

    msg = 98;
    for (i = 1; i <= MAXOBJ; ++i)
    {
        if (i == BEAR || !toting(i))
            continue;

        if (msg)
            rspeak(99);

        msg = 0;
        pspeak(i, -1);
    }

    if (toting(BEAR))
        msg = 141;

    if (msg)
        rspeak(msg);

    return;
}


/* ensure uniqueness as objects are searched out for an intransitive verb */

#if ANSI_PROTO
VOID PASCAL addobj(SHORT obj)
#else
VOID PASCAL addobj(obj)
SHORT       obj;
#endif
{
    if (G.object1 != 0)
        return;

    if (G.object != 0)
    {
        G.object1 = -1;
        return;
    }

    G.object = obj;
    return;
}