server/src/magic.c

#ifdef _MSC_VER
#include <platform.h>
#endif
#include "magic.h"

#include "contact.h"
#include "helpers.h"
#include "laws.h"
#include "skill.h"
#include "spells.h"
#include "study.h"

#include <triggers/timeout.h>
#include <triggers/shock.h>
#include <triggers/killunit.h>
#include <triggers/giveitem.h>
#include <triggers/changerace.h>
#include <triggers/clonedied.h>

#include <spells/regioncurse.h>
#include <spells/buildingcurse.h>
#include <spells/unitcurse.h>

#include <kernel/ally.h>
#include <kernel/building.h>
#include <kernel/callbacks.h>
#include <kernel/config.h>
#include <kernel/curse.h>
#include <kernel/equipment.h>
#include <kernel/faction.h>
#include <kernel/item.h>
#include <kernel/messages.h>
#include <kernel/objtypes.h>
#include <kernel/order.h>
#include <kernel/pathfinder.h>
#include <kernel/plane.h>
#include <kernel/pool.h>
#include <kernel/race.h>
#include <kernel/region.h>
#include <kernel/ship.h>
#include <kernel/spell.h>
#include <kernel/spellbook.h>
#include <kernel/terrain.h>
#include <kernel/unit.h>

/* util includes */
#include <kernel/attrib.h>
#include <util/base36.h>
#include <kernel/event.h>
#include <kernel/gamedata.h>
#include <util/language.h>
#include <util/lists.h>
#include <util/log.h>
#include <util/macros.h>
#include <util/param.h>
#include <util/parser.h>
#include <util/rand.h>
#include <util/resolve.h>
#include <util/rng.h>
#include <util/strings.h>
#include <util/umlaut.h>

#include <selist.h>
#include <critbit.h>
#include <storage.h>

/* libc includes */
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <limits.h>
#include <assert.h>
#include <errno.h>
#include <math.h>

const char *magic_school[MAXMAGIETYP] = {
    "gray",
    "illaun",
    "tybied",
    "cerddor",
    "gwyrrd",
    "draig",
    "common"
};

struct combatspell {
    int level;
    const struct spell *sp;
};

typedef struct sc_mage {
    magic_t magietyp;
    int spellpoints;
    int spchange;
    int spellcount;
    struct combatspell combatspells[MAXCOMBATSPELLS];
    struct spellbook *spellbook;
} sc_mage;

void mage_set_spellpoints(sc_mage *m, int aura)
{
    m->spellpoints = aura;
}

int mage_get_spellpoints(const sc_mage *m)
{
    return m ? m->spellpoints : 0;
}

int mage_change_spellpoints(sc_mage *m, int delta)
{
    if (m) {
        int val = m->spellpoints + delta;
        return m->spellpoints = (val >= 0) ? val : m->spellpoints;
    }
    return 0;
}

magic_t mage_get_type(const sc_mage *m)
{
    return m ? m->magietyp : M_GRAY;
}

const spell *mage_get_combatspell(const sc_mage *mage, int nr, int *level)
{
    assert(nr < MAXCOMBATSPELLS);
    if (mage) {
        if (level) {
            *level = mage->combatspells[nr].level;
        }
        return mage->combatspells[nr].sp;
    }
    return NULL;
}

void unit_set_magic(struct unit *u, enum magic_t mtype)
{
    sc_mage *mage = get_mage(u);
    if (mage) {
        mage->magietyp = mtype;
    }
}

magic_t unit_get_magic(const unit *u)
{
    return mage_get_type(get_mage(u));
}

void unit_add_spell(unit * u, struct spell * sp, int level)
{
    sc_mage *mage = get_mage(u);

    if (!mage) {
        log_error("adding new spell %s to a previously non-magical unit %s\n", sp->sname, unitname(u));
        mage = create_mage(u, M_GRAY);
    }
    if (!mage->spellbook) {
        mage->spellbook = create_spellbook(0);
    }
    spellbook_add(mage->spellbook, sp, level);
}

/**
 ** at_icastle
 ** TODO: separate castle-appearance from illusion-effects
 **/

static double MagicRegeneration(void)
{
    return config_get_flt("magic.regeneration", 1.0);
}

static double MagicPower(double force)
{
    if (force > 0) {
        const char *str = config_get("magic.power");
        double value = str ? atof(str) : 1.0;
        return fmax(value * force, 1.0f);
    }
    return 0;
}

typedef struct icastle_data {
    const struct building_type *type;
    int time;
} icastle_data;

static int a_readicastle(variant *var, void *owner, struct gamedata *data)
{
    storage *store = data->store;
    icastle_data *idata = (icastle_data *)var->v;
    char token[32];

    UNUSED_ARG(owner);
    READ_TOK(store, token, sizeof(token));
    if (data->version < ATTRIBOWNER_VERSION) {
        READ_INT(store, NULL);
    }
    READ_INT(store, &idata->time);
    idata->type = bt_find(token);
    return AT_READ_OK;
}

static void
a_writeicastle(const variant *var, const void *owner, struct storage *store)
{
    icastle_data *data = (icastle_data *)var->v;
    UNUSED_ARG(owner);
    WRITE_TOK(store, data->type->_name);
    WRITE_INT(store, data->time);
}

static int a_ageicastle(struct attrib *a, void *owner)
{
    icastle_data *data = (icastle_data *)a->data.v;
    if (data->time <= 0) {
        building *b = (building *)owner;
        region *r = b->region;
        assert(owner == b);
        ADDMSG(&r->msgs, msg_message("icastle_dissolve", "building", b));
        /* remove_building lets units leave the building */
        remove_building(&r->buildings, b);
        return AT_AGE_REMOVE;
    }
    else
        data->time--;
    return AT_AGE_KEEP;
}

static void a_initicastle(variant *var)
{
    var->v = calloc(1, sizeof(icastle_data));
}

attrib_type at_icastle = {
    "zauber_icastle",
    a_initicastle,
    a_free_voidptr,
    a_ageicastle,
    a_writeicastle,
    a_readicastle
};

void make_icastle(building *b, const building_type *btype, int timeout) {
    attrib *a = a_add(&b->attribs, a_new(&at_icastle));
    icastle_data *data = (icastle_data *)a->data.v;
    data->type = btype;
    data->time = timeout;
}

const building_type *icastle_type(const struct attrib *a) {
    icastle_data *icastle = (icastle_data *)a->data.v;
    return icastle->type;
}
/* ------------------------------------------------------------- */

extern int dice(int count, int value);

bool FactionSpells(void)
{
    static int config, rule;
    if (config_changed(&config)) {
        rule = config_get_int("rules.magic.factionlist", 0);
    }
    return rule != 0;
}

int get_spell_level_mage(const spell * sp, void * cbdata)
{
    sc_mage *mage = (sc_mage *)cbdata;
    spellbook *book = get_spellbook(magic_school[mage->magietyp]);
    spellbook_entry *sbe = spellbook_get(book, sp);
    return sbe ? sbe->level : 0;
}

/* ------------------------------------------------------------- */
/* aus dem alten System uebriggebliegene Funktionen, die bei der
 * Umwandlung von alt nach neu gebraucht werden */
 /* ------------------------------------------------------------- */

static void init_mage(variant *var)
{
    var->v = calloc(1, sizeof(sc_mage));
}

static void free_mage(variant *var)
{
    sc_mage *mage = (sc_mage *)var->v;
    if (mage->spellbook) {
        spellbook_clear(mage->spellbook);
        free(mage->spellbook);
    }
    free(mage);
}

static int read_mage(variant *var, void *owner, struct gamedata *data)
{
    storage *store = data->store;
    int i, mtype;
    sc_mage *mage = (sc_mage *)var->v;
    char spname[64];

    UNUSED_ARG(owner);
    READ_INT(store, &mtype);
    mage->magietyp = (magic_t)mtype;
    READ_INT(store, &mage->spellpoints);
    READ_INT(store, &mage->spchange);
    for (i = 0; i != MAXCOMBATSPELLS; ++i) {
        spell *sp = NULL;
        int level = 0;
        READ_TOK(store, spname, sizeof(spname));
        READ_INT(store, &level);

        if (strcmp("none", spname) != 0) {
            sp = find_spell(spname);
            if (!sp) {
                log_error("read_mage: could not find combat spell '%s' in school '%s'\n", spname, magic_school[mage->magietyp]);
            }
        }
        if (sp && level >= 0) {
            int slot = -1;
            if (sp->sptyp & PRECOMBATSPELL)
                slot = 0;
            else if (sp->sptyp & COMBATSPELL)
                slot = 1;
            else if (sp->sptyp & POSTCOMBATSPELL)
                slot = 2;
            if (slot >= 0) {
                mage->combatspells[slot].level = level;
                mage->combatspells[slot].sp = sp;
            }
        }
    }
    if (mage->magietyp == M_GRAY) {
        read_spellbook(&mage->spellbook, data, get_spell_level_mage, mage);
    }
    else {
        read_spellbook(NULL, data, NULL, mage);
    }
    return AT_READ_OK;
}

static void
write_mage(const variant *var, const void *owner, struct storage *store)
{
    int i;
    sc_mage *mage = (sc_mage *)var->v;

    UNUSED_ARG(owner);
    WRITE_INT(store, mage->magietyp);
    WRITE_INT(store, mage->spellpoints);
    WRITE_INT(store, mage->spchange);
    for (i = 0; i != MAXCOMBATSPELLS; ++i) {
        WRITE_TOK(store,
            mage->combatspells[i].sp ? mage->combatspells[i].sp->sname : "none");
        WRITE_INT(store, mage->combatspells[i].level);
    }
    write_spellbook(mage->spellbook, store);
}

attrib_type at_mage = {
    "mage",
    init_mage,
    free_mage,
    NULL,
    write_mage,
    read_mage,
    NULL,
    ATF_UNIQUE
};

bool is_mage(const struct unit * u)
{
    sc_mage *m = get_mage(u);
    return (m && m->magietyp != M_GRAY);
}

sc_mage *get_mage(const unit * u)
{
    attrib *a = a_find(u->attribs, &at_mage);
    if (a) {
        return (sc_mage *)a->data.v;
    }
    return NULL;
}

struct spellbook * mage_get_spellbook(const struct sc_mage * mage) {
    if (mage) {
        return mage->spellbook;
    }
    return NULL;
}

struct spellbook * unit_get_spellbook(const struct unit * u)
{
    sc_mage * mage = get_mage(u);
    if (mage) {
        if (mage->spellbook) {
            return mage->spellbook;
        }
        if (mage->magietyp != M_GRAY) {
            return faction_get_spellbook(u->faction);
        }
    }
    return NULL;
}

#define MAXSPELLS 256

/** update the spellbook with a new level
* Written for E3
*/
void pick_random_spells(faction * f, int level, spellbook * book, int num_spells)
{
    spellbook_entry *commonspells[MAXSPELLS];
    int qi, numspells = 0;
    selist *ql;

    if (level <= f->max_spelllevel) {
        return;
    }

    for (qi = 0, ql = book->spells; ql; selist_advance(&ql, &qi, 1)) {
        spellbook_entry * sbe = (spellbook_entry *)selist_get(ql, qi);
        if (sbe && sbe->level <= level) {
            commonspells[numspells++] = sbe;
        }
    }

    while (numspells > 0 && level > f->max_spelllevel) {
        int i;

        ++f->max_spelllevel;
        for (i = 0; i < num_spells; ++i) {
            int maxspell = numspells;
            int spellno = -1;
            spellbook_entry *sbe = 0;
            while (!sbe && maxspell > 0) {
                spellno = rng_int() % maxspell;
                sbe = commonspells[spellno];
                if (sbe->level > f->max_spelllevel) {
                    /* not going to pick it in this round, move it to the end for later */
                    commonspells[spellno] = commonspells[--maxspell];
                    commonspells[maxspell] = sbe;
                    sbe = 0;
                }
                else {
                    if (f->spellbook) {
                        const spell *sp = spellref_get(&sbe->spref);
                        if (sp && spellbook_get(f->spellbook, sp)) {
                            /* already have this spell, remove it from the list of candidates */
                            commonspells[spellno] = commonspells[--numspells];
                            if (maxspell > numspells) {
                                maxspell = numspells;
                            }
                            sbe = 0;
                        }
                    }
                }
            }

            if (sbe && spellno < maxspell) {
                if (!f->spellbook) {
                    f->spellbook = create_spellbook(0);
                }
                spellbook_add(f->spellbook, spellref_get(&sbe->spref), sbe->level);
                commonspells[spellno] = commonspells[--numspells];
            }
        }
    }
}

/* ------------------------------------------------------------- */
/* Erzeugen eines neuen Magiers */
sc_mage *create_mage(unit * u, magic_t mtyp)
{
    sc_mage *mage;
    attrib *a;

    a = a_find(u->attribs, &at_mage);
    if (a == NULL) {
        a = a_add(&u->attribs, a_new(&at_mage));
    }
    mage = (sc_mage *)a->data.v;
    mage->magietyp = mtyp;
    return mage;
}

/* ------------------------------------------------------------- */
/* Funktionen fuer die Bearbeitung der List-of-known-spells */

int u_hasspell(const unit *u, const struct spell *sp)
{
    spellbook * book = unit_get_spellbook(u);
    spellbook_entry * sbe = book ? spellbook_get(book, sp) : 0;
    if (sbe) {
        return sbe->level <= effskill(u, SK_MAGIC, NULL);
    }
    return 0;
}

/* ------------------------------------------------------------- */
/* Eingestellte Kampfzauberstufe ermitteln */

int get_combatspelllevel(const unit * u, int nr)
{
    int level;
    if (mage_get_combatspell(get_mage(u), nr, &level) != NULL) {
        int maxlevel = effskill(u, SK_MAGIC, NULL);
        if (level > maxlevel) {
            return maxlevel;
        }
        return level;
    }
    return 0;
}

/* ------------------------------------------------------------- */
/* Kampfzauber ermitteln, setzen oder loeschen */

const spell *get_combatspell(const unit * u, int nr)
{
    return mage_get_combatspell(get_mage(u), nr, NULL);
}

void set_combatspell(unit * u, spell * sp, struct order *ord, int level)
{
    sc_mage *mage = get_mage(u);
    int i = -1;

    assert(mage || !"trying to set a combat spell for non-mage");
    if (sp->sptyp & PRECOMBATSPELL)
        i = 0;
    else if (sp->sptyp & COMBATSPELL)
        i = 1;
    else if (sp->sptyp & POSTCOMBATSPELL)
        i = 2;
    assert(i >= 0);
    mage->combatspells[i].sp = sp;
    mage->combatspells[i].level = level;
    return;
}

void unset_combatspell(unit * u, spell * sp)
{
    int nr = 0;
    sc_mage *m = get_mage(u);

    if (!m) {
        return;
    }
    if (!sp) {
        int i;
        for (i = 0; i < MAXCOMBATSPELLS; i++) {
            m->combatspells[i].sp = NULL;
        }
    }
    else if (sp->sptyp & PRECOMBATSPELL) {
        if (sp != get_combatspell(u, 0))
            return;
    }
    else if (sp->sptyp & COMBATSPELL) {
        if (sp != get_combatspell(u, 1)) {
            return;
        }
        nr = 1;
    }
    else if (sp->sptyp & POSTCOMBATSPELL) {
        if (sp != get_combatspell(u, 2)) {
            return;
        }
        nr = 2;
    }
    m->combatspells[nr].sp = NULL;
    m->combatspells[nr].level = 0;
    return;
}

/**
 * Gibt die aktuelle Anzahl der Magiepunkte der Einheit zurueck
 */
int get_spellpoints(const unit * u)
{
    return mage_get_spellpoints(get_mage(u));
}

void set_spellpoints(unit * u, int sp)
{
    sc_mage *m = get_mage(u);
    if (m) {
        mage_set_spellpoints(m, sp);
    }
}

/**
 * Veraendert die Anzahl der Magiepunkte der Einheit um +mp
 */
int change_spellpoints(unit * u, int mp)
{
    return mage_change_spellpoints(get_mage(u), mp);
}

/* ein Magier kann normalerweise maximal Stufe^2.1/1.2+1 Magiepunkte
 * haben.
 * Manche Rassen haben einen zusaetzlichen Multiplikator
 * Durch Talentverlust (zB Insekten im Berg) koennen negative Werte
 * entstehen
 */

 /* Artefakt der Staerke
  * Ermoeglicht dem Magier mehr Magiepunkte zu 'speichern'
  */
  /** TODO: at_skillmod daraus machen */
static int use_item_aura(const region * r, const unit * u)
{
    int sk, n;

    sk = effskill(u, SK_MAGIC, r);
    n = (int)(sk * sk * rc_maxaura(u_race(u)) / 4);

    return n;
}

int max_spellpoints(const struct unit *u, const region * r)
{
    int sk;
    double n, msp = 0;
    double potenz = 2.1;
    double divisor = 1.2;
    const struct resource_type *rtype;
    const sc_mage *m;

    assert(u);
    m = get_mage(u);
    if (!m) return 0;
    if (!r) r = u->region;

    sk = effskill(u, SK_MAGIC, r);
    msp = rc_maxaura(u_race(u)) * (pow(sk, potenz) / divisor + 1);
    msp += m->spchange;

    rtype = rt_find("aurafocus");
    if (rtype && i_get(u->items, rtype->itype) > 0) {
        msp += use_item_aura(r, u);
    }
    n = get_curseeffect(u->attribs, &ct_auraboost);
    if (n > 0) {
        msp = (msp * n) / 100;
    }
    return (msp > 0) ? (int)msp : 0;
}

int max_spellpoints_depr(const struct region *r, const struct unit *u)
{
    return max_spellpoints(u, r);
}

int change_maxspellpoints(unit * u, int csp)
{
    sc_mage *m = get_mage(u);
    if (!m) {
        return 0;
    }
    m->spchange += csp;
    return max_spellpoints_depr(u->region, u);
}

/* ------------------------------------------------------------- */
/* Counter fuer die bereits gezauberte Anzahl Sprueche pro Runde.
 */
int countspells(unit * u, int step)
{
    sc_mage * m = get_mage(u);
    if (m) {
        int count;
        if (step == 0) {
            return m->spellcount;
        }
        count = m->spellcount + step;
        m->spellcount = (count > 0) ? count : 0;
        return m->spellcount;
    }
    return 0;
}

int spellcount(const unit *u) {
    sc_mage *m = get_mage(u);
    return m ? m->spellcount : 0;
}

/**
 * Die Grundkosten pro Stufe werden um 2^count erhoeht. countspells(u)
 * ist dabei die Anzahl der bereits gezauberten Sprueche
 */
int aura_multiplier(const unit * u) {
    int count = spellcount(u);
    return (1 << count);
}

int spellcost(const unit * caster, const struct spell_component *spc)
{
    const resource_type *r_aura = get_resourcetype(R_AURA);

    if (spc->type == r_aura) {
        return spc->amount * aura_multiplier(caster);
    }
    return spc->amount;
}

/**
 * Die fuer den Spruch benoetigte Aura pro Stufe.
 */
int auracost(const unit *caster, const spell *sp) {
    const resource_type *r_aura = get_resourcetype(R_AURA);
    if (sp->components) {
        int k;
        for (k = 0; sp->components[k].type; ++k) {
            const struct spell_component *spc = sp->components + k;
            if (r_aura == spc->type) {
                return spc->amount * aura_multiplier(caster);
            }
        }
    }
    return 0;
}

/* ------------------------------------------------------------- */
/* SPC_LINEAR ist am hoechstwertigen, dann muessen Komponenten fuer die
 * Stufe des Magiers vorhanden sein.
 * SPC_LINEAR hat die gewuenschte Stufe als multiplikator,
 * nur SPC_FIX muss nur einmal vorhanden sein, ist also am
 * niedrigstwertigen und sollte von den beiden anderen Typen
 * ueberschrieben werden */
static int spl_costtyp(const spell * sp)
{
    int k;
    int costtyp = SPC_FIX;

    for (k = 0; sp->components && sp->components[k].type; k++) {
        if (costtyp == SPC_LINEAR)
            return SPC_LINEAR;

        if (sp->components[k].cost == SPC_LINEAR) {
            return SPC_LINEAR;
        }

        /* wenn keine Fixkosten, Typ uebernehmen */
        if (sp->components[k].cost != SPC_FIX) {
            costtyp = sp->components[k].cost;
        }
    }
    return costtyp;
}

/**
 * Durch Komponenten und cast_level begrenzter maximal moeglicher Level.
 *
 * Da die Funktion nicht alle Komponenten durchprobiert sondern beim
 * ersten Fehler abbricht, muss die Fehlermeldung spaeter mit cancast()
 * generiert werden.
 */
int eff_spelllevel(unit * u, unit *caster, const spell * sp, int cast_level, int range)
{
    const resource_type *r_aura = get_resourcetype(R_AURA);
    int k, maxlevel;
    int costtyp = SPC_FIX;

    for (k = 0; sp->components && sp->components[k].type; k++) {
        if (cast_level == 0)
            return 0;

        if (sp->components[k].amount > 0) {
            int level_cost = sp->components[k].amount * range;
            if (sp->components[k].type == r_aura) {
                /* Die Kosten fuer Aura sind auch von der Zahl der bereits
                 * gezauberten Sprueche abhaengig */
                level_cost *= aura_multiplier(caster);
            }
            maxlevel =
                get_pooled(u, sp->components[k].type, GET_DEFAULT,
                    level_cost * cast_level) / level_cost;

            /* sind die Kosten fix, so muss die Komponente nur einmal vorhanden
             * sein und der cast_level aendert sich nicht */
            if (sp->components[k].cost == SPC_FIX) {
                if (maxlevel < 1)
                    cast_level = 0;
                /* ansonsten wird das Minimum aus maximal moeglicher Stufe und der
                 * gewuenschten gebildet */
            }
            else if (sp->components[k].cost == SPC_LEVEL) {
                costtyp = SPC_LEVEL;
                if (maxlevel < cast_level) {
                    cast_level = maxlevel;
                }
                /* bei Typ Linear muessen die Kosten in Hoehe der Stufe vorhanden
                 * sein, ansonsten schlaegt der Spruch fehl */
            }
            else if (sp->components[k].cost == SPC_LINEAR) {
                costtyp = SPC_LINEAR;
                if (maxlevel < cast_level)
                    cast_level = 0;
            }
        }
    }
    /* Ein Spruch mit Fixkosten wird immer mit der Stufe des Spruchs und
     * nicht auf der Stufe des Magiers gezaubert */
    if (costtyp == SPC_FIX) {
        spellbook * sb = unit_get_spellbook(u);
        if (sb) {
            spellbook_entry * sbe = spellbook_get(sb, sp);
            if (sbe && cast_level > sbe->level) {
                return sbe->level;
            }
        }
        else {
            log_error("spell %s is not in the spellbook for %s\n", sp->sname, unitname(u));
        }
    }
    return cast_level;
}

/* ------------------------------------------------------------- */
/* Die Spruchgrundkosten werden mit der Entfernung (Farcasting)
 * multipliziert, wobei die Aurakosten ein Sonderfall sind, da sie sich
 * auch durch die Menge der bereits gezauberten Sprueche erhoeht.
 * Je nach Kostenart werden dann die Komponenten noch mit cast_level
 * multipliziert.
 */
void pay_spell(unit * mage, const unit *caster, const spell * sp, int cast_level, int range)
{
    int k;

    assert(cast_level > 0);
    for (k = 0; sp->components && sp->components[k].type; k++) {
        const struct spell_component *spc = sp->components + k;
        int resuse = spellcost(caster ? caster : mage, spc) * range;

        if (spc->cost == SPC_LINEAR || spc->cost == SPC_LEVEL) {
            resuse *= cast_level;
        }

        use_pooled(mage, spc->type, GET_DEFAULT, resuse);
    }
}

/* ------------------------------------------------------------- */
/* Ein Magier kennt den Spruch und kann sich die Beschreibung anzeigen
 * lassen, wenn diese in seiner Spruchliste steht. Zaubern muss er ihn
 * aber dann immer noch nicht koennen, vieleicht ist seine Stufe derzeit
 * nicht ausreichend oder die Komponenten fehlen.
 */
bool knowsspell(const region * r, const unit * u, const spell * sp)
{
    UNUSED_ARG(r);
    assert(sp);
    /* steht der Spruch in der Spruchliste? */
    return u_hasspell(u, sp) != 0;
}

/* Um einen Spruch zu beherrschen, muss der Magier die Stufe des
 * Spruchs besitzen, nicht nur wissen, das es ihn gibt (also den Spruch
 * in seiner Spruchliste haben).
 * Kosten fuer einen Spruch koennen Magiepunkte, Silber, Kraeuter
 * und sonstige Gegenstaende sein.
 */

bool
cancast(unit * u, const spell * sp, int level, int range, struct order * ord)
{
    int k;
    resource *reslist = NULL;

    if (!knowsspell(u->region, u, sp)) {
        /* Diesen Zauber kennt die Einheit nicht */
        cmistake(u, ord, 173, MSG_MAGIC);
        return false;
    }
    /* reicht die Stufe aus? */
    if (effskill(u, SK_MAGIC, NULL) < level) {
        /* die Einheit ist nicht erfahren genug fuer diesen Zauber */
        cmistake(u, ord, 169, MSG_MAGIC);
        return false;
    }

    for (k = 0; sp->components && sp->components[k].type; ++k) {
        const struct spell_component *spc = sp->components + k;
        if (spc->amount > 0) {
            const resource_type *rtype = spc->type;
            int itemhave, itemanz;

            /* Die Kosten fuer Aura sind auch von der Zahl der bereits
             * gezauberten Sprueche abhaengig */
            itemanz = spellcost(u, spc) * range;

            /* sind die Kosten stufenabhaengig, so muss itemanz noch mit dem
             * level multipliziert werden */
            switch (spc->cost) {
            case SPC_LEVEL:
            case SPC_LINEAR:
                itemanz *= level;
                break;
            case SPC_FIX:
            default:
                break;
            }

            itemhave = get_pooled(u, rtype, GET_DEFAULT, itemanz);
            if (itemhave < itemanz) {
                resource *res = malloc(sizeof(resource));
                assert(res);
                res->number = itemanz - itemhave;
                res->type = rtype;
                res->next = reslist;
                reslist = res;
            }
        }
    }
    if (reslist != NULL) {
        ADDMSG(&u->faction->msgs, msg_feedback(u, ord, "missing_components_list",
            "list", reslist));
        while (reslist) {
            resource *res = reslist->next;
            free(reslist);
            reslist = res;
        }
        return false;
    }
    return true;
}

/* ------------------------------------------------------------- */
/* generische Spruchstaerke,
 *
 * setzt sich derzeit aus der Stufe des Magiers, Magieturmeffekt,
 * Spruchitems und Antimagiefeldern zusammen. Es koennen noch die
 * Stufe des Spruchs und Magiekosten mit einfliessen.
 *
 * Die effektive Spruchstaerke und ihre Auswirkungen werden in der
 * Spruchfunktionsroutine ermittelt.
 */

double
spellpower(region * r, unit * u, const spell * sp, int cast_level, struct order *ord)
{
    double force = cast_level;
    static int elf_power, config;
    const struct resource_type *rtype;

    if (sp == NULL) {
        return 0;
    }
    else {
        /* Bonus durch Magieturm und gesegneten Steinkreis */
        struct building *b = inside_building(u);
        const struct building_type *btype = building_is_active(b) ? b->type : NULL;
        if (btype && btype->flags & BTF_MAGIC) ++force;
    }

    if (config_changed(&config)) {
        elf_power = config_get_int("rules.magic.elfpower", 0);
    }
    if (elf_power) {
        static int rc_cache;
        static const race *rc_elf;
        if (rc_changed(&rc_cache)) {
            rc_elf = get_race(RC_ELF);
        }
        if (u_race(u) == rc_elf && r_isforest(r)) {
            ++force;
        }
    }
    rtype = rt_find("rop");
    if (rtype && i_get(u->items, rtype->itype) > 0) {
        ++force;
    }

    if (r->attribs) {
        curse *c;

        /* Antimagie in der Zielregion */
        c = get_curse(r->attribs, &ct_antimagiczone);
        if (curse_active(c)) {
            unit *mage = c->magician;
            force -= curse_geteffect(c);
            curse_changevigour(&r->attribs, c, -cast_level);
            cmistake(u, ord, 185, MSG_MAGIC);
            if (mage != NULL && mage->faction != NULL) {
                if (force > 0) {
                    ADDMSG(&mage->faction->msgs, msg_message("reduce_spell",
                        "self mage region", mage, u, r));
                }
                else {
                    ADDMSG(&mage->faction->msgs, msg_message("block_spell",
                        "self mage region", mage, u, r));
                }
            }
        }

        /* Patzerfluch-Effekt: */
        c = get_curse(r->attribs, &ct_fumble);
        if (curse_active(c)) {
            unit *mage = c->magician;
            force -= curse_geteffect(c);
            curse_changevigour(&u->attribs, c, -1);
            cmistake(u, ord, 185, MSG_MAGIC);
            if (mage != NULL && mage->faction != NULL) {
                if (force > 0) {
                    ADDMSG(&mage->faction->msgs, msg_message("reduce_spell",
                        "self mage region", mage, u, r));
                }
                else {
                    ADDMSG(&mage->faction->msgs, msg_message("block_spell",
                        "self mage region", mage, u, r));
                }
            }
        }
    }
    return (force > 0) ? (int)force : 0;
}

/* ------------------------------------------------------------- */
/* farcasting() == 1 -> gleiche Region, da man mit Null nicht vernuenfigt
 * rechnen kann */
static int farcasting(unit * magician, region * r)
{
    int dist;
    int mult;

    if (!r) {
        return INT_MAX;
    }

    dist = koor_distance(r->x, r->y, magician->region->x, magician->region->y);

    if (dist > 24)
        return INT_MAX;

    mult = 1 << dist;
    if (dist > 1) {
        if (!path_exists(magician->region, r, dist * 2, allowed_fly))
            mult = INT_MAX;
    }

    return mult;
}

/* ------------------------------------------------------------- */
/* Antimagie - Magieresistenz */
/* ------------------------------------------------------------- */

/* allgemeine Magieresistenz einer Einheit,
 * reduziert magischen Schaden */
variant magic_resistance(unit * target)
{
    attrib *a;
    curse *c;
    const resource_type *rtype;
    const race *rc = u_race(target);
    variant v, prob = rc_magres(rc);
    const plane *pl = rplane(target->region);
    bool good_resist = true;
    bool bad_resist = true;

    if (rc == get_race(RC_HIRNTOETER) && !pl) {
        prob = frac_mul(prob, frac_make(1, 2));
    }
    assert(target->number > 0);
    /* Magier haben einen Resistenzbonus vom Magietalent * 5% */
    prob = frac_add(prob, frac_make(effskill(target, SK_MAGIC, NULL), 20));

    /* Auswirkungen von Zaubern auf der Einheit */
    c = get_curse(target->attribs, &ct_magicresistance);
    if (c) {
        /* TODO: legacy. magicresistance-effect is an integer-percentage stored in a double */
        int effect = curse_geteffect_int(c) * get_cursedmen(target, c);
        prob = frac_add(prob, frac_make(effect, 100));
    }

    /* Unicorn +10 */
    rtype = get_resourcetype(R_UNICORN);
    if (rtype) {
        int n = i_get(target->items, rtype->itype);
        if (n) {
            prob = frac_add(prob, frac_make(n, target->number * 10));
        }
    }

    /* Auswirkungen von Zaubern auf der Region */
    a = a_find(target->region->attribs, &at_curse);
    while (a && a->type == &at_curse) {
        unit *mage;

        c = (curse *)a->data.v;
        mage = c->magician;

        if (mage != NULL) {
            if (good_resist && c->type == &ct_goodmagicresistancezone) {
                if (alliedunit(mage, target->faction, HELP_GUARD)) {
                    /* TODO: legacy. magicresistance-effect is an integer-percentage stored in a double */
                    prob = frac_add(prob, frac_make(curse_geteffect_int(c), 100));
                    good_resist = false; /* only one effect per region */
                }
            }
            else if (bad_resist && c->type == &ct_badmagicresistancezone) {
                if (!alliedunit(mage, target->faction, HELP_GUARD)) {
                    /* TODO: legacy. magicresistance-effect is an integer-percentage stored in a double */
                    prob = frac_sub(prob, frac_make(curse_geteffect_int(c), 100));
                    bad_resist = false; /* only one effect per region */
                }
            }
        }
        a = a->next;
    }
    /* Bonus durch Artefakte */
    /* TODO (noch gibs keine) */

    /* Bonus durch Gebaeude */
    {
        struct building *b = inside_building(target);
        const struct building_type *btype = building_is_active(b) ? b->type : NULL;

        /* gesegneter Steinkreis gibt 30% dazu */
        if (btype) {
            /* TODO: legacy. building-bonus is an integer-percentage */
            prob = frac_add(prob, frac_make(btype->magresbonus, 100));
        }
    }

    /* resistance must never be more than 90% */
    v = frac_make(9, 10);
    if (frac_sign(frac_sub(prob, v)) > 0) { /* prob < 90% */
        return v; /* at most 90% */
    }
    return prob;
}

/* ------------------------------------------------------------- */
/* Prueft, ob das Objekt dem Zauber widerstehen kann.
 * Objekte koennen Regionen, Units, Gebaeude oder Schiffe sein.
 * TYP_UNIT:
 * Das hoechste Talent des Ziels ist sein 'Magieresistenz-Talent', Magier
 * bekommen einen Bonus. Grundchance ist 50%, fuer jede Stufe
 * Unterschied gibt es 5%, minimalchance ist 5% fuer jeden (5-95%)
 * Scheitert der Spruch an der Magieresistenz, so gibt die Funktion
 * true zurueck
 */

bool
target_resists_magic(unit * magician, void *obj, int objtyp, int t_bonus)
{
    variant v02p, v98p, prob = frac_make(t_bonus, 100);
    attrib *a = NULL;
    static bool never_resist;
    static int config;
    if (config_changed(&config)) {
        never_resist = config_get_int("magic.resist.enable", 1) == 0;
    }
    if (never_resist) {
        return false;
    }

    if (magician == NULL || obj == NULL) {
        return true;
    }

    switch (objtyp) {
    case TYP_UNIT:
    {
        int at, pa = 0;
        skill *sv;
        unit *u = (unit *)obj;

        at = effskill(magician, SK_MAGIC, NULL);

        for (sv = u->skills; sv != u->skills + u->skill_size; ++sv) {
            int sk = eff_skill(u, sv, NULL);
            if (pa < sk)
                pa = sk;
        }

        /* Contest, probability = 0.05 * (10 + pa - at); */
        prob = frac_add(prob, frac_make(10 + pa - at, 20));
        prob = frac_add(prob, magic_resistance((unit *)obj));
        break;
    }

    case TYP_REGION:
        /* Bonus durch Zauber
        probability +=
            0.01 * get_curseeffect(((region *)obj)->attribs, C_RESIST_MAGIC, 0); */
        a = ((region *)obj)->attribs;
        break;

    case TYP_BUILDING:
        /* Bonus durch Zauber
        probability +=
            0.01 * get_curseeffect(((building *)obj)->attribs, C_RESIST_MAGIC, 0); */
        a = ((building *)obj)->attribs;
        /* Bonus durch Typ
        probability += 0.01 * ((building *)obj)->type->magres; */
        prob = frac_add(prob, ((building *)obj)->type->magres);
        break;

    case TYP_SHIP:
        /* Bonus durch Zauber */
        a = ((ship *)obj)->attribs;
        break;
    }

    if (a) {
        curse * c = get_curse(a, &ct_magicrunes);
        int effect = curse_geteffect_int(c);
        prob = frac_add(prob, frac_make(effect, 100));
    }

    /* ignore results < 2% and > 98% */
    v02p = frac_make(1, 50);
    v98p = frac_make(49, 50);
    if (frac_sign(frac_sub(prob, v02p)) < 0) {
        prob = v02p;
    }
    else if (frac_sign(frac_sub(prob, v98p)) > 0) {
        prob = v98p;
    }

    /* gibt true, wenn die Zufallszahl kleiner als die chance ist und
     * false, wenn sie gleich oder groesser ist, dh je groesser die
     * Magieresistenz (chance) desto eher gibt die Funktion true zurueck */
    return rng_int() % prob.sa[1] < prob.sa[0];
}

/* ------------------------------------------------------------- */

bool is_magic_resistant(unit * magician, unit * target, int resist_bonus)
{
    return target_resists_magic(magician, target, TYP_UNIT,
        resist_bonus);
}

/* ------------------------------------------------------------- */
/* Patzer */
/* ------------------------------------------------------------- */
/* allgemeine Zauberpatzer:
 * Treten auf, wenn die Stufe des Magieres zu niedrig ist.
 * Abhaengig von Staerke des Spruchs.
 *
 * Die Warscheinlichkeit reicht von 20% (beherrscht den Spruch gerade
 * eben) bis zu etwa 1% bei doppelt so gut wie notwendig
 */

bool fumble(region * r, unit * u, const spell * sp, int cast_grade)
{
    /* X ergibt Zahl zwischen 1 und 0, je kleiner, desto besser der Magier.
     * 0,5*40-20=0, dh wenn der Magier doppelt so gut ist, wie der Spruch
     * benoetigt, gelingt er immer, ist er gleich gut, gelingt der Spruch mit
     * 20% Warscheinlichkeit nicht
     * */

    int fumble_chance, rnd = 0;
    int effsk = effskill(u, SK_MAGIC, r);
    struct building *b = inside_building(u);
    const struct building_type *btype = building_is_active(b) ? b->type : NULL;
    int fumble_enabled = config_get_int("magic.fumble.enable", 1);
    sc_mage * mage;

    UNUSED_ARG(sp);
    if (effsk <= 0 || !fumble_enabled) {
        return false;
    }
    fumble_chance = (int)((cast_grade * 40.0 / (double)effsk) - 20.0);
    if (btype) {
        fumble_chance -= btype->fumblebonus;
    }

    /* CHAOSPATZERCHANCE 10 : +10% Chance zu Patzern */
    mage = get_mage(u);
    if (mage && mage->magietyp == M_DRAIG) {
        fumble_chance += CHAOSPATZERCHANCE;
    }
    if (is_cursed(u->attribs, &ct_magicboost)) {
        fumble_chance += CHAOSPATZERCHANCE;
    }
    if (is_cursed(u->attribs, &ct_fumble)) {
        fumble_chance += CHAOSPATZERCHANCE;
    }

    /* wenn die Chance kleiner als 0 ist, koennen wir gleich false
     * zurueckgeben */
    if (fumble_chance <= 0) {
        return false;
    }
    rnd = rng_int() % 100;

    return (rnd <= fumble_chance);
}

/* ------------------------------------------------------------- */
/* Dummy-Zauberpatzer, Platzhalter fuer speziell auf die Sprueche
* zugeschnittene Patzer */
static void fumble_default(castorder * co)
{
    unit *mage = co_get_magician(co);

    cmistake(mage, co->order, 180, MSG_MAGIC);

    return;
}

/* Die normalen Spruchkosten muessen immer bezahlt werden, hier noch
 * alle weiteren Folgen eines Patzers
 */

static void do_fumble(castorder * co)
{
    curse *c;
    region *r = co_get_region(co);
    unit *mage = co_get_magician(co);
    unit *caster = co_get_caster(co);
    const spell *sp = co->sp;
    int level = co->level;
    int duration;
    double effect;
    static int rc_cache;
    fumble_f fun;

    ADDMSG(&caster->faction->msgs,
        msg_message("patzer", "unit region spell", caster, r, sp));
    switch (rng_int() % 10) {
    case 0:
        /* wenn vorhanden spezieller Patzer, ansonsten nix */
        fun = get_fumble(sp->sname);
        if (fun) {
            fun(co);
        }
        else {
            fumble_default(co);
        }
        break;

    case 1: /* toad */
    {
        /* one or two things will happen: the toad changes her race back,
         * and may or may not get toadslime.
         * The list of things to happen are attached to a timeout
         * trigger and that's added to the triggerlit of the mage gone toad.
         */
        static const race *rc_toad;
        trigger *trestore = trigger_changerace(mage, u_race(mage), mage->irace);
        if (chance(0.7)) {
            const resource_type *rtype = rt_find("toadslime");
            if (rtype) {
                t_add(&trestore, trigger_giveitem(mage, rtype->itype, 1));
            }
        }
        duration = rng_int() % level / 2;
        if (duration < 2) duration = 2;
        add_trigger(&mage->attribs, "timer", trigger_timeout(duration, trestore));
        if (rc_changed(&rc_cache)) {
            rc_toad = get_race(RC_TOAD);
        }
        u_setrace(mage, rc_toad);
        mage->irace = NULL;
        ADDMSG(&r->msgs, msg_message("patzer6", "unit region spell", mage, r, sp));
        break;
    }
    /* fall-through is intentional! */

    case 2:
        /* temporary skill loss */
        duration = rng_int() % level / 2;
        if (duration < 2) duration = 2;
        effect = level / -2.0;
        c = create_curse(mage, &mage->attribs, &ct_skillmod, level,
            duration, effect, 1);
        c->data.i = SK_MAGIC;
        ADDMSG(&caster->faction->msgs, msg_message("patzer2", "unit region", caster, r));
        break;
    case 3:
    case 4:
        /* Spruch schlaegt fehl, alle Magiepunkte weg */
        set_spellpoints(mage, 0);
        ADDMSG(&caster->faction->msgs, msg_message("patzer3", "unit region spell",
            caster, r, sp));
        break;

    case 5:
    case 6:
        /* Spruch gelingt, aber alle Magiepunkte weg */
        co->level = cast_spell(co);
        set_spellpoints(mage, 0);
        ADDMSG(&caster->faction->msgs, msg_message("patzer4", "unit region spell",
            caster, r, sp));
        break;

    case 7:
    case 8:
    case 9:
    default:
        /* Spruch gelingt, alle nachfolgenden Sprueche werden 2^4 so teuer */
        co->level = cast_spell(co);
        ADDMSG(&caster->faction->msgs, msg_message("patzer5", "unit region spell",
            caster, r, sp));
        countspells(caster, 3);
    }
}

/* ------------------------------------------------------------- */
/* Regeneration von Aura */
/* ------------------------------------------------------------- */

/* Ein Magier regeneriert pro Woche W(Stufe^1.5/2+1), mindestens 1
 * Zwerge nur die Haelfte
 */
static double regeneration(unit * u)
{
    int sk;
    double aura, d;
    double potenz = 1.5;
    double divisor = 2.0;

    sk = effskill(u, SK_MAGIC, NULL);
    /* Rassenbonus/-malus */
    d = pow(sk, potenz) * u_race(u)->regaura / divisor;
    d++;

    /* Einfluss von Artefakten */
    /* TODO (noch gibs keine) */

    /* Wuerfeln */
    aura = (rng_double() * d + rng_double() * d) / 2 + 1;

    aura *= MagicRegeneration();

    return aura;
}

void regenerate_aura(void)
{
    region *r;
    unit *u;
    int aura, auramax;
    double reg_aura;
    int regen;
    double mod;
    int regen_enabled = config_get_int("magic.regeneration.enable", 1);

    if (!regen_enabled) return;

    for (r = regions; r; r = r->next) {
        for (u = r->units; u; u = u->next) {
            if (u->number && u->attribs) {
                sc_mage *m = get_mage(u);
                if (m) {
                    aura = mage_get_spellpoints(m);
                    auramax = max_spellpoints(u, r);
                    if (aura < auramax) {
                        struct building *b = inside_building(u);
                        const struct building_type *btype = building_is_active(b) ? b->type : NULL;
                        reg_aura = regeneration(u);

                        /* Magierturm erhoeht die Regeneration um 75% */
                        /* Steinkreis erhoeht die Regeneration um 50% */
                        if (btype)
                            reg_aura *= btype->auraregen;

                        /* Bonus/Malus durch Zauber */
                        mod = get_curseeffect(u->attribs, &ct_auraboost);
                        if (mod > 0) {
                            reg_aura = (reg_aura * mod) / 100.0;
                        }

                        /* Einfluss von Artefakten */
                        /* TODO (noch gibs keine) */

                        /* maximal Differenz bis Maximale-Aura regenerieren
                         * mindestens 1 Aura pro Monat */
                        regen = (int)reg_aura;
                        reg_aura -= regen;
                        if (chance(reg_aura)) {
                            ++regen;
                        }
                        if (regen < 1) regen = 1;
                        if (regen > auramax - aura) regen = auramax - aura;

                        aura += regen;
                        ADDMSG(&u->faction->msgs, msg_message("regenaura",
                            "unit region amount", u, r, regen));
                    }
                    if (aura > auramax) aura = auramax;
                    mage_set_spellpoints(m, aura);
                }
            }
        }
    }
}

static bool
verify_ship(region * r, unit * mage, const spell * sp, spllprm * spobj,
    order * ord)
{
    ship *sh = findship(spobj->data.i);

    if (sh != NULL && sh->region != r && (sp->sptyp & GLOBALTARGET) == 0) {
        /* Burg muss in gleicher Region sein */
        sh = NULL;
    }

    if (sh == NULL) {
        /* Burg nicht gefunden */
        spobj->flag = TARGET_NOTFOUND;
        ADDMSG(&mage->faction->msgs, msg_message("spellshipnotfound",
            "unit region command id", mage, mage->region, ord, spobj->data.i));
        return false;
    }
    spobj->flag = 0;
    spobj->data.sh = sh;
    return true;
}

static bool
verify_building(region * r, unit * mage, const spell * sp, spllprm * spobj,
    order * ord)
{
    building *b = findbuilding(spobj->data.i);

    if (b != NULL && b->region != r && (sp->sptyp & GLOBALTARGET) == 0) {
        /* Burg muss in gleicher Region sein */
        b = NULL;
    }

    if (b == NULL) {
        /* Burg nicht gefunden */
        spobj->flag = TARGET_NOTFOUND;
        ADDMSG(&mage->faction->msgs, msg_message("spellbuildingnotfound",
            "unit region command id", mage, mage->region, ord, spobj->data.i));
        return false;
    }
    spobj->flag = 0;
    spobj->data.b = b;
    return true;
}

message *msg_unitnotfound(const struct unit * mage, struct order * ord,
    const struct spllprm * spobj)
{
    /* Einheit nicht gefunden */
    char tbuf[20];
    const char *uid = 0;

    if (spobj->typ == SPP_TEMP) {
        sprintf(tbuf, "%s %s", LOC(mage->faction->locale,
            parameters[P_TEMP]), itoa36(spobj->data.i));
        uid = tbuf;
    }
    else if (spobj->typ == SPP_UNIT) {
        uid = itoa36(spobj->data.i);
    }
    assert(uid);
    return msg_message("unitnotfound_id",
        "unit region command id", mage, mage->region, ord, uid);
}

static bool
verify_unit(region * r, unit * mage, const spell * sp, spllprm * spobj,
    order * ord)
{
    unit *u = NULL;
    switch (spobj->typ) {
    case SPP_UNIT:
        u = findunit(spobj->data.i);
        break;
    case SPP_TEMP:
        u = findnewunit(r, mage->faction, spobj->data.i);
        if (u == NULL)
            u = findnewunit(mage->region, mage->faction, spobj->data.i);
        break;
    default:
        assert(!"shouldn't happen, this");
    }
    if (u != NULL) {
        if (u->region == r) {
            if (!cansee(mage->faction, r, u, 0) && !ucontact(u, mage)) {
                u = NULL;
            }
        }
        else if ((sp->sptyp & GLOBALTARGET) == 0) {
            u = NULL;
        }
    }

    if (u == NULL) {
        /* Einheit nicht gefunden */
        spobj->flag = TARGET_NOTFOUND;
        ADDMSG(&mage->faction->msgs, msg_unitnotfound(mage, ord, spobj));
        return false;
    }
    /* Einheit wurde gefunden, pointer setzen */
    spobj->flag = 0;
    spobj->data.u = u;
    return true;
}

/* ------------------------------------------------------------- */
/* Zuerst wird versucht alle noch nicht gefundenen Objekte zu finden
 * oder zu pruefen, ob das gefundene Objekt wirklich haette gefunden
 * werden duerfen (nicht alle Zauber wirken global). Dabei zaehlen wir die
 * Misserfolge (failed).
 * Dann folgen die Tests der gefundenen Objekte auf Magieresistenz und
 * Sichtbarkeit. Dabei zaehlen wir die magieresistenten (resists)
 * Objekte. Alle anderen werten wir als Erfolge (success) */

 /* gibt bei Misserfolg 0 zurueck, bei Magieresistenz zumindeste eines
  * Objektes 1 und bei Erfolg auf ganzer Linie 2 */
static void
verify_targets(castorder * co, int *invalid, int *resist, int *success)
{
    unit *caster = co_get_caster(co);
    const spell *sp = co->sp;
    region *target_r = co_get_region(co);
    spellparameter *sa = co->par;

    *invalid = 0;
    *resist = 0;
    *success = 0;

    if (sa && sa->length) {
        int i;
        /* zuerst versuchen wir vorher nicht gefundene Objekte zu finden.
         * Wurde ein Objekt durch globalsuche gefunden, obwohl der Zauber
         * gar nicht global haette suchen duerften, setzen wir das Objekt
         * zurueck. */
        for (i = 0; i < sa->length; i++) {
            spllprm *spobj = sa->param[i];

            switch (spobj->typ) {
            case SPP_TEMP:
            case SPP_UNIT:
                if (!verify_unit(target_r, caster, sp, spobj, co->order))
                    ++ * invalid;
                break;
            case SPP_BUILDING:
                if (!verify_building(target_r, caster, sp, spobj, co->order))
                    ++ * invalid;
                break;
            case SPP_SHIP:
                if (!verify_ship(target_r, caster, sp, spobj, co->order))
                    ++ * invalid;
                break;
            default:
                break;
            }
        }

        /* Nun folgen die Tests auf cansee und Magieresistenz */
        for (i = 0; i < sa->length; i++) {
            spllprm *spobj = sa->param[i];
            unit *u;
            building *b;
            ship *sh;
            region *tr;

            if (spobj->flag == TARGET_NOTFOUND)
                continue;
            switch (spobj->typ) {
            case SPP_TEMP:
            case SPP_UNIT:
                u = spobj->data.u;

                if ((sp->sptyp & TESTRESISTANCE)
                    && target_resists_magic(caster, u, TYP_UNIT, 0)) {
                    /* Fehlermeldung */
                    spobj->data.i = u->no;
                    spobj->flag = TARGET_RESISTS;
                    ++*resist;
                    ADDMSG(&caster->faction->msgs, msg_message("spellunitresists",
                        "unit region command target", caster, caster->region, co->order, u));
                    break;
                }

                /* TODO: Test auf Parteieigenschaft Magieresistsenz */
                ++*success;
                break;
            case SPP_BUILDING:
                b = spobj->data.b;

                if ((sp->sptyp & TESTRESISTANCE)
                    && target_resists_magic(caster, b, TYP_BUILDING, 0)) {  /* Fehlermeldung */
                    spobj->data.i = b->no;
                    spobj->flag = TARGET_RESISTS;
                    ++*resist;
                    ADDMSG(&caster->faction->msgs, msg_message("spellbuildingresists",
                        "unit region command id",
                        caster, caster->region, co->order, spobj->data.i));
                    break;
                }
                ++*success;
                break;
            case SPP_SHIP:
                sh = spobj->data.sh;

                if ((sp->sptyp & TESTRESISTANCE)
                    && target_resists_magic(caster, sh, TYP_SHIP, 0)) {     /* Fehlermeldung */
                    spobj->data.i = sh->no;
                    spobj->flag = TARGET_RESISTS;
                    ++*resist;
                    ADDMSG(&caster->faction->msgs, msg_feedback(caster, co->order,
                        "spellshipresists", "ship", sh));
                    break;
                }
                ++*success;
                break;

            case SPP_REGION:
                /* haben wir ein Regionsobjekt, dann wird auch dieses und
                   nicht target_r ueberprueft. */
                tr = spobj->data.r;

                if ((sp->sptyp & TESTRESISTANCE)
                    && target_resists_magic(caster, tr, TYP_REGION, 0)) {   /* Fehlermeldung */
                    spobj->flag = TARGET_RESISTS;
                    ++*resist;
                    ADDMSG(&caster->faction->msgs, msg_message("spellregionresists",
                        "unit region command", caster, caster->region, co->order));
                    break;
                }
                ++*success;
                break;
            case SPP_INT:
            case SPP_STRING:
                ++*success;
                break;

            default:
                break;
            }
        }
    }
    else {
        /* der Zauber hat keine expliziten Parameter/Ziele, es kann sich
         * aber um einen Regionszauber handeln. Wenn notwendig hier die
         * Magieresistenz der Region pruefen. */
        if ((sp->sptyp & REGIONSPELL)) {
            /* Zielobjekt Region anlegen */
            spllprm *spobj = (spllprm *)malloc(sizeof(spllprm));
            if (!spobj) abort();
            spobj->flag = 0;
            spobj->typ = SPP_REGION;
            spobj->data.r = target_r;

            sa = calloc(1, sizeof(spellparameter));
            if (!sa) abort();
            sa->length = 1;
            sa->param = calloc(sa->length, sizeof(spllprm *));
            sa->param[0] = spobj;
            co->par = sa;

            if ((sp->sptyp & TESTRESISTANCE)) {
                if (target_resists_magic(caster, target_r, TYP_REGION, 0)) {
                    /* Fehlermeldung */
                    ADDMSG(&caster->faction->msgs, msg_message("spellregionresists",
                        "unit region command", caster, caster->region, co->order));
                    spobj->flag = TARGET_RESISTS;
                    ++*resist;
                }
                else {
                    ++*success;
                }
            }
            else {
                ++*success;
            }
        }
        else {
            ++*success;
        }
    }
}

/* ------------------------------------------------------------- */
/* Hilfsstrukturen fuer ZAUBERE */
/* ------------------------------------------------------------- */

static void free_spellparameter(spellparameter * pa)
{
    int i;

    assert(pa->param);

    for (i = 0; i < pa->length; i++) {
        assert(pa->param[i]);
        switch (pa->param[i]->typ) {
        case SPP_STRING:
            free(pa->param[i]->data.s);
            break;
        default:
            break;
        }
        free(pa->param[i]);
    }
    free(pa->param);
    free(pa);
}

static int addparam_string(const char *const param[], spllprm ** spobjp)
{
    spllprm *spobj = *spobjp = malloc(sizeof(spllprm));
    assert(param[0]);

    if (!spobj) abort();
    spobj->flag = 0;
    spobj->typ = SPP_STRING;
    spobj->data.xs = str_strdup(param[0]);
    return 1;
}

static int addparam_int(const char *const param[], spllprm ** spobjp)
{
    spllprm *spobj = *spobjp = malloc(sizeof(spllprm));
    assert(param[0]);

    if (!spobj) abort();
    spobj->flag = 0;
    spobj->typ = SPP_INT;
    spobj->data.i = atoi((char *)param[0]);
    return 1;
}

static int addparam_ship(const char *const param[], spllprm ** spobjp)
{
    spllprm *spobj = *spobjp = malloc(sizeof(spllprm));
    int id = atoi36((const char *)param[0]);

    if (!spobj) abort();
    spobj->flag = 0;
    spobj->typ = SPP_SHIP;
    spobj->data.i = id;
    return 1;
}

static int addparam_building(const char *const param[], spllprm ** spobjp)
{
    spllprm *spobj = *spobjp = malloc(sizeof(spllprm));
    int id = atoi36((const char *)param[0]);

    if (!spobj) abort();
    spobj->flag = 0;
    spobj->typ = SPP_BUILDING;
    spobj->data.i = id;
    return 1;
}

static int
addparam_region(const char *const param[], spllprm ** spobjp, const unit * u,
    order * ord, message **err)
{
    assert(param[0]);
    if (param[1] == NULL) {
        /* Fehler: Zielregion vergessen */
        *err = msg_error(u, ord, 194);
        return -1;
    }
    else {
        plane *pl = getplanebyid(0);
        int tx = atoi((const char *)param[0]), ty = atoi((const char *)param[1]);
        int x = rel_to_abs(pl, u->faction, tx, 0);
        int y = rel_to_abs(pl, u->faction, ty, 1);
        region *rt;

        pnormalize(&x, &y, pl);
        rt = findregion(x, y);

        if (rt != NULL) {
            spllprm *spobj = *spobjp = (spllprm *)malloc(sizeof(spllprm));

            if (!spobj) abort();
            spobj->flag = 0;
            spobj->typ = SPP_REGION;
            spobj->data.r = rt;
        }
        else {
            /* Fehler: Zielregion vergessen */
            *err = msg_error(u, ord, 194);
            return -1;
        }
        return 2;
    }
}

static int
addparam_unit(const char *const param[], spllprm ** spobjp, const unit * u,
    order * ord, message **err)
{
    spllprm *spobj;
    int i = 0;
    sppobj_t otype = SPP_UNIT;

    *spobjp = NULL;
    if (isparam(param[0], u->faction->locale, P_TEMP)) {
        if (param[1] == NULL) {
            /* Fehler: Ziel vergessen */
            *err = msg_error(u, ord, 203);
            return -1;
        }
        ++i;
        otype = SPP_TEMP;
    }

    spobj = *spobjp = malloc(sizeof(spllprm));
    if (!spobj) abort();
    spobj->flag = 0;
    spobj->typ = otype;
    spobj->data.i = atoi36((const char *)param[i]);

    return i + 1;
}

static spellparameter *add_spellparameter(region * target_r, unit * u,
    const char *syntax, const char *const param[], int size, struct order *ord)
{
    struct message *err = NULL;
    int i = 0;
    int p = 0;
    const char *c;
    spellparameter *par;
    int minlen = 0;

    for (c = syntax; *c != 0; ++c) {
        /* this makes sure that:
         *  minlen("kc?") = 0
         *  minlen("kc+") = 1
         *  minlen("cccc+c?") = 4
         */
        if (*c == '?')
            --minlen;
        else if (*c != '+' && *c != 'k')
            ++minlen;
    }
    c = syntax;

    /* mindestens ein Ziel (Ziellose Zauber werden nicht
     * geparst) */
    if (minlen && size == 0) {
        /* Fehler: Ziel vergessen */
        cmistake(u, ord, 203, MSG_MAGIC);
        return 0;
    }

    par = malloc(sizeof(spellparameter));
    if (!par) abort();
    par->length = size;
    if (!size) {
        par->param = NULL;
        return par;
    }
    par->param = malloc(size * sizeof(spllprm *));
    if (!par->param) abort();

    while (!err && *c && i < size && param[i] != NULL) {
        spllprm *spobj = NULL;
        int j = -1;
        switch (*c) {
        case '?':
            /* tja. das sollte moeglichst nur am Ende passieren,
             * weil sonst die kacke dampft. */
            j = 0;
            ++c;
            assert(*c == 0);
            break;
        case '+':
            /* das vorhergehende Element kommt ein oder mehrmals vor, wir
             * springen zum key zurueck */
            j = 0;
            --c;
            break;
        case 'u':
            /* Parameter ist eine Einheit, evtl. TEMP */
            j = addparam_unit(param + i, &spobj, u, ord, &err);
            ++c;
            break;
        case 'r':
            /* Parameter sind zwei Regionskoordinaten innerhalb der "normalen" Plane */
            if (i + 1 < size) {
                j = addparam_region(param + i, &spobj, u, ord, &err);
            }
            ++c;
            break;
        case 'b':
            /* Parameter ist eine Burgnummer */
            j = addparam_building(param + i, &spobj);
            ++c;
            break;
        case 's':
            j = addparam_ship(param + i, &spobj);
            ++c;
            break;
        case 'c':
            /* Text, wird im Spruch ausgewertet */
            j = addparam_string(param + i, &spobj);
            ++c;
            break;
        case 'i':                  /* Zahl */
            j = addparam_int(param + i, &spobj);
            ++c;
            break;
        case 'k':
            ++c;
            switch (findparam_ex(param[i++], u->faction->locale)) {
            case P_REGION:
                spobj = (spllprm *)malloc(sizeof(spllprm));
                if (!spobj) abort();
                spobj->flag = 0;
                spobj->typ = SPP_REGION;
                spobj->data.r = target_r;
                j = 0;
                ++c;
                break;
            case P_UNIT:
                if (i < size) {
                    j = addparam_unit(param + i, &spobj, u, ord, &err);
                    ++c;
                }
                break;
            case P_BUILDING:
            case P_GEBAEUDE:
                if (i < size) {
                    j = addparam_building(param + i, &spobj);
                    ++c;
                }
                break;
            case P_SHIP:
                if (i < size) {
                    j = addparam_ship(param + i, &spobj);
                    ++c;
                }
                break;
            default:
                j = -1;
                break;
            }
            break;
        default:
            j = -1;
            break;
        }
        if (j < 0 && !err) {
            /* syntax error */
            err = msg_error(u, ord, 209);
        }
        else {
            if (spobj != NULL)
                par->param[p++] = spobj;
            i += j;
        }
    }

    /* im Endeffekt waren es evtl. nur p parameter (weniger weil TEMP nicht gilt) */
    par->length = p;

    if (!err && p < minlen) {
        /* syntax error */
        err = msg_error(u, ord, 209);
    }
    if (err) {
        ADDMSG(&u->faction->msgs, err);
        free_spellparameter(par);
        par = NULL;
    }
    return par;
}

struct unit * co_get_caster(const struct castorder * co) {
    return co->_familiar ? co->_familiar : co->magician.u;
}

struct unit * co_get_magician(const struct castorder * co) {
    return co->magician.u;
}

struct region * co_get_region(const struct castorder * co) {
    return co->_rtarget;
}

castorder *create_castorder(castorder * co, unit *caster, unit * familiar, const spell * sp, region * r,
    int lev, double force, int range, struct order * ord, spellparameter * p)
{
    if (!co) co = (castorder*)calloc(1, sizeof(castorder));
    if (!co) abort();

    co->magician.u = caster;
    co->_familiar = familiar;
    co->sp = sp;
    co->level = lev;
    co->force = MagicPower(force);
    co->_rtarget = r ? r : (familiar ? familiar->region : (caster ? caster->region : NULL));
    co->distance = range;
    co->order = copy_order(ord);
    co->par = p;

    return co;
}

void free_castorder(struct castorder *co)
{
    if (co->par) free_spellparameter(co->par);
    if (co->order) free_order(co->order);
}

/* Haenge c-order co an die letze c-order von cll an */
void add_castorder(spellrank * cll, castorder * co)
{
    if (cll->begin == NULL) {
        cll->handle_end = &cll->begin;
    }

    *cll->handle_end = co;
    cll->handle_end = &co->next;

    return;
}

void free_castorders(castorder * co)
{

    while (co) {
        castorder *co2 = co;
        co = co->next;
        free_castorder(co2);
        free(co2);
    }
    return;
}

bool is_familiar(const unit * u)
{
    attrib *a = a_find(u->attribs, &at_familiarmage);
    return a != NULL;
}

static void
a_write_unit(const variant *var, const void *owner, struct storage *store)
{
    unit *u = (unit *)var->v;
    UNUSED_ARG(owner);
    write_unit_reference(u, store);
}

static int sm_familiar(const unit * u, const region * r, skill_t sk, int value)
{                               /* skillmod */
    if (sk == SK_MAGIC)
        return value;
    else {
        int mod;
        unit *familiar = get_familiar(u);
        if (familiar == NULL) {
            /* the familiar is dead */
            return value;
        }
        mod = effskill(familiar, sk, r) / 2;
        if (r != familiar->region) {
            mod /= distance(r, familiar->region);
        }
        return value + mod;
    }
}

void set_familiar(unit * mage, unit * familiar)
{
    /* if the skill modifier for the mage does not yet exist, add it */
    attrib *a = a_find(mage->attribs, &at_skillmod);
    while (a && a->type == &at_skillmod) {
        skillmod_data *smd = (skillmod_data *)a->data.v;
        if (smd->special == sm_familiar)
            break;
        a = a->next;
    }
    if (a == NULL) {
        a = make_skillmod(NOSKILL, sm_familiar, 0.0, 0);
        a_add(&mage->attribs, a);
    }

    a = a_find(mage->attribs, &at_familiar);
    if (a == NULL) {
        a = a_add(&mage->attribs, a_new(&at_familiar));
        a->data.v = familiar;
    }
    else {
        assert(!a->data.v || a->data.v == familiar);
    }

    /* TODO: Diese Attribute beim Tod des Familiars entfernen: */
    a = a_find(familiar->attribs, &at_familiarmage);
    if (a == NULL) {
        a = a_add(&familiar->attribs, a_new(&at_familiarmage));
        a->data.v = mage;
    }
    else {
        assert(!a->data.v || a->data.v == mage);
    }
}

void remove_familiar(unit * mage)
{
    attrib *a = a_find(mage->attribs, &at_familiar);
    attrib *an;

    if (a != NULL) {
        a_remove(&mage->attribs, a);
    }
    a = a_find(mage->attribs, &at_skillmod);
    while (a && a->type == &at_skillmod) {
        skillmod_data *smd = (skillmod_data *)a->data.v;
        an = a->next;
        if (smd->special == sm_familiar) {
            a_remove(&mage->attribs, a);
        }
        a = an;
    }
}

static void equip_familiar(unit *fam) {
    /* items, skills and spells: */
    char eqname[64];
    const race *rc = u_race(fam);

    snprintf(eqname, sizeof(eqname), "fam_%s", rc->_name);
    if (!equip_unit(fam, eqname)) {
        log_debug("could not perform initialization for familiar %s.\n", rc->_name);
    }
}

static int copy_spell_cb(spellbook_entry *sbe, void *udata) {
    spellbook *sb = (spellbook *)udata;
    spell * sp = spellref_get(&sbe->spref);
    if (!spellbook_get(sb, sp)) {
        spellbook_add(sb, sp, sbe->level);
    }
    return 0;
}

/**
 * Entferne Magie-Attribut von Migranten, die keine Vertrauten sind.
 *
 * Einmalige Reparatur von Vertrauten (Bug 2585).
 */
void fix_fam_migrant(unit *u) {
    if (!is_familiar(u)) {
        a_removeall(&u->attribs, &at_mage);
    }
}

/**
 * Einheiten, die Vertraute sind, bekommen ihre fehlenden Zauber.
 *
 * Einmalige Reparatur von Vertrauten (Bugs 2451, 2517).
 */
void fix_fam_spells(unit *u) {
    sc_mage *dmage;
    unit *du = unit_create(0);

    if (!is_familiar(u)) {
        return;
    }

    u_setrace(du, u_race(u));
    dmage = create_mage(du, M_GRAY);
    equip_familiar(du);
    if (dmage) {
        sc_mage *mage = get_mage(u);
        if (!mage) {
            mage = create_mage(u, dmage->magietyp);
        }
        else if (dmage->magietyp != mage->magietyp) {
            mage->magietyp = dmage->magietyp;
        }
        if (dmage->spellbook) {
            if (!mage->spellbook) {
                mage->spellbook = create_spellbook(NULL);
                spellbook_foreach(dmage->spellbook, copy_spell_cb, mage->spellbook);
            }
        }
        else {
            if (mage->spellbook) {
                spellbook_clear(mage->spellbook);
                mage->spellbook = NULL;
            }
        }
    }
    free_unit(du);
}

void create_newfamiliar(unit * mage, unit * fam)
{
    create_mage(fam, M_GRAY);
    set_familiar(mage, fam);
    equip_familiar(fam);

    /* TODO: Diese Attribute beim Tod des Familiars entfernen: */
    /* Wenn der Magier stirbt, dann auch der Vertraute */
    add_trigger(&mage->attribs, "destroy", trigger_killunit(fam));
    /* Wenn der Vertraute stirbt, dann bekommt der Magier einen Schock */
    add_trigger(&fam->attribs, "destroy", trigger_shock(mage));
}

static void * resolve_familiar(int id, void *data) {
    UNUSED_ARG(id);
    if (data) {
        unit *familiar = (unit *)data;
        attrib *a = a_find(familiar->attribs, &at_familiarmage);
        if (a != NULL && a->data.v) {
            unit *mage = (unit *)a->data.v;
            set_familiar(mage, familiar);
        }
    }
    return data;
}

static int read_familiar(variant *var, void *owner, struct gamedata *data)
{
    UNUSED_ARG(owner);
    if (read_unit_reference(data, (unit **)&var->v, resolve_familiar) <= 0) {
        return AT_READ_FAIL;
    }
    return AT_READ_OK;
}

/* clones */

void create_newclone(unit * mage, unit * clone)
{
    attrib *a;

    a = a_find(mage->attribs, &at_clone);
    if (a == NULL) {
        a = a_add(&mage->attribs, a_new(&at_clone));
        a->data.v = clone;
    }
    else
        assert(!a->data.v || a->data.v == clone);
    /* TODO: Diese Attribute beim Tod des Klons entfernen: */

    a = a_find(clone->attribs, &at_clonemage);
    if (a == NULL) {
        a = a_add(&clone->attribs, a_new(&at_clonemage));
        a->data.v = mage;
    }
    else
        assert(!a->data.v || a->data.v == mage);

    /* Wenn der Magier stirbt, wird das in destroy_unit abgefangen.
     * Kein Trigger, zu kompliziert. */

     /* Wenn der Klon stirbt, dann bekommt der Magier einen Schock */
    add_trigger(&clone->attribs, "destroy", trigger_clonedied(mage));
}

static void set_clone(unit * mage, unit * clone)
{
    attrib *a;

    a = a_find(mage->attribs, &at_clone);
    if (a == NULL) {
        a = a_add(&mage->attribs, a_new(&at_clone));
        a->data.v = clone;
    }
    else
        assert(!a->data.v || a->data.v == clone);

    a = a_find(clone->attribs, &at_clonemage);
    if (a == NULL) {
        a = a_add(&clone->attribs, a_new(&at_clonemage));
        a->data.v = mage;
    }
    else
        assert(!a->data.v || a->data.v == mage);
}

static void * resolve_clone(int id, void *data) {
    UNUSED_ARG(id);
    if (data) {
        unit *clone = (unit *)data;
        attrib *a = a_find(clone->attribs, &at_clonemage);
        if (a != NULL && a->data.v) {
            unit *mage = (unit *)a->data.v;
            set_clone(mage, clone);
        }
    }
    return data;
}

static int read_clone(variant *var, void *owner, struct gamedata *data)
{
    UNUSED_ARG(owner);
    if (read_unit_reference(data, (unit **)&var->v, resolve_clone) <= 0) {
        return AT_READ_FAIL;
    }
    return AT_READ_OK;
}

/* mages */
static void * resolve_mage(int id, void *data) {
    UNUSED_ARG(id);
    if (data) {
        unit *mage = (unit *)data;
        attrib *a = a_find(mage->attribs, &at_familiar);
        if (a != NULL && a->data.v) {
            unit *familiar = (unit *)a->data.v;
            set_familiar(mage, familiar);
        }
    }
    return data;
}

static int read_magician(variant *var, void *owner, struct gamedata *data)
{
    UNUSED_ARG(owner);
    if (read_unit_reference(data, (unit **)&var->v, resolve_mage) <= 0) {
        return AT_READ_FAIL;
    }
    return AT_READ_OK;
}

static int age_unit(attrib * a, void *owner)
/* if unit is gone or dead, remove the attribute */
{
    unit *u = (unit *)a->data.v;
    UNUSED_ARG(owner);
    return (u != NULL && u->number > 0) ? AT_AGE_KEEP : AT_AGE_REMOVE;
}

attrib_type at_familiarmage = {
    "familiarmage",
    NULL,
    NULL,
    age_unit,
    a_write_unit,
    read_magician,
    NULL,
    ATF_UNIQUE
};

attrib_type at_familiar = {
    "familiar",
    NULL,
    NULL,
    age_unit,
    a_write_unit,
    read_familiar,
    NULL,
    ATF_UNIQUE
};

attrib_type at_clonemage = {
    "clonemage",
    NULL,
    NULL,
    age_unit,
    a_write_unit,
    read_magician,
    NULL,
    ATF_UNIQUE
};

attrib_type at_clone = {
    "clone",
    NULL,
    NULL,
    age_unit,
    a_write_unit,
    read_clone,
    NULL,
    ATF_UNIQUE
};

unit *get_familiar(const unit * u)
{
    attrib *a = a_find(u->attribs, &at_familiar);
    if (a != NULL) {
        unit *uf = (unit *)a->data.v;
        if (uf->number > 0)
            return uf;
    }
    return NULL;
}

unit *get_familiar_mage(const unit * u)
{
    attrib *a = a_find(u->attribs, &at_familiarmage);
    if (a != NULL) {
        unit *um = (unit *)a->data.v;
        if (um->number > 0)
            return um;
    }
    return NULL;
}

unit *get_clone(const unit * u)
{
    attrib *a = a_find(u->attribs, &at_clone);
    if (a != NULL) {
        unit *uc = (unit *)a->data.v;
        if (uc->number > 0) {
            return uc;
        }
    }
    return NULL;
}

static bool is_moving_ship(ship * sh)
{
    const unit *u = ship_owner(sh);

    if (u) {
        switch (getkeyword(u->thisorder)) {
        case K_ROUTE:
        case K_MOVE:
        case K_FOLLOW:
            return true;
        default:
            return false;
        }
    }
    return false;
}

#define MAX_PARAMETERS 48
static castorder *cast_cmd(unit * u, order * ord)
{
    char token[128];
    region *r = u->region;
    region *target_r = r;
    int level, range;
    unit *familiar = NULL;
    const char *s;
    spell *sp = 0;
    plane *pl;
    spellparameter *args = NULL;
    unit * mage = u;
    param_t param;

    if (LongHunger(u)) {
        cmistake(u, ord, 224, MSG_MAGIC);
        return 0;
    }
    pl = getplane(r);
    if (pl && fval(pl, PFL_NOMAGIC)) {
        cmistake(u, ord, 269, MSG_MAGIC);
        return 0;
    }
    level = effskill(u, SK_MAGIC, NULL);

    init_order_depr(ord);
    s = gettoken(token, sizeof(token));
    param = findparam(s, u->faction->locale);
    /* fuer Syntax ' STUFE x REGION y z ' */
    if (param == P_LEVEL) {
        int p = getint();
        if (level > p) level = p;
        if (level < 1) {
            /* Fehler "Das macht wenig Sinn" */
            syntax_error(u, ord);
            return 0;
        }
        s = gettoken(token, sizeof(token));
        param = findparam(s, u->faction->locale);
    }
    if (param == P_REGION) {
        int t_x = getint();
        int t_y = getint();

        t_x = rel_to_abs(pl, u->faction, t_x, 0);
        t_y = rel_to_abs(pl, u->faction, t_y, 1);
        pnormalize(&t_x, &t_y, pl);
        target_r = findregion(t_x, t_y);
        if (!target_r) {
            /* Fehler "Die Region konnte nicht verzaubert werden" */
            ADDMSG(&u->faction->msgs, msg_message("spellregionresists",
                "unit region command", u, u->region, ord));
            return 0;
        }
        s = gettoken(token, sizeof(token));
        param = findparam(s, u->faction->locale);
    }
    /* fuer Syntax ' REGION x y STUFE z '
     * hier nach REGION nochmal auf STUFE pruefen */
    if (param == P_LEVEL) {
        int p = getint();
        if (level > p) level = p;
        if (level < 1) {
            /* Fehler "Das macht wenig Sinn" */
            syntax_error(u, ord);
            return 0;
        }
        s = gettoken(token, sizeof(token));
    }
    if (!s || !s[0]) {
        /* Fehler "Es wurde kein Zauber angegeben" */
        cmistake(u, ord, 172, MSG_MAGIC);
        return 0;
    }

    sp = unit_getspell(u, s, u->faction->locale);

    /* Vertraute koennen auch Zauber sprechen, die sie selbst nicht
     * koennen. unit_getspell findet aber nur jene Sprueche, die
     * die Einheit beherrscht. */
    if (!sp && is_familiar(u)) {
        mage = get_familiar_mage(u);
        if (mage) {
            familiar = u;
            sp = unit_getspell(mage, s, mage->faction->locale);
        }
        else {
            /* somehow, this familiar has no mage! */
            log_error("cast_cmd: familiar %s is without a mage?\n", unitname(u));
            mage = u;
        }
    }

    if (!sp) {
        /* Fehler 'Spell not found' */
        cmistake(u, ord, 173, MSG_MAGIC);
        return 0;
    }
    /* um testen auf spruchnamen zu unterbinden sollte vor allen
     * fehlermeldungen die anzeigen das der magier diesen Spruch
     * nur in diese Situation nicht anwenden kann, noch eine
     * einfache Sicherheitspruefung kommen */
    if (!knowsspell(r, u, sp)) {
        /* vorsicht! u kann der familiar sein */
        if (!familiar) {
            cmistake(u, ord, 173, MSG_MAGIC);
            return 0;
        }
    }
    if (sp->sptyp & ISCOMBATSPELL) {
        /* Fehler: "Dieser Zauber ist nur im Kampf sinnvoll" */
        cmistake(u, ord, 174, MSG_MAGIC);
        return 0;
    }
    /* Auf dem Ozean Zaubern als quasi-langer Befehl koennen
     * normalerweise nur Meermenschen, ausgenommen explizit als
     * OCEANCASTABLE deklarierte Sprueche */
    if (fval(r->terrain, SEA_REGION)) {
        if (u_race(u) != get_race(RC_AQUARIAN)
            && !fval(u_race(u), RCF_SWIM)
            && !(sp->sptyp & OCEANCASTABLE)) {
            /* Fehlermeldung */
            ADDMSG(&u->faction->msgs, msg_message("spellfail_onocean",
                "unit region command", u, u->region, ord));
            return 0;
        }
        /* Auf bewegenden Schiffen kann man nur explizit als
         * ONSHIPCAST deklarierte Zauber sprechen */
    }
    else if (u->ship) {
        if (is_moving_ship(u->ship)) {
            if (!(sp->sptyp & ONSHIPCAST)) {
                /* Fehler: "Diesen Spruch kann man nicht auf einem sich
                 * bewegenden Schiff stehend zaubern" */
                cmistake(u, ord, 175, MSG_MAGIC);
                return 0;
            }
        }
    }
    /* Farcasting bei nicht farcastbaren Spruechen abfangen */
    range = farcasting(u, target_r);
    if (range > 1) {
        if (!(sp->sptyp & FARCASTING)) {
            /* Fehler "Diesen Spruch kann man nicht in die Ferne
             * richten" */
            cmistake(u, ord, 176, MSG_MAGIC);
            return 0;
        }
        if (range > 1024) {         /* (2^10) weiter als 10 Regionen entfernt */
            ADDMSG(&u->faction->msgs, msg_feedback(u, ord, "spellfail::nocontact",
                "target", target_r));
            return 0;
        }
    }
    /* Stufenangabe bei nicht Stufenvariierbaren Spruechen abfangen */
    if (!(sp->sptyp & SPELLLEVEL)) {
        int ilevel = effskill(u, SK_MAGIC, NULL);
        if (ilevel != level) {
            level = ilevel;
            ADDMSG(&u->faction->msgs, msg_message("spellfail::nolevel",
                "mage region command", u, u->region, ord));
        }
    }
    /* Vertrautenmagie */
    /* Kennt der Vertraute den Spruch, so zaubert er ganz normal.
     * Ansonsten zaubert der Magier durch seinen Vertrauten, dh
     * zahlt Komponenten und Aura. Dabei ist die maximale Stufe
     * die des Vertrauten!
     * Der Spruch wirkt dann auf die Region des Vertrauten und
     * gilt nicht als Farcasting. */
    if (familiar) {
        if ((sp->sptyp & NOTFAMILIARCAST)) {
            /* Fehler: "Diesen Spruch kann der Vertraute nicht zaubern" */
            cmistake(u, ord, 177, MSG_MAGIC);
            return 0;
        }
        if (mage != familiar) {        /* Magier zaubert durch Vertrauten */
            int sk;
            if (range > 1) {          /* Fehler! Versucht zu Farcasten */
                ADDMSG(&u->faction->msgs, msg_feedback(u, ord, "familiar_farcast",
                    "mage", mage));
                return 0;
            }
            sk = effskill(mage, SK_MAGIC, NULL);
            if (distance(mage->region, r) > sk) {
                ADDMSG(&u->faction->msgs, msg_feedback(u, ord, "familiar_toofar",
                    "mage", mage));
                return 0;
            }
            /* mage auf magier setzen, level anpassen, range fuer Erhoehung
             * der Spruchkosten nutzen */
            range *= 2;
            sk /= 2;
            if (level > sk) level = sk;
        }
    }
    /* Weitere Argumente zusammenbasteln */
    if (sp->parameter) {
        char *params[MAX_PARAMETERS];
        int i, p;
        for (p = 0; p != MAX_PARAMETERS; ++p) {
            s = gettoken(token, sizeof(token));
            if (!s || *s == 0) {
                break;
            }
            params[p] = str_strdup(s);
        }
        if (p == MAX_PARAMETERS) {
            log_error("%s: MAX_PARAMETERS (%d) too small to CAST %s, parsing stopped early.",
                unitname(u), MAX_PARAMETERS, sp->sname);
        }
        args =
            add_spellparameter(target_r, mage, sp->parameter,
            (const char *const *)params, p, ord);
        for (i = 0; i != p; ++i) {
            free(params[i]);
        }
        if (args == NULL) {
            /* Syntax war falsch */
            return 0;
        }
    }
    return create_castorder(0, mage, familiar, sp, target_r, level, 0, range, ord,
        args);
}

/* ------------------------------------------------------------- */
/* Damit man keine Rituale in fremden Gebiet machen kann, diese vor
 * Bewegung zaubern. Magier sind also in einem fremden Gebiet eine Runde
 * lang verletzlich, da sie es betreten, und angegriffen werden koennen,
 * bevor sie ein Ritual machen koennen.
 *
 * Syntax: ZAUBER [REGION X Y] [STUFE <stufe>] "Spruchname" [Einheit-1
 * Einheit-2 ..]
 *
 * Nach Prioritaet geordnet die Zauber global auswerten.
 *
 * Die Kosten fuer Farcasting multiplizieren sich mit der Entfernung,
 * cast_level gibt die virtuelle Stufe an, die den durch das Farcasten
 * entstandenen Spruchkosten entspricht.  Sind die Spruchkosten nicht
 * levelabhaengig, so sind die Kosten nur von der Entfernung bestimmt,
 * die Staerke/Level durch den realen Skill des Magiers
 */

void magic(void)
{
    region *r;
    int rank;
    spellrank spellranks[MAX_SPELLRANK];
    const race *rc_insect = get_race(RC_INSECT);

    memset(spellranks, 0, sizeof(spellranks));

    for (r = regions; r; r = r->next) {
        unit *u;
        for (u = r->units; u; u = u->next) {
            order *ord;

            if (u->number <= 0)
                continue;

            if (u_race(u) == rc_insect && r_insectstalled(r) &&
                !is_cursed(u->attribs, &ct_insectfur))
                continue;

            if (fval(u, UFL_WERE | UFL_LONGACTION)) {
                continue;
            }

            for (ord = u->orders; ord; ord = ord->next) {
                if (getkeyword(ord) == K_CAST) {
                    castorder *co = cast_cmd(u, ord);
                    fset(u, UFL_LONGACTION | UFL_NOTMOVING);
                    if (co) {
                        const spell *sp = co->sp;
                        add_castorder(&spellranks[sp->rank], co);
                    }
                }
            }
        }
    }

    /* Da sich die Aura und Komponenten in der Zwischenzeit veraendert
     * haben koennen und sich durch vorherige Sprueche das Zaubern
     * erschwert haben kann, muss beim zaubern erneut geprueft werden, ob der
     * Spruch ueberhaupt gezaubert werden kann.
     * (level) die effektive Staerke des Spruchs (= Stufe, auf der der
     * Spruch gezaubert wird) */

    for (rank = 0; rank < MAX_SPELLRANK; rank++) {
        castorder *co;
        for (co = spellranks[rank].begin; co; co = co->next) {
            order *ord = co->order;
            int invalid, resist, success, cast_level = co->level;
            bool fumbled = false;
            unit *mage = co_get_magician(co);
            unit *caster = co_get_caster(co);
            const spell *sp = co->sp;
            region *target_r = co_get_region(co);

            /* reichen die Komponenten nicht, wird der Level reduziert. */
            co->level = eff_spelllevel(mage, caster, sp, cast_level, co->distance);

            if (co->level < 1) {
                /* Fehlermeldung mit Komponenten generieren */
                cancast(mage, sp, cast_level, co->distance, ord);
                continue;
            }

            if (cast_level > co->level) {
                /* Sprueche mit Fixkosten werden immer auf Stufe des Spruchs
                 * gezaubert, co->level ist aber defaultmaessig Stufe des Magiers */
                if (spl_costtyp(sp) != SPC_FIX) {
                    ADDMSG(&caster->faction->msgs, msg_message("missing_components",
                        "unit spell level", caster, sp, cast_level));
                }
            }

            /* Pruefen, ob die realen Kosten fuer die gewuenschten Stufe bezahlt
             * werden koennen */
            if (!cancast(mage, sp, co->level, co->distance, ord)) {
                /* die Fehlermeldung wird in cancast generiert */
                continue;
            }

            co->force = MagicPower(spellpower(target_r, mage, sp, co->level, ord));
            /* die Staerke kann durch Antimagie auf 0 sinken */
            if (co->force <= 0) {
                co->force = 0;
                ADDMSG(&caster->faction->msgs, msg_message("missing_force",
                    "unit spell level", caster, sp, co->level));
            }

            /* Ziele auf Existenz pruefen und Magieresistenz feststellen. Wurde
             * kein Ziel gefunden, so ist verify_targets=0. Scheitert der
             * Spruch an der Magieresistenz, so ist verify_targets = 1, bei
             * Erfolg auf ganzer Linie ist verify_targets= 2
             */
            verify_targets(co, &invalid, &resist, &success);
            if (success + resist == 0) {
                /* kein Ziel gefunden, Fehlermeldungen sind in verify_targets */
                /* keine kosten fuer den zauber */
                continue;               /* aeussere Schleife, naechster Zauberer */
            }
            else if (co->force > 0 && resist > 0) {
                /* einige oder alle Ziele waren magieresistent */
                if (success == 0) {
                    co->force = 0;
                    /* zwar wurde mindestens ein Ziel gefunden, das widerstand
                     * jedoch dem Zauber. Kosten abziehen und abbrechen. */
                    ADDMSG(&caster->faction->msgs, msg_message("spell_resist",
                        "unit region spell", caster, r, sp));
                }
            }

            /* Auch fuer Patzer gibt es Erfahrung, muessen die Spruchkosten
             * bezahlt werden und die nachfolgenden Sprueche werden teurer */
            if (co->force > 0) {
                if (fumble(target_r, mage, sp, co->level)) {
                    /* zuerst bezahlen, dann evt in do_fumble alle Aura verlieren */
                    fumbled = true;
                }
                else {
                    co->level = cast_spell(co);
                    if (co->level <= 0) {
                        /* Kosten nur fuer real benoetige Stufe berechnen */
                        continue;
                    }
                }
            }
            /* erst bezahlen, dann Kostenzaehler erhoehen */
            if (co->level > 0) {
                pay_spell(mage, caster, sp, co->level, co->distance);
            }
            if (fumbled) {
                do_fumble(co);
            }
            countspells(caster, 1);
        }
    }

    /* Sind alle Zauber gesprochen gibts Erfahrung */
    for (r = regions; r; r = r->next) {
        unit *u;
        for (u = r->units; u; u = u->next) {
            if (is_mage(u) && spellcount(u) > 0) {
                produceexp(u, SK_MAGIC, u->number);
                /* Spruchlistenaktualisierung ist in Regeneration */
            }
        }
    }
    for (rank = 0; rank < MAX_SPELLRANK; rank++) {
        free_castorders(spellranks[rank].begin);
    }
    remove_empty_units();
}

const char *spell_info(const spell * sp, const struct locale *lang)
{
    return LOC(lang, mkname("spellinfo", sp->sname));
}

/* TODO: should take the name, not the spell (spellref optimizations) */
const char *spell_name(const spell * sp, const struct locale *lang)
{
    return LOC(lang, mkname("spell", sp->sname));
}

const char *curse_name(const curse_type * ctype, const struct locale *lang)
{
    return LOC(lang, mkname("spell", ctype->cname));
}

static void select_spellbook(void **tokens, spellbook *sb, const struct locale * lang) {
    selist * ql;
    int qi;

    assert(sb);
    assert(lang);

    for (qi = 0, ql = sb->spells; ql; selist_advance(&ql, &qi, 1)) {
        spellbook_entry *sbe = (spellbook_entry *)selist_get(ql, qi);
        const spell *sp = spellref_get(&sbe->spref);
        const char *n = spell_name(sp, lang);
        if (!n) {
            log_error("no translation in locale %s for spell %s\n", locale_name(lang), sp->sname);
        }
        else {
            variant token;
            token.v = (void *)sp;
            addtoken((struct tnode **)tokens, n, token);
        }
    }
}

spell *unit_getspell(struct unit *u, const char *name, const struct locale * lang)
{
    spellbook *sb;

    sb = unit_get_spellbook(u);
    if (sb) {
        void * tokens = NULL;
        select_spellbook(&tokens, sb, lang);
        if (tokens) {
            variant token;
            if (findtoken(tokens, name, &token) != E_TOK_NOMATCH) {
                freetokens(tokens);
                return (spell *)token.v;
            }
            freetokens(tokens);
        }
    }
    return NULL;
}

int cast_spell(struct castorder *co)
{
    const char *fname = co->sp->sname;
    const char *hashpos = strchr(fname, '#');
    char fbuf[64];
    spell_f fun;

    const spell *sp = co->sp;
    if (hashpos != NULL) {
        ptrdiff_t len = hashpos - fname;
        assert(len < (ptrdiff_t) sizeof(fbuf));
        memcpy(fbuf, fname, len);
        fbuf[len] = '\0';
        fname = fbuf;
    }

    fun = get_spellcast(sp->sname);
    if (!fun) {
        log_debug("no spell function for %s, try callback", sp->sname);
        return callbacks.cast_spell(co, fname);
    }
    return fun(co);
}

const char *magic_name(magic_t mtype, const struct locale *lang)
{
    return LOC(lang, mkname("school", magic_school[mtype]));
}

static critbit_tree cb_spellbooks;

#define SBNAMELEN 16

typedef struct sb_entry {
    char key[SBNAMELEN];
    spellbook *value;
} sb_entry;

spellbook * get_spellbook(const char * name)
{
    size_t len = strlen(name);
    const void * match;

    if (len >= SBNAMELEN) {
        log_error("spellbook name is longer than %d bytes: %s", SBNAMELEN - 1, name);
        return NULL;
    }

    match = cb_find_str(&cb_spellbooks, name);
    if (!match) {
        sb_entry ent;
        memset(ent.key, 0, SBNAMELEN);
        memcpy(ent.key, name, len);
        ent.value = create_spellbook(name);
        if (cb_insert(&cb_spellbooks, &ent, sizeof(ent)) == CB_EXISTS) {
            log_error("cb_insert failed although cb_find returned nothing for spellbook=%s", name);
            assert(!"should not happen");
        }
        return ent.value;
    }
    return ((const sb_entry *)match)->value;
}

void free_spellbook(spellbook *sb) {
    spellbook_clear(sb);
    free(sb);
}

static int free_spellbook_cb(void *match, const void *key, size_t keylen, void *data) {
    const sb_entry *ent = (const sb_entry *)match;
    UNUSED_ARG(data);
    UNUSED_ARG(keylen);
    UNUSED_ARG(key);
    free_spellbook(ent->value);
    return 0;
}

void free_spellbooks(void)
{
    cb_foreach(&cb_spellbooks, "", 0, free_spellbook_cb, NULL);
    cb_clear(&cb_spellbooks);
}