&& you.unrand_reacts != SPWLD_SHADOW

        && !you.attribute[ATTR_SHADOWS]

    if (you.unrand_reacts == SPWLD_SHADOW)

    if (you.attribute[ATTR_SHADOWS])

my @warnings      = ();

my %found_funcs   = ();

    CHAOTIC  => "bool",

    EVIL     => "bool",

    HOLY     => "bool",

    SPECIAL  => "bool",

    VALUE    => "num",

    flags     => "flags",
    equip_func        => "func",
    unequip_func      => "func",
    world_reacts_func => "func",
    melee_effect_func => "func",
    evoke_func        => "func",

    # Handled later
    $artefact->{flags} = "";

    # Default ego.

        }
    }
    # Fill in function pointers.
    my $enum = $artefact->{_ENUM};
    my $funcs;
    if ($found_funcs{$enum})
    {
        $funcs = $found_funcs{$enum};
        delete($found_funcs{$enum});
    }
    else
    {
        $funcs = {};
    }
    foreach my $func_name ("equip", "unequip", "world_reacts", "melee_effect",
                           "evoke")
    {
        my $val;
        if ($funcs->{$func_name})
        {
            $val = "_${enum}_$func_name";
        }
        else
        {
            $val = "NULL";

        $artefact->{"${func_name}_func"} = $val;

    # Default values.

        }
    }
    my $flags = "";
    my $flag;
    foreach $flag ("SPECIAL", "HOLY", "EVIL", "CHAOTIC")
    {
        if ($artefact->{$flag})
        {
            $flags .= "UNRAND_FLAG_$flag | ";

    }
    if ($flags eq "")
    {
        $flags = "UNRAND_FLAG_NONE";

    else
    {
        chop($flags);
        chop($flags);
        chop($flags);
    }
    $artefact->{flags} = $flags;

    "base_type", "sub_type", "plus", "plus2", "COLOUR",

    "base_type", "sub_type", "plus", "plus2", "COLOUR", "VALUE", "\n",
    "flags",

    "DESC_END"

    "DESC_END", "\n",
    "equip_func", "unequip_func", "world_reacts_func", "melee_effect_func",
    "evoke_func"

#ifndef ART_FUNC_H
#error "art-func.h must be included before art-data.h"
#endif

}
my %valid_func = (
    equip        => 1,
    unequip      => 1,
    world_reacts => 1,
    melee_effect => 1,
    evoke        => 1
);
sub read_funcs
{
    unless(open(INPUT, "<art-func.h"))
    {
        die "Couldn't open art-func.h for reading: $!\n";
    }
    while(<INPUT>)
    {
        if (/^static .* _([A-Z_]+)_(\S+)\s*\(/)
        {
            my $enum = $1;
            my $func = $2;
            if (!$valid_func{$func})
            {
                push(@warnings, "Unrecognized func '$func' for artefact " .
                                "'$enum'");
                next;
            }
            $found_funcs{$enum} ||= {};
            my $func_list = $found_funcs{$enum};
            $func_list->{$func} = 1;
        }
    }
    close(INPUT);
}
sub read_data
{
    unless(open(INPUT, "<art-data.txt"))
    {
        die "Couldn't open art-data.txt for reading: $!\n";
    }
    my $prev_line = "";
    my $curr_art  = {};
    while (<INPUT>)
    {
        chomp;
        $line_num++;
        # Skip comment-only lines
        next if (/^#/);
        # Strip comments.
        s/#.*//;
        # Strip trailing whitspace; leading whitespace indicates the
        # continuation of a string field.
        s/\s*$//;
        if ($_ =~ /^\s*$/)
        {
            if ($prev_line !~ /^\s*$/)
            {
                finish_art($curr_art);
                push(@all_artefacts, $curr_art);
                $curr_art = {};
            }
        }
        else
        {
            process_line($curr_art, $_);
        }
        $prev_line = $_;
    }
    close(INPUT);
    if (keys(%$curr_art) > 0)
    {
        finish_art($curr_art);
        push(@all_artefacts, $curr_art);
    }

die "Couldn't find art-func.h\n"   unless (-e "art-func.h");

die "Can't read art-func.h\n"      unless (-r "art-func.h");

unless(open(INPUT, "<art-data.txt"))
{
    die "Couldn't open art-data.txt for reading: $!\n";
}

my $prev_line = "";
my $curr_art  = {};

read_funcs();
read_data();

while (<INPUT>)

if (keys(%found_funcs) > 0)

    chomp;
    $line_num++;
    # Skip comment-only lines
    next if (/^#/);
    # Strip comments.
    s/#.*//;
    # Strip trailing whitspace; leading whitespace indicates the
    # continuation of a string field.
    s/\s*$//;
    if ($_ =~ /^\s*$/)
    {
        if ($prev_line !~ /^\s*$/)
        {
            finish_art($curr_art);
            push(@all_artefacts, $curr_art);
            $curr_art = {};
        }
    }
    else

    my $key;
    foreach $key (keys(%found_funcs))

        process_line($curr_art, $_);

        push(@warnings, "Funcs for unknown artefact enum $key: " .
                        join(", ", keys(%{$found_funcs{$key}})));

    $prev_line = $_;

close(INPUT);

if (keys(%$curr_art) > 0)

if (@warnings > 0)

    finish_art($curr_art);
    push(@all_artefacts, $curr_art);

    print STDERR "Warning(s):\n";
    my $warn;
    foreach $warn (@warnings)
    {
        print STDERR "$warn\n";
    }
    print STDERR "\n";

    if (is_unrandom_artefact( item ) &&
        item_ident( item, ISFLAG_KNOW_PROPERTIES ))
    {
        const unrandart_entry *entry = get_unrand_entry(item.special);
        valued += entry->value;
    }

        if (is_unrandom_artefact( item ))
        {
            if (item_ident( item, ISFLAG_KNOW_PROPERTIES ))
            {
                switch (item.special)
                {
                case UNRAND_CEREBOV:
                    valued += 2000;
                    break;
                case UNRAND_ASMODEUS:
                    valued += 1500;
                    break;
                case UNRAND_ZONGULDROK:
                    valued += 1250;
                    break;
                case UNRAND_TORMENT:
                case UNRAND_SINGING_SWORD:
                case UNRAND_DISPATER:
                    valued += 1200;
                    break;
                case UNRAND_PRUNE:
                case UNRAND_TROG:
                    valued += 1000;
                    break;
                case UNRAND_CURSES:
                    valued += 800;
                    break;
                case UNRAND_VARIABILITY:
                    valued += 700;
                    break;
                default:
                    valued += 1000;
                    break;
                }
                break;
            }
        }                       // end uniques

    if (is_unrandom_artefact(item))
    {
        unrandart_entry* entry = get_unrand_entry(item.special);
        if (entry->flags & UNRAND_FLAG_HOLY )
            return (true);
    }

    if (is_unrandom_artefact(item))
    {
        unrandart_entry* entry = get_unrand_entry(item.special);
        if (entry->flags & UNRAND_FLAG_EVIL)
            return (true);
    }

        const int item_eff = item_special_wield_effect(item);

                  || item.special == UNRAND_ASMODEUS
                  || item.special == UNRAND_DISPATER
                  || item.special == UNRAND_CEREBOV
                  || item_eff == SPWLD_CURSE
                  || item_eff == SPWLD_TORMENT
                  || item_eff == SPWLD_ZONGULDROK

    if (is_unrandom_artefact(item))
    {
        unrandart_entry* entry = get_unrand_entry(item.special);
        if (entry->flags & UNRAND_FLAG_CHAOTIC)
            return (true);
    }

        {

              hunger += 3 * player_equip_unrand( UNRAND_VAMPIRES_TOOTH );
        }

        {

            hunger += 1 * player_equip_unrand( UNRAND_VAMPIRES_TOOTH );
        }

    if (you.unrand_reacts == SPWLD_SHADOW || you.duration[DUR_BERSERKER])

    if (you.attribute[ATTR_SHADOWS] || you.duration[DUR_BERSERKER])

    unrand_reacts   = SPWLD_NONE;

    unrand_reacts   = 0;

artefact.h: art-data.txt

art-data.h: art-data.txt util/art-data.pl art-func.h

art-data.h: art-data.txt util/art-data.pl
	util/art-data.pl

artefact.h: art-data.txt

art-data.h: art-data.txt util/art-data.pl art-func.h

art-data.h: art-data.txt util/art-data.pl
	util/art-data.pl

artefact.h: art-data.txt

art-data.h: art-data.txt util/art-data.pl art-func.h

art-data.h: art-data.txt util/art-data.pl
	util/art-data.pl

artefact.h: art-data.txt

art-data.h: art-data.txt util/art-data.pl art-func.h

art-data.h: art-data.txt util/art-data.pl
	util/art-data.pl

enum special_wield_type                     // you.special_wield
{
    SPWLD_NONE,                        //    0
    SPWLD_SING,
    SPWLD_TROG,
    SPWLD_CURSE,
    SPWLD_VARIABLE,                    //    4
    SPWLD_PRUNE, //    5 - implicit in it_use3::special_wielded() {dlb}
    SPWLD_TORMENT,                     //    6
    SPWLD_ZONGULDROK,
    SPWLD_POWER,
    SPWLD_WUCAD_MU,                    //    9
    SPWLD_OLGREB,                      //   10
    SPWLD_SHADOW = 50,                 //   50
    SPWLD_NOISE //   further differentiation useless -> removed (jpeg)
};

void use_artefact( unsigned char item_wield_2 );
void use_artefact(item_def &item, bool unmeld = false);

void use_artefact( unsigned char item_wield_2, bool *show_msgs = NULL);
void use_artefact(item_def &item, bool *show_msgs = NULL, bool unmeld = false);

int item_special_wield_effect(const item_def &item);

    }
}
int item_special_wield_effect(const item_def &item)
{
    if (item.base_type != OBJ_WEAPONS || !is_artefact(item))
        return (SPWLD_NONE);
    int i_eff = SPWPN_NORMAL;
    if (is_special_unrandom_artefact( item ))
        i_eff = item.special;
    else if (is_artefact( item ))
        i_eff = artefact_wpn_property(item, ARTP_BRAND);
    else
        i_eff = item.special;
    switch (i_eff)
    {
    case UNRAND_SINGING_SWORD:
        return (SPWLD_SING);
    case UNRAND_TROG:
        return (SPWLD_TROG);
    case UNRAND_CURSES:
        return (SPWLD_CURSE);
    case UNRAND_VARIABILITY:
        return (SPWLD_VARIABLE);
    case UNRAND_TORMENT:
        return (SPWLD_TORMENT);
    case UNRAND_ZONGULDROK:
        return (SPWLD_ZONGULDROK);
    case UNRAND_POWER:
        return (SPWLD_POWER);
    case UNRAND_OLGREB:
        return (SPWLD_OLGREB);
    case UNRAND_WUCAD_MU:
        return (SPWLD_WUCAD_MU);
    default:
        return (SPWLD_NONE);

            you.unrand_reacts = SPWLD_SHADOW;

            you.attribute[ATTR_SHADOWS] = 1;

        const bool was_known = item_type_known(item);

        // Call unrandrt equip func before item is identified.
        if (artefact)
            use_artefact(item_wield_2, &showMsgs);

        // Only used for Singing Sword introducing itself
        // (could be extended to other talking weapons...)
        const std::string old_desc = item.name(DESC_CAP_THE);

        const bool was_known      = item_type_known(item);
              bool known_recurser = false;

            if (!is_special_unrandom_artefact(item))
                special = artefact_wpn_property(item, ARTP_BRAND);
            use_artefact(item_wield_2);

            special = artefact_wpn_property(item, ARTP_BRAND);

            else
                known_recurser = artefact_known_wpn_property(item,
                                                             ARTP_CURSED);

                    break;
                case UNRAND_SINGING_SWORD:
                    if (!was_known)
                    {
                        mprf(MSGCH_TALK, "%s says, "
                             "\"Hi! I'm the Singing Sword!\"",
                             old_desc.c_str());
                    }
                    else
                        mpr("The Singing Sword hums in delight!", MSGCH_TALK);
                    break;
                case UNRAND_TROG:
                    mpr("You feel bloodthirsty!");
                    break;
                case UNRAND_CURSES:
                    mpr("A shiver runs down your spine.");
                    break;
                case UNRAND_PRUNE:
                    mpr("You feel pruney.");
                    break;
                case UNRAND_TORMENT:
                    mpr("A terribly searing pain shoots up your arm!");
                    break;
                case UNRAND_ZONGULDROK:
                    mpr("You sense an extremely unholy aura.");
                    break;
                case UNRAND_POWER:
                    mpr("You sense an aura of extreme power.");
                    break;
                case UNRAND_OLGREB:
                    if (player_can_smell())
                        mpr("You smell chlorine.");
                    else
                        mpr("The staff glows slightly green.");

                case UNRAND_VAMPIRES_TOOTH:
                    if (you.is_undead != US_UNDEAD)
                    {
                        mpr("You feel a strange hunger, and smell blood in "
                            "the air...");
                    }
                    else
                        mpr("You feel strangely empty.");

                case SPWPN_NORMAL:

                    mprf(MSGCH_ERROR, "Unknown weapon brand %d, please file"
                         "a bug report", special);

                break;
            case UNRAND_CURSES:
                if (!item_cursed(item) && one_chance_in(3))
                    do_curse_item(item, false);
                break;
            case UNRAND_WUCAD_MU:
                MiscastEffect(&you, WIELD_MISCAST, SPTYP_DIVINATION, 9, 90,
                              "the Staff of Wucad Mu" );

            if (is_unrandom_artefact(item))
                you.unrand_reacts = item_special_wield_effect(item);

            if (!known_cursed
                && !(was_known && special == UNRAND_CURSES))

            if (!known_cursed && !known_recurser)

        unuse_artefact(item);

        unuse_artefact(item, &mesg);

void use_artefact(unsigned char item_wield_2)

void use_artefact(unsigned char item_wield_2, bool *show_msgs)

    use_artefact( you.inv[ item_wield_2 ] );

    use_artefact( you.inv[ item_wield_2 ], show_msgs );

void use_artefact(item_def &item, bool unmeld)

void use_artefact(item_def &item, bool *show_msgs, bool unmeld)

    // Call unrandart equip function first, so that it can modify the
    // artefact's properties before they're applied.
    if (is_unrandom_artefact( item ))
    {
        const unrandart_entry *entry = get_unrand_entry(item.special);
        if (entry->equip_func)
            entry->equip_func(&item, show_msgs, unmeld);
        if (entry->world_reacts_func)
        {
            equipment_type eq = get_item_slot(item.base_type, item.sub_type);
            you.unrand_reacts |= (1 << eq);
        }
    }

        you.unrand_reacts = SPWLD_NOISE;

        you.attribute[ATTR_NOISES] = 1;

void special_wielded();

void noisy_equipment();
void shadow_lantern_effect();
void unrand_reacts();

#include "misc.h"

#include "monstuff.h"

#include "misc.h"

#include "spells3.h"

#include "spl-mis.h"

void special_wielded()

// TODO: Let artefacts besides weapons generate noise.
void noisy_equipment()

    item_def&  weapon     = *you.weapon();
    const int  old_plus   = weapon.plus;
    const int  old_plus2  = weapon.plus2;
    const char old_colour = weapon.colour;

    if (silenced(you.pos()) || !one_chance_in(20))
        return;
    std::string msg;
    const item_def* weapon = you.weapon();

    switch (you.unrand_reacts)

    if (weapon && weapon->props.exists(ART_NOISE_KEY))

    case SPWLD_SING:
    case SPWLD_NOISE:

        const std::string key = weapon->props[ART_NOISE_KEY];
        msg = getSpeakString(key);
        if (!msg.empty())
        {
            // "Your Singing Sword" sounds disrespectful
            // (as if there could be more than one!)
            msg = replace_all(msg, "@Your_weapon@", "@The_weapon@");
            msg = replace_all(msg, "@your_weapon@", "@the_weapon@");
        }
    }
    else

        if (!silenced(you.pos()) && one_chance_in(20))

        msg = getSpeakString("noisy weapon");
        if (!msg.empty())

            std::string msg;

            msg = replace_all(msg, "@Your_weapon@", "Your @weapon@");
            msg = replace_all(msg, "@your_weapon@", "your @weapon@");
        }
    }

            if (you.unrand_reacts == SPWLD_SING)
            {
                msg = getSpeakString("Singing Sword");
                if (!msg.empty())
                {
                    // "Your Singing Sword" sounds disrespectful
                    // (as if there could be more than one!)
                    msg = replace_all(msg, "@Your_weapon@", "@The_weapon@");
                    msg = replace_all(msg, "@your_weapon@", "@the_weapon@");
                }
            }
            else // SPWLD_NOISE
            {
                msg = getSpeakString("noisy weapon");
                if (!msg.empty())
                {
                    msg = replace_all(msg, "@Your_weapon@", "Your @weapon@");
                    msg = replace_all(msg, "@your_weapon@", "your @weapon@");
                }
            }

    // Set appropriate channel (will usually be TALK).
    msg_channel_type channel = MSGCH_TALK;

            // Set appropriate channel (will usually be TALK).
            msg_channel_type channel = MSGCH_TALK;

    // Disallow anything with VISUAL in it.
    if (!msg.empty() && msg.find("VISUAL") != std::string::npos)
        msg = "";

            // Disallow anything with VISUAL in it.
            if (!msg.empty() && msg.find("VISUAL") != std::string::npos)
                msg = "";

    if (!msg.empty())
    {
        std::string param = "";
        std::string::size_type pos = msg.find(":");

            if (!msg.empty())
            {
                std::string param = "";
                std::string::size_type pos = msg.find(":");

        if (pos != std::string::npos)
            param = msg.substr(0, pos);

                if (pos != std::string::npos)
                    param = msg.substr(0, pos);

        if (!param.empty())
        {
            bool match = true;

                if (!param.empty())
                {
                    bool match = true;

            if (param == "DANGER")
                channel = MSGCH_DANGER;
            else if (param == "WARN")
                channel = MSGCH_WARN;
            else if (param == "SOUND")
                channel = MSGCH_SOUND;
            else if (param == "PLAIN")
                channel = MSGCH_PLAIN;
            else if (param == "SPELL" || param == "ENCHANT")
                msg = ""; // disallow these as well, channel stays TALK
            else if (param != "TALK")
                match = false;

                    if (param == "DANGER")
                        channel = MSGCH_DANGER;
                    else if (param == "WARN")
                        channel = MSGCH_WARN;
                    else if (param == "SOUND")
                        channel = MSGCH_SOUND;
                    else if (param == "PLAIN")
                        channel = MSGCH_PLAIN;
                    else if (param == "SPELL" || param == "ENCHANT")
                        msg = ""; // disallow these as well, channel stays TALK
                    else if (param != "TALK")
                        match = false;
                    if (match && !msg.empty())
                        msg = msg.substr(pos + 1);
                }
            }
            if (msg.empty()) // give default noises
            {
                if (you.unrand_reacts == SPWLD_SING)
                    msg = "@The_weapon@ sings.";
                else
                {
                    channel = MSGCH_SOUND;
                    msg = "You hear a strange noise.";
                }
            }
            // replace weapon references
            msg = replace_all(msg, "@The_weapon@", "The @weapon@");
            msg = replace_all(msg, "@the_weapon@", "the @weapon@");
            msg = replace_all(msg, "@weapon@", weapon.name(DESC_BASENAME));
            // replace references to player name and god
            msg = replace_all(msg, "@player_name@", you.your_name);
            msg = replace_all(msg, "@player_god@",
                              you.religion == GOD_NO_GOD ? "atheism"
                                : god_name(you.religion, coinflip()));
            mpr(msg.c_str(), channel);
            noisy(25, you.pos());

            if (match && !msg.empty())
                msg = msg.substr(pos + 1);

        break;

    case SPWLD_CURSE:
        if (one_chance_in(30))
            curse_an_item(false);
        break;
    case SPWLD_VARIABLE:
        do_uncurse_item(weapon);
        if (x_chance_in_y(2, 5))
            weapon.plus  += (coinflip() ? +1 : -1);
        if (x_chance_in_y(2, 5))
            weapon.plus2 += (coinflip() ? +1 : -1);

    if (msg.empty()) // give default noises
    {
        channel = MSGCH_SOUND;
        msg = "You hear a strange noise.";
    }

        if (weapon.plus < -4)
            weapon.plus = -4;
        else if (weapon.plus > 16)
            weapon.plus = 16;

    // replace weapon references
    if (weapon)
    {
        msg = replace_all(msg, "@The_weapon@", "The @weapon@");
        msg = replace_all(msg, "@the_weapon@", "the @weapon@");
        msg = replace_all(msg, "@weapon@", weapon->name(DESC_BASENAME));
    }
    // replace references to player name and god
    msg = replace_all(msg, "@player_name@", you.your_name);
    msg = replace_all(msg, "@player_god@",
                      you.religion == GOD_NO_GOD ? "atheism"
                      : god_name(you.religion, coinflip()));

        if (weapon.plus2 < -4)
            weapon.plus2 = -4;
        else if (weapon.plus2 > 16)
            weapon.plus2 = 16;

    mpr(msg.c_str(), channel);

        weapon.colour = random_colour();
        break;

    noisy(25, you.pos());
}

    case SPWLD_TORMENT:
        if (one_chance_in(200))
        {
            torment(TORMENT_SPWLD, you.pos());
            did_god_conduct(DID_UNHOLY, 1);
        }
        break;

void shadow_lantern_effect()
{
    if (x_chance_in_y(player_spec_death() + 1, 8))
    {
        create_monster(mgen_data(MONS_SHADOW, BEH_FRIENDLY, 2, 0, you.pos(),
                                 MHITYOU));
        did_god_conduct(DID_NECROMANCY, 1);
    }
}
 
void unrand_reacts()
{
    item_def*  weapon     = you.weapon();
    const int  old_plus   = weapon ? weapon->plus   : 0;
    const int  old_plus2  = weapon ? weapon->plus2  : 0;

    case SPWLD_ZONGULDROK:
        if (one_chance_in(5))

    for (int i = 0; i < NUM_EQUIP; i++)
    {
        if (you.unrand_reacts & (1 << i))

            animate_dead(&you, 1 + random2(3), BEH_HOSTILE, MHITYOU);
            did_god_conduct(DID_NECROMANCY, 1);
        }
        break;
    case SPWLD_POWER:
        weapon.plus  = stepdown_value( -4 + (you.hp / 5), 4, 4, 4, 20 );
        weapon.plus2 = weapon.plus;
        break;
    case SPWLD_OLGREB:
        // Giving Olgreb's staff a little lift since staves of poison have
        // been made better. -- bwr
        weapon.plus  = you.skills[SK_POISON_MAGIC] / 3;
        weapon.plus2 = weapon.plus;
        break;
    case SPWLD_WUCAD_MU:
        weapon.plus  = std::min(you.intel - 3, 22);
        weapon.plus2 = std::min(you.intel / 2, 13);
        break;

            item_def&        item  = you.inv[you.equip[i]];
            unrandart_entry* entry = get_unrand_entry(item.special);

    case SPWLD_SHADOW:
        if (x_chance_in_y(player_spec_death() + 1, 8))
        {
            create_monster(
                mgen_data(MONS_SHADOW, BEH_FRIENDLY, 2, 0, you.pos(), MHITYOU));
            did_god_conduct(DID_NECROMANCY, 1);

            entry->world_reacts_func(&item);

        break;
    //case SPWLD_PRUNE:
    default:
        return;

    if (old_plus != weapon.plus
        || old_plus2 != weapon.plus2
        || old_colour != weapon.colour)
    {

    if (weapon && (old_plus != weapon->plus || old_plus2 != weapon->plus2))

    }

static bool evoke_sceptre_of_asmodeus()
{
    bool rc = true;
    if (one_chance_in(21))
        rc = false;
    else if (one_chance_in(20))
    {
        // Summon devils, maybe a Fiend.
        const monster_type mon = (one_chance_in(4) ? MONS_FIEND :
                                     summon_any_demon(DEMON_COMMON));
        const bool good_summon = create_monster(
                                     mgen_data::hostile_at(mon,
                                         you.pos(), 6, 0, true)) != -1;
        if (good_summon)
        {
            if (mon == MONS_FIEND)
                mpr("\"Your arrogance condemns you, mortal!\"");
            else
                mpr("The Sceptre summons one of its servants.");
        }
        else
            mpr("The air shimmers briefly.");
    }
    else
    {
        // Cast a destructive spell.
        const spell_type spl = static_cast<spell_type>(
            random_choose_weighted(114, SPELL_BOLT_OF_FIRE,
                                   57,  SPELL_LIGHTNING_BOLT,
                                   57,  SPELL_BOLT_OF_DRAINING,
                                   12,  SPELL_HELLFIRE,
                                   0));
        your_spells(spl, you.skills[SK_EVOCATIONS] * 8, false);
    }
    return (rc);
}

    int power = 0;

    switch (item.base_type)

    const unrandart_entry *entry = is_unrandom_artefact(item)
        ? get_unrand_entry(item.special) : NULL;
    if (entry && entry->evoke_func)
    {
        ASSERT(item_is_equipped(item));
        if (entry->evoke_func(&item, &pract, &did_work, &unevokable))
            return (did_work);
    }
    else switch (item.base_type)

                pract = 0;

                pract    = 0;

        else if (is_unrandom_artefact(item))
        {
            switch (item.special)
            {
            case UNRAND_DISPATER:
                if (you.duration[DUR_DEATHS_DOOR] || !enough_hp(11, true)
                    || !enough_mp(5, true))
                {
                    break;
                }
                mpr("You feel the staff feeding on your energy!");
                dec_hp( 5 + random2avg(19, 2), false, "Staff of Dispater" );
                dec_mp( 2 + random2avg(5, 2) );
                make_hungry(100, false, true);
                power = you.skills[SK_EVOCATIONS] * 8;
                your_spells( SPELL_HELLFIRE, power, false );
                pract = (coinflip() ? 2 : 1);
                did_work = true;
                break;
            case UNRAND_ASMODEUS:
                if (evoke_sceptre_of_asmodeus())
                {
                    make_hungry(200, false, true);
                    did_work = true;
                    pract = 1;
                }
                break;
            case UNRAND_OLGREB:
                if (!enough_mp( 4, true )
                    || you.skills[SK_EVOCATIONS] < random2(6))
                {
                    break;
                }
                dec_mp(4);
                make_hungry(50, false, true);
                pract = 1;
                did_work = true;
                power = 10 + you.skills[SK_EVOCATIONS] * 8;
                your_spells( SPELL_OLGREBS_TOXIC_RADIANCE, power, false );
                if (x_chance_in_y(you.skills[SK_EVOCATIONS] + 1, 10))
                    your_spells( SPELL_VENOM_BOLT, power, false );
                break;
            case UNRAND_WUCAD_MU:
                if (you.magic_points == you.max_magic_points
                    || you.skills[SK_EVOCATIONS] < random2(25))
                {
                    break;
                }
                mpr("Magical energy flows into your mind!");
                inc_mp( 3 + random2(5) + you.skills[SK_EVOCATIONS] / 3, false );
                make_hungry(50, false, true);
                pract = 1;
                did_work = true;
                if (one_chance_in(3))
                {
                    // NH_NEVER prevents "nothing happens" messages.
                    MiscastEffect( &you, NON_MONSTER, SPTYP_DIVINATION,
                                   random2(9), random2(70),
                                   "the Staff of Wucad Mu", NH_NEVER );
                }
                break;
            default:
                unevokable = true;
                break;
            }
        }

void unuse_artefact(const item_def &item);

void unuse_artefact(const item_def &item, bool *show_msgs = NULL);

    you.unrand_reacts    = SPWLD_NONE;

    // Call this first, so that the unrandart func can set showMsgs to
    // false if it does its own message handling.
    if (is_artefact( item ))
        unuse_artefact(item, &showMsgs);

        you.attribute[ATTR_SHADOWS] = 0;

        if (is_unrandom_artefact( item ))
        {
            switch (item.special)
            {
            case UNRAND_SINGING_SWORD:
                if (showMsgs)
                    mpr("The Singing Sword sighs.", MSGCH_TALK);
                break;
            case UNRAND_TROG:
                if (showMsgs)
                    mpr("You feel less violent.");
                break;
            case UNRAND_OLGREB:
                item.plus  = 0;
                item.plus2 = 0;
                break;
            case UNRAND_WUCAD_MU:
                item.plus  = 0;
                item.plus2 = 0;
                MiscastEffect( &you, WIELD_MISCAST, SPTYP_DIVINATION, 9, 90,
                               "the Staff of Wucad Mu" );
                break;
            default:
                break;
            }
            return (true);
        }

        if (is_artefact( item ))
            unuse_artefact(item);

void unuse_artefact(const item_def &item)

void unuse_artefact(const item_def &item, bool *show_msgs)

        you.unrand_reacts = SPWLD_NONE;

        you.attribute[ATTR_NOISES]  = 0;
    if (is_unrandom_artefact( item ))
    {
        const unrandart_entry *entry = get_unrand_entry(item.special);
        if (entry->unequip_func)
            entry->unequip_func(&item, show_msgs);
        if (entry->world_reacts_func)
        {
            equipment_type eq = get_item_slot(item.base_type, item.sub_type);
            you.unrand_reacts &= ~(1 << eq);
        }
    }

    if (is_unrandom_artefact(item))
    {
        const unrandart_entry* entry = get_unrand_entry(item.special);
        if (entry->evoke_func && item_type_known(item))
        {
            if (item_is_equipped(item))
                return (true);
            if (msg)
                mpr("That item can only be evoked when wielded.");
            return (false);
        }
        // Unrandart might still be evokable (e.g., reaching)
    }

        if (is_unrandom_artefact(item))
        {
            switch (item.special)
            {
            case UNRAND_ASMODEUS:
            case UNRAND_WUCAD_MU:
            case UNRAND_DISPATER:
            case UNRAND_OLGREB:
                if (!wielded)
                {
                    if (msg)
                        mpr("That item can only be evoked when wielded.");
                    return (false);
                }
                return (true);

            default:
                return (false);
            }
        }

    int       spwld;         // Special wield effects?

    // If weapon is a randart, its properties.

    // If weapon is an artefact, its properties.

    // If a weapon is an unrandart, its unrandart entry.
    unrandart_entry *unrand_entry;

    void check_special_wield_effects();

    bool check_unrand_effects(bool mondied = false);

      wpn_skill(SK_UNARMED_COMBAT), hands(HANDS_ONE),
      spwld(SPWLD_NONE), hand_half_bonus(false),
      art_props(0), attack_verb("bug"), verb_degree(),

      wpn_skill(SK_UNARMED_COMBAT), hands(HANDS_ONE), hand_half_bonus(false),
      art_props(0), unrand_entry(NULL), attack_verb("bug"), verb_degree(),

        if (is_unrandom_artefact( *weapon ))
            unrand_entry = get_unrand_entry(weapon->special);

    {

        spwld = item_special_wield_effect( *weapon );
    }

void melee_attack::check_special_wield_effects()

bool melee_attack::check_unrand_effects(bool mondied)

    switch (spwld)

    if (unrand_entry && unrand_entry->melee_effects_func)

    case SPWLD_TROG:
        if (coinflip())
            attacker->go_berserk(false);
        break;
    case SPWLD_WUCAD_MU:
        if (one_chance_in(9))
        {
            MiscastEffect(attacker, MELEE_MISCAST, SPTYP_DIVINATION,
                          random2(9), random2(70), "the Staff of Wucad Mu");
        }
        break;
    default:
        break;

        unrand_entry->melee_effects_func(weapon, attacker, defender, mondied);
        return (!defender->alive());

    return (false);

    check_special_wield_effects();

    if (spwld == SPWLD_TORMENT && coinflip())

    if (weapon && weapon->base_type == OBJ_WEAPONS)

        torment(TORMENT_SPWLD, you.pos());
        did_god_conduct(DID_UNHOLY, 5);

        if (is_holy_item(*weapon))
            did_god_conduct(DID_HOLY, 1);
        else if (is_demonic(*weapon))
            did_god_conduct(DID_UNHOLY, 1);

    if (spwld == SPWLD_ZONGULDROK || spwld == SPWLD_CURSE)
        did_god_conduct(DID_NECROMANCY, 3);
    if (weapon)
    {
        if (weapon->base_type == OBJ_WEAPONS)
        {
            if (is_holy_item(*weapon))
                did_god_conduct(DID_HOLY, 1);
            else if (is_demonic(*weapon))
                did_god_conduct(DID_UNHOLY, 1);
        }
        if (is_unrandom_artefact(*weapon))
        {
            switch (weapon->special)
            {
            case UNRAND_ASMODEUS:
            case UNRAND_DISPATER:
            case UNRAND_CEREBOV:
                did_god_conduct(DID_UNHOLY, 3);
                break;
            default:
                break;
            }
        }
    }

    mondied = check_unrand_effects(mondied) || mondied;

        if (check_unrand_effects())
            break;

             && you.unrand_reacts != SPWLD_SHADOW)

             && !you.attribute[ATTR_SHADOWS])

        use_artefact(arm, melded);

        use_artefact(arm, NULL, melded);

}
static std::string _art_val_str(const item_def& item)
{
    ASSERT(is_artefact(item));
    return make_stringf("art val: %d, item val: %d",
                        artefact_value(item), item_value(item, true));

                        make_item_unrandart(*item, index);

                            mpr(entry->name);
                        make_item_unrandart(*item, index);

                        {
                            mprf("%s (%s)", entry->name,
                                 _art_val_str(*item).c_str());
                        }

    int i = prompt_invent_item( "Value of which randart?", MT_INVLIST, -1 );

    int i = prompt_invent_item( "Value of which artefact?", MT_INVLIST, -1 );

        if (!is_random_artefact( you.inv[i] ))

        const item_def& item(you.inv[i]);
        if (!is_artefact(item))

            mprf("randart val: %d", artefact_value(you.inv[i]));

            mpr(_art_val_str(item).c_str());

                                        << " (" << _art_val_str(item) << ")"

// Artefacts which make noise can use this key to use a different
// speech database key than the default.
#define ART_NOISE_KEY "art_noise_key"

};
enum unrand_flag_type
{
    UNRAND_FLAG_NONE    = 0x00,
    UNRAND_FLAG_SPECIAL = 0x01,
    UNRAND_FLAG_HOLY    = 0x02,
    UNRAND_FLAG_EVIL    = 0x04,
    UNRAND_FLAG_CHAOTIC = 0x08

    object_class_type base_type;        // class of ura
    int sub_type;        // type of ura
    int plus;        // plus of ura
    int plus2;       // plus2 of ura
    int colour;       // colour of ura

    object_class_type base_type;
    unsigned char     sub_type;
    short             plus;
    short             plus2;
    unsigned char     colour;       // colour of ura
    short         value;
    unsigned char flags;

    void (*equip_func)(item_def* item, bool* show_msgs, bool unmeld);
    void (*unequip_func)(const item_def* item, bool* show_msgs);
    void (*world_reacts_func)(item_def* item);
    void (*melee_effects_func)(item_def* item, actor* attacker,
                               actor* defender, bool mondied);
    bool (*evoke_func)(item_def *item, int* pract, bool* did_work,
                       bool* unevokable);

#include "view.h" // Elemental colours for unrandarts

// Functions defined in art-func.h are referenced in art-data.h
#include "art-func.h"

static FixedVector < bool, NO_UNRANDARTS > unrandart_exist;

            && get_unrand_specialness(item.special) == UNRANDSPEC_SPECIAL);

            && (_seekunrandart(item)->flags & UNRAND_FLAG_SPECIAL));

    if (unrand_index >= UNRAND_SINGING_SWORD
        && unrand_index <= UNRAND_ASMODEUS)

    if (unrand_index < UNRAND_START || unrand_index > UNRAND_LAST)

        return (UNRANDSPEC_SPECIAL);

        return (UNRANDSPEC_NORMAL);

    if (unranddata[unrand_index].flags & UNRAND_FLAG_SPECIAL)
        return (UNRANDSPEC_SPECIAL);

    ASSERT(is_unrandom_artefact(item));

    if (unrand_index == UNRAND_VARIABILITY)
    {
        item.plus  = random_range(-4, 16);
        item.plus2 = random_range(-4, 16);
    }

    ASSERT( is_random_artefact( item ) );

    ASSERT( is_artefact( item ) );

    ASSERT( is_random_artefact( item ) );

    ASSERT( is_artefact( item ) );

/*
 * File:       art-func.h
 * Summary:    Functions non-standard unrandarts uses.
 * Written by: Matthew Cline
 *
 *  Modified for Crawl Reference by $Author$ on $Date$
 */
/*
 * util/art-data.pl scans through this file to grab the functions
 * non-standard unrandarts use and put them into the unranddata structs
 * in art-data.h, so the function names must have the form of
 * _UNRAND_ENUM_func_name() in order to be recognized.
 */ 
#ifdef ART_FUNC_H
#error "art-func.h included twice!"
#endif
#ifdef ART_DATA_H
#error "art-func.h must be included before art-data.h"
#endif
#define ART_FUNC_H
#include "effects.h"  // For Sceptre of Torment tormenting
#include "food.h"     // For evokes
#include "monplace.h" // For Sceptre of Asmodeus evoke
#include "monstuff.h" // For Scythe of Curses cursing items
#include "spells3.h"  // For Zonguldrok animating dead
#include "spl-cast.h" // For evokes
#include "spl-mis.h"  // For Staff of Wucad Mu miscasts
/*******************
 * Helper functions.
 *******************/
static void _equip_mpr(bool* show_msgs, const char* msg,
                       msg_channel_type chan = MSGCH_PLAIN)
{
    bool def_show = true;
    if (show_msgs == NULL)
        show_msgs = &def_show;
    if (*show_msgs)
        mpr(msg, chan);
    // Caller shouldn't give any more messages.
    *show_msgs = false;
}
/*******************
 * Unrand functions.
 *******************/
static void _ASMODEUS_melee_effect(item_def* weapon, actor* attacker,
                                   actor* defender, bool mondied)
{
    if (attacker->atype() == ACT_PLAYER)
    {
        did_god_conduct(DID_UNHOLY, 3);
    }
}
static bool _evoke_sceptre_of_asmodeus()
{
    bool rc = true;
    if (one_chance_in(21))
        rc = false;
    else if (one_chance_in(20))
    {
        // Summon devils, maybe a Fiend.
        const monster_type mon = (one_chance_in(4) ? MONS_FIEND :
                                     summon_any_demon(DEMON_COMMON));
        const bool good_summon = create_monster(
                                     mgen_data::hostile_at(mon,
                                         you.pos(), 6, 0, true)) != -1;
        if (good_summon)
        {
            if (mon == MONS_FIEND)
                mpr("\"Your arrogance condemns you, mortal!\"");
            else
                mpr("The Sceptre summons one of its servants.");
        }
        else
            mpr("The air shimmers briefly.");
    }
    else
    {
        // Cast a destructive spell.
        const spell_type spl = static_cast<spell_type>(
            random_choose_weighted(114, SPELL_BOLT_OF_FIRE,
                                   57,  SPELL_LIGHTNING_BOLT,
                                   57,  SPELL_BOLT_OF_DRAINING,
                                   12,  SPELL_HELLFIRE,
                                   0));
        your_spells(spl, you.skills[SK_EVOCATIONS] * 8, false);
    }
    return (rc);
}
static bool _ASMODEUS_evoke(item_def *item, int* pract, bool* did_work,
                            bool* unevokable)
{
    if (_evoke_sceptre_of_asmodeus())
    {
        make_hungry(200, false, true);
        *did_work = true;
        *pract    = 1;
    }
    return (false);
}
////////////////////////////////////////////////////
// XXX: Defender's resistance to fire being temporarily downgraded is
// hardcoded in melee_attack::fire_res_apply_cerebov_downgrade()
static void _CEREBOV_melee_effect(item_def* weapon, actor* attacker,
                                  actor* defender, bool mondied)
{
    if (attacker->atype() == ACT_PLAYER)
    {
        did_god_conduct(DID_UNHOLY, 3);
    }
}
////////////////////////////////////////////////////
static void _CURSES_equip(item_def *item, bool *show_msgs, bool unmeld)
{
    _equip_mpr(show_msgs, "A shiver runs down your spine.");
}
static void _CURSES_world_reacts(item_def *item)
{
    if (one_chance_in(30))
        curse_an_item(false);
}
static void _CURSES_melee_effect(item_def* weapon, actor* attacker,
                                 actor* defender, bool mondied)
{
    if (attacker->atype() == ACT_PLAYER)
    {
        did_god_conduct(DID_NECROMANCY, 3);
    }
}
/////////////////////////////////////////////////////
static void _DISPATER_melee_effect(item_def* weapon, actor* attacker,
                                   actor* defender, bool mondied)
{
    if (attacker->atype() == ACT_PLAYER)
    {
        did_god_conduct(DID_UNHOLY, 3);
    }
}
static bool _DISPATER_evoke(item_def *item, int* pract, bool* did_work,
                            bool* unevokable)
{
    if (you.duration[DUR_DEATHS_DOOR] || !enough_hp(11, true)
        || !enough_mp(5, true))
    {
        return (false);
    }
    mpr("You feel the staff feeding on your energy!");
    dec_hp( 5 + random2avg(19, 2), false, "Staff of Dispater" );
    dec_mp( 2 + random2avg(5, 2) );
    make_hungry(100, false, true);
    int power = you.skills[SK_EVOCATIONS] * 8;
    your_spells( SPELL_HELLFIRE, power, false );
    *pract    = (coinflip() ? 2 : 1);
    *did_work = true;
    return (false);
}
////////////////////////////////////////////////////
// XXX: Staff giving a boost to poison spells is hardocded in
// player_spec_poison()
static void _olgreb_pluses(item_def *item)
{
    // Giving Olgreb's staff a little lift since staves of poison have
    // been made better. -- bwr
    item->plus  = you.skills[SK_POISON_MAGIC] / 3;
    item->plus2 = item->plus;
}
static void _OLGREB_equip(item_def *item, bool *show_msgs, bool unmeld)
{
    if (player_can_smell())
        _equip_mpr(show_msgs, "You smell chlorine.");
    else
        _equip_mpr(show_msgs, "The staff glows a sickly green.");
    _olgreb_pluses(item);
}
static void _OLGREB_unequip(const item_def *item, bool *show_msgs)
{
    if (player_can_smell())
        _equip_mpr(show_msgs, "The smell of chlorine vanishes.");
    else
        _equip_mpr(show_msgs, "The staff's sickly green glow vanishes.");
}
static void _OLGREB_world_reacts(item_def *item)
{
    _olgreb_pluses(item);
}
static bool _OLGREB_evoke(item_def *item, int* pract, bool* did_work,
                          bool* unevokable)
{
    if (!enough_mp( 4, true ) || you.skills[SK_EVOCATIONS] < random2(6))
        return (false);
    dec_mp(4);
    make_hungry(50, false, true);
    *pract    = 1;
    *did_work = true;
    int power = 10 + you.skills[SK_EVOCATIONS] * 8;
    your_spells( SPELL_OLGREBS_TOXIC_RADIANCE, power, false );
    if (x_chance_in_y(you.skills[SK_EVOCATIONS] + 1, 10))
        your_spells( SPELL_VENOM_BOLT, power, false );
    return (false);
}
////////////////////////////////////////////////////
static void _power_pluses(item_def *item)
{
    item->plus  = stepdown_value( -4 + (you.hp / 5), 4, 4, 4, 20 );
    item->plus2 = item->plus;
}
static void _POWER_equip(item_def *item, bool *show_msgs, bool unmeld)
{
    _equip_mpr(show_msgs, "You sense an aura of extreme power.");
    _power_pluses(item);
}
static void _POWER_world_reacts(item_def *item)
{
    _power_pluses(item);
}
////////////////////////////////////////////////////
static void _SINGING_SWORD_equip(item_def *item, bool *show_msgs, bool unmeld)
{
    bool def_show = true;
    if (show_msgs == NULL)
        show_msgs = &def_show;
    if (!*show_msgs)
        return;
    if (item_type_known(*item))
    {
        mprf(MSGCH_TALK, "%s says, \"Hi!  I'm the Singing Sword!\"",
             item->name(DESC_CAP_THE).c_str());
    }
    else
        mpr("The Singing Sword hums in delight!", MSGCH_TALK);
    *show_msgs = false;
    // Make noisy_equipment() use a special speech database key.
    item->props[ART_NOISE_KEY] = "Singing Sword";
}
static void _SINGING_SWORD_unequip(const item_def *item, bool *show_msgs)
{
    _equip_mpr(show_msgs, "The Singing Sword sighs.", MSGCH_TALK);
}
////////////////////////////////////////////////////
static void _PRUNE_equip(item_def *item, bool *show_msgs, bool unmeld)
{
    _equip_mpr(show_msgs, "You feel pruney.");
}
////////////////////////////////////////////////////
static void _TORMENT_equip(item_def *item, bool *show_msgs, bool unmeld)
{
    _equip_mpr(show_msgs, "A terribly searing pain shoots up your arm!");
}
static void _TORMENT_world_reacts(item_def *item)
{
    if (one_chance_in(200))
    {
        torment(TORMENT_SPWLD, you.pos());
        did_god_conduct(DID_UNHOLY, 1);
    }
}
static void _TORMENT_melee_effect(item_def* weapon, actor* attacker,
                                  actor* defender, bool mondied)
{
    if (attacker->atype() == ACT_PLAYER && coinflip())
    {
        torment(TORMENT_SPWLD, you.pos());
        did_god_conduct(DID_UNHOLY, 5);
    }
}
/////////////////////////////////////////////////////
static void _TROG_equip(item_def *item, bool *show_msgs, bool unmeld)
{
    _equip_mpr(show_msgs, "You feel bloodthirsty!");
}
static void _TROG_unequip(const item_def *item, bool *show_msgs)
{
    _equip_mpr(show_msgs, "You feel less violent.");
}
static void _TROG_melee_effect(item_def* weapon, actor* attacker,
                               actor* defender, bool mondied)
{
    if (coinflip())
        attacker->go_berserk(false);
}
////////////////////////////////////////////////////
static void _wucad_miscast(actor* victim, int power,int fail)
{
    MiscastEffect(victim, WIELD_MISCAST, SPTYP_DIVINATION, power, fail,
                  "the Staff of Wucad Mu", NH_NEVER);
}
static void _wucad_pluses(item_def *item)
{
    item->plus  = std::min(you.intel - 3, 22);
    item->plus2 = std::min(you.intel / 2, 13);
}
static void _WUCAD_MU_equip(item_def *item, bool *show_msgs, bool unmeld)
{
    _wucad_miscast(&you, 9, 90);
    _wucad_pluses(item);
}
static void _WUCAD_MU_unequip(const item_def *item, bool *show_msgs)
{
    _wucad_miscast(&you, 9, 90);
}
static void _WUCAD_MU_world_reacts(item_def *item)
{
    _wucad_pluses(item);
}
static void _WUCAD_MU_melee_effect(item_def* weapon, actor* attacker,
                                   actor* defender, bool mondied)
{
    if (one_chance_in(9))
        _wucad_miscast(attacker, random2(9), random2(70));
}
static bool _WUCAD_MU_evoke(item_def *item, int* pract, bool* did_work,
                            bool* unevokable)
{
    if (you.magic_points == you.max_magic_points
        || you.skills[SK_EVOCATIONS] < random2(25))
    {
        return (false);
    }
    mpr("Magical energy flows into your mind!");
    inc_mp( 3 + random2(5) + you.skills[SK_EVOCATIONS] / 3, false );
    make_hungry(50, false, true);
    *pract    = 1;
    *did_work = true;
    if (one_chance_in(3))
        _wucad_miscast(&you, random2(9), random2(70));
    return (false);
}
///////////////////////////////////////////////////
// XXX: Always getting maximal vampiric drain is harcoded in 
// melee_attack::apply_damage_brand()
static void _VAMPIRES_TOOTH_equip(item_def *item, bool *show_msgs, bool unmeld)
{
    if (you.is_undead != US_UNDEAD)
    {
        _equip_mpr(show_msgs,
                   "You feel a strange hunger, and smell blood in the air...");
    }
    else
        _equip_mpr(show_msgs, "You feel strangely empty.");
    // Vampire's Tooth imposes more hunger than a normal vampiric
    // weapon.  Like other vampiric weapons, the hunger is less for
    // vampires than for other species.
    if (you.species != SP_VAMPIRE)
        artefact_set_property(*item, ARTP_METABOLISM, 3);
    else
        artefact_set_property(*item, ARTP_METABOLISM, 1);
}
///////////////////////////////////////////////////
// XXX: Pluses at creation time are hardcoded in make_item_unrandart()
static void _VARIABILITY_world_reacts(item_def *item)
{
    do_uncurse_item(*item);
    if (x_chance_in_y(2, 5))
        item->plus  += (coinflip() ? +1 : -1);
    if (x_chance_in_y(2, 5))
        item->plus2 += (coinflip() ? +1 : -1);
    if (item->plus < -4)
        item->plus = -4;
    else if (item->plus > 16)
        item->plus = 16;
    if (item->plus2 < -4)
        item->plus2 = -4;
    else if (item->plus2 > 16)
        item->plus2 = 16;
}
///////////////////////////////////////////////////
static void _ZONGULDROK_equip(item_def *item, bool *show_msgs, bool unmeld)
{
    _equip_mpr(show_msgs, "You sense an extremely unholy aura.");
}
static void _ZONGULDROK_world_reacts(item_def *item)
{
    if (one_chance_in(5))
    {
        animate_dead(&you, 1 + random2(3), BEH_HOSTILE, MHITYOU);
        did_god_conduct(DID_NECROMANCY, 1);
    }
}
  
static void _ZONGULDROK_melee_effect(item_def* weapon, actor* attacker,
                                     actor* defender, bool mondied)
{
    if (attacker->atype() == ACT_PLAYER)
    {
        did_god_conduct(DID_NECROMANCY, 3);
    }
}
///////////////////////////////////////////////////

# unrand.h

# artefact.h.  C/C++ functions which give unrandarts non-standard
# behaviour are in art-func.h; util/art-data.pl scans art-func.h and
# puts the function names found into art-data.h

# * chaotic:  Is treated as a chaotic item.

# * evil:     Is treated as an evil item.
# * holy:     Is treated as a holy item.

# * special:  Artefact is "special": can't be picked up by monsters,
#             can't be affected by Tukima's Dance, generated less
#             frequently than normal randarts, can be generated in the
#             Abyss if its been lost elsewhere.

# COLOUR:   The colour of the artifact, as listed in defines.h.

# COLOUR:   The colour of the artifact, either as listed in defines.h
#           (e.g., LIGHTRED) or as listed under element_type in view.h
#           (e.g., ETC_FIRE)

# VALUE:    Modifies the value returned by item_value()

VALUE:   1200
BOOL:    noises, special

VALUE:   1000
BOOL:    special

COLOUR:  BLACK # Set on generation

COLOUR:  ETC_RANDOM

VALUE:   700
BOOL:    special

VALUE:   1000
BOOL:    special

BOOL:    tilerim

VALUE:   1000
BOOL:    tilerim, special

VALUE:   1000

BOOL:    poison

BOOL:    poison, special

VALUE:   1000
BOOL:    special

VALUE:   1000
BOOL:    special

BOOL:    cursed

VALUE:   800
CURSED:  3
BOOL:    special, evil

BOOL:    tilerim

VALUE:   1200
BOOL:    tilerim, special, evil

BOOL:    tilerim

VALUE:   1250
BOOL:    tilerim, special, evil

VALUE:   2000

BOOL:    cursed, tilerim

BOOL:    cursed, tilerim, special, evil

BOOL:    tilerim

VALUE:   1200
BOOL:    tilerim, special, evil

BOOL:    tilerim

VALUE:   1500
BOOL:    tilerim, special, evil

#ifndef ART_FUNC_H
#error "art-func.h must be included before art-data.h"
#endif

    OBJ_UNASSIGNED, 250, 250, 250, BLACK, 

    OBJ_UNASSIGNED, 250, 250, 250, BLACK, 0, 
    UNRAND_FLAG_NONE, 

    NULL, NULL, NULL, NULL, NULL, 

    OBJ_WEAPONS, WPN_LONG_SWORD, +7, +7, YELLOW, 

    OBJ_WEAPONS, WPN_LONG_SWORD, +7, +7, YELLOW, 1200, 
    UNRAND_FLAG_SPECIAL, 

        0, 1, 0, 0, 0, 

        0, 0, 0, 0, 0, 

    _SINGING_SWORD_equip, _SINGING_SWORD_unequip, NULL, NULL, NULL, 

    OBJ_WEAPONS, WPN_BATTLEAXE, +3, +11, RED, 

    OBJ_WEAPONS, WPN_BATTLEAXE, +3, +11, RED, 1000, 
    UNRAND_FLAG_SPECIAL, 

    _TROG_equip, _TROG_unequip, NULL, _TROG_melee_effect, NULL, 

    OBJ_WEAPONS, WPN_MACE, 0, 0, BLACK, 

    OBJ_WEAPONS, WPN_MACE, 0, 0, ETC_RANDOM, 700, 
    UNRAND_FLAG_SPECIAL, 

    NULL, NULL, _VARIABILITY_world_reacts, NULL, NULL, 

    OBJ_WEAPONS, WPN_GLAIVE, 0, +12, MAGENTA, 

    OBJ_WEAPONS, WPN_GLAIVE, 0, +12, MAGENTA, 1000, 
    UNRAND_FLAG_SPECIAL, 

    _PRUNE_equip, NULL, NULL, NULL, NULL, 

    OBJ_WEAPONS, WPN_GREAT_SWORD, 0, 0, RED, 

    OBJ_WEAPONS, WPN_GREAT_SWORD, 0, 0, RED, 1000, 
    UNRAND_FLAG_SPECIAL, 

    _POWER_equip, NULL, _POWER_world_reacts, NULL, NULL, 

    OBJ_WEAPONS, WPN_QUARTERSTAFF, 0, 0, GREEN, 

    OBJ_WEAPONS, WPN_QUARTERSTAFF, 0, 0, GREEN, 1000, 
    UNRAND_FLAG_SPECIAL,