SPELL_PORTALED_PROJECTILE, "Portaled Projectile",
        SPTYP_TRANSLOCATION,
        SPFLAG_TARGET,
        2,
        50,
        NULL,
        false,
        false
},
{

    case SPELL_PORTALED_PROJECTILE:
        if ( !cast_portaled_projectile(powc, beam) )
            return SPRET_ABORT;
        break;

     SPELL_PORTALED_PROJECTILE,

     SPELL_NO_SPELL,

    // 37 - Book of Mutations //jmf: now Morphology

    // 37 - Book of Morphology

bool cast_portaled_projectile(int pow, bolt& beam);

#include "item_use.h"

bool cast_portaled_projectile(int pow, bolt& beam)
{
    if ( pow > 50 )
        pow = 50;
    if ( grid_is_solid(beam.target_x, beam.target_y) )
    {
        mpr("You can't shoot at gazebos.");
        return false;
    }

    const int idx = get_fire_item_index();
    if ( idx == ENDOFPACK )
    {
        mpr("No suitable missiles.");
        return false;
    }
    throw_it( beam, idx, true, random2(pow/4) );
    return true;
}

bool throw_it(struct bolt &pbolt, int throw_2, monsters *dummy_target = NULL);

bool throw_it(bolt &pbolt, int throw_2, bool teleport=false, int acc_bonus=0);

// Note: If dummy_target is non-NULL, throw_it fakes a bolt and calls
// affect() on the monster's square.

// Note: If teleport is true, assume that pbolt is already set up,
// and teleport the projectile onto the square.

bool throw_it(struct bolt &pbolt, int throw_2, monsters *dummy_target)

bool throw_it(struct bolt &pbolt, int throw_2, bool teleport, int acc_bonus)

    char wepClass, wepType;     // ammo class and type

    if (dummy_target)

    if (!teleport)

        thr.isValid = true;
        thr.isCancel = false;
        thr.tx = dummy_target->x;
        thr.ty = dummy_target->y;
    }
    else
    {

    }

    if (!thr.isValid)
    {
        if (thr.isCancel)
            canned_msg(MSG_OK);
        return (false);

        if (!thr.isValid)
        {
            if (thr.isCancel)
                canned_msg(MSG_OK);
            
            return (false);
        }

    pbolt.set_target(thr);

    if ( !teleport )
        pbolt.set_target(thr);

    wepClass = item.base_type;
    wepType = item.sub_type;

    const object_class_type wepClass = item.base_type;
    const int wepType = item.sub_type;

    // Add in bonus (only from Portaled Projectile for now)
    pbolt.hit += acc_bonus;

    // using copy, since the launched item might be differect (venom blowgun)
    if (dummy_target)
        hit = (affect( pbolt, dummy_target->x, dummy_target->y ) != 0);

    if (teleport)
    {
        // Violating encapsulation somewhat...oh well.
        hit = (affect( pbolt, pbolt.target_x, pbolt.target_y ) != 0);
        beam_drop_object( pbolt, &item, pbolt.target_x, pbolt.target_y );
    }

        // Dropping item copy, since the launched item might be different
        // (e.g. venom blowgun)

        dec_inv_item_quantity( throw_2, 1 );

    dec_inv_item_quantity( throw_2, 1 );

static unsigned int str_to_fire_types( const std::string &str )

static fire_type str_to_fire_types( const std::string &str )

                               FixedVector< int, NUM_FIRE_TYPES > &list )

                               FixedVector< fire_type, NUM_FIRE_TYPES > &list )

    FixedVector<int, NUM_FIRE_TYPES>  fire_order; // order for 'f' command

    FixedVector<fire_type, NUM_FIRE_TYPES> fire_order; // order for 'f' command

    SPELL_PORTALED_PROJECTILE,

        
    case SPELL_PORTALED_PROJECTILE:
        description += "teleports a missile directly to its target, "
            "greatly increasing its accuracy (but not damage.)";
        break;

        if (throw_it(beam, thrown, &mon))

        // throw_it() will decrease quantity by 1
        inc_inv_item_quantity(thrown, 1);
        if (throw_it(beam, thrown, true))

int affect(struct bolt &beam, int x, int y);

int affect(bolt &beam, int x, int y);
void beam_drop_object( bolt &beam, item_def *item, int x, int y );

// helper functions (some of these, esp. affect(), should probably
// be public):

// helper functions (some of these should probably be public):

static void beam_drop_object( bolt &beam, item_def *item, int x, int y );

static void beam_drop_object( bolt &beam, item_def *item, int x, int y )

void beam_drop_object( bolt &beam, item_def *item, int x, int y )