Example #1
0
static void test_set_insert_ex(CuTest * tc)
{
    const char * strings[] = {
        "aaa", "bbb", "ccc", "ddd"
    };
    struct quicklist *ql = NULL;
    int qi;

    /* insert a string: */
    CuAssertIntEquals(tc, ql_true, ql_set_insert_ex(&ql, (void *)strings[0], cmp_str));
    CuAssertIntEquals(tc, 1, ql_length(ql));

    /* insert a second string: */
    CuAssertIntEquals(tc, ql_true, ql_set_insert_ex(&ql, (void *)strings[1], cmp_str));
    CuAssertIntEquals(tc, 2, ql_length(ql));
    /* same string again, no change: */
    CuAssertIntEquals(tc, ql_false, ql_set_insert_ex(&ql, (void *)strings[1], cmp_str));
    CuAssertIntEquals(tc, 2, ql_length(ql));

    /* a third string */
    CuAssertIntEquals(tc, ql_true, ql_set_insert_ex(&ql, (void *)strings[2], cmp_str));
    CuAssertIntEquals(tc, 3, ql_length(ql));

    /* check that they are alphabetically ordered: */
    for (qi = 0; qi != 3; ++qi) {
        CuAssertPtrEquals(tc, (void *)strings[qi], ql_get(ql, qi));
    }

    CuAssertIntEquals(tc, 1, ql_set_find_ex(&ql, &qi, (void *)strings[2], cmp_str));
    CuAssertIntEquals(tc, 2, qi);
    ql_free(ql);
}
Example #2
0
static attrib *set_new_dragon_target(unit * u, region * r, int range)
{
    int max_affinity = 0;
    region *max_region = NULL;
    quicklist *ql, *rlist = regions_in_range(r, range, allowed_dragon);
    int qi;

    for (qi = 0, ql = rlist; ql; ql_advance(&ql, &qi, 1)) {
        region *r2 = (region *)ql_get(ql, qi);
        int affinity = dragon_affinity_value(r2, u);
        if (affinity > max_affinity) {
            max_affinity = affinity;
            max_region = r2;
        }
    }

    ql_free(rlist);

    if (max_region && max_region != r) {
        attrib *a = a_find(u->attribs, &at_targetregion);
        if (!a) {
            a = a_add(&u->attribs, make_targetregion(max_region));
        }
        else {
            a->data.v = max_region;
        }
        return a;
    }
    return NULL;
}
Example #3
0
static void test_set_remove(CuTest * tc)
{
    struct quicklist *ql = NULL, *q2;
    int a;

    ql_set_insert(&ql, (void *)data);
    ql_set_insert(&ql, (void *)(data + 1));
    ql_set_insert(&ql, (void *)(data + 2));

    q2 = ql;

    a = ql_set_remove(&ql, (void *)(data + 1));
    CuAssertIntEquals(tc, ql_true, a);
    CuAssertPtrEquals(tc, q2, ql);
    CuAssertPtrEquals(tc, (void *)data, ql_get(ql, 0));
    CuAssertPtrEquals(tc, (void *)(data + 2), ql_get(ql, 1));
    CuAssertIntEquals(tc, 2, ql_length(ql));

    a = ql_set_remove(&ql, (void *)(data + 1));
    CuAssertIntEquals(tc, ql_false, a);
    CuAssertPtrEquals(tc, q2, ql);

    a = ql_set_remove(&ql, (void *)data);
    CuAssertIntEquals(tc, ql_true, a);
    a = ql_set_remove(&ql, (void *)(data + 2));
    CuAssertIntEquals(tc, ql_true, a);
    CuAssertPtrEquals(tc, 0, ql);

    ql_free(ql);
}
Example #4
0
static void test_set_find(CuTest * tc)
{
    struct quicklist *ql = 0, *q2;
    int a, qi;

    q2 = ql;
    a = ql_set_find(&q2, 0, (void *)data);
    CuAssertIntEquals(tc, ql_false, a);
    CuAssertPtrEquals(tc, ql, q2);

    for (a = 0; a != 32; ++a) {
        ql_set_insert(&ql, (void *)(data + a));
    }

    q2 = ql;
    a = ql_set_find(&q2, 0, (void *)(data + 31));
    CuAssertIntEquals(tc, ql_true, a);
    CuAssertPtrEquals(tc, ql, q2);

    q2 = ql;
    a = ql_set_find(&ql, &qi, (void *)data);
    CuAssertIntEquals(tc, ql_true, a);
    CuAssertIntEquals(tc, 0, qi);
    CuAssertPtrEquals(tc, ql, q2);

    q2 = ql;
    a = ql_set_find(&ql, &qi, (void *)(data + 31));
    CuAssertIntEquals(tc, ql_true, a);
    CuAssertPtrEquals(tc, (void *)(data + 31), ql_get(ql, qi));
    CuAssertTrue(tc, ql != q2);

    ql_free(ql);
}
Example #5
0
static void test_set_insert(CuTest * tc)
{
    struct quicklist *ql = NULL;
    int a, qi;
    a = ql_set_insert(&ql, (void *)data);
    CuAssertIntEquals(tc, 1, ql_length(ql));
    CuAssertIntEquals(tc, ql_true, a);
    a = ql_set_insert(&ql, (void *)(data + 1));
    CuAssertIntEquals(tc, 2, ql_length(ql));
    CuAssertIntEquals(tc, ql_true, a);
    a = ql_set_insert(&ql, (void *)data);
    CuAssertIntEquals(tc, 2, ql_length(ql));
    CuAssertIntEquals(tc, ql_false, a);
    a = ql_set_insert(&ql, (void *)(data + 2));
    CuAssertIntEquals(tc, ql_true, a);
    CuAssertIntEquals(tc, 3, ql_length(ql));
    CuAssertPtrEquals(tc, (void *)data, ql_get(ql, 0));
    CuAssertPtrEquals(tc, (void *)(data + 1), ql_get(ql, 1));
    CuAssertPtrEquals(tc, (void *)(data + 2), ql_get(ql, 2));

    a = ql_set_find(&ql, &qi, (void *)(data + 3));
    CuAssertIntEquals(tc, 0, a);
    a = ql_set_find(&ql, &qi, (void *)data);
    CuAssertIntEquals(tc, 1, a);
    CuAssertPtrEquals(tc, (void *)data, ql_get(ql, qi));
    ql_free(ql);
}
Example #6
0
static void test_insert_delete_gives_null(CuTest * tc)
{
    struct quicklist *ql = NULL;
    CuAssertIntEquals(tc, 1, ql_empty(ql));
    ql_push(&ql, (void *)data);
    CuAssertIntEquals(tc, 0, ql_empty(ql));
    ql_delete(&ql, 0);
    CuAssertPtrEquals(tc, 0, ql);
    ql_free(ql);
}
Example #7
0
static void test_replace(CuTest * tc)
{
    struct quicklist *ql = NULL;
    void * a;
    ql_push(&ql, (void *)data);
    a = ql_replace(ql, 0, (void *)(data + 1));
    CuAssertPtrEquals(tc, (void *)data, a);
    CuAssertPtrEquals(tc, (void *)(data + 1), ql_get(ql, 0));
    ql_free(ql);
}
Example #8
0
static void test_delete_edgecases(CuTest * tc)
{
    struct quicklist *ql = NULL;
    ql_delete(&ql, 0);
    CuAssertPtrEquals(tc, 0, ql);
    ql_push(&ql, (void *)data);
    ql_delete(&ql, -1);
    ql_delete(&ql, 32);
    CuAssertIntEquals(tc, 1, ql_length(ql));
    ql_free(ql);
}
Example #9
0
static void test_foreach(CuTest *tc) {
    int total = 0;
    struct quicklist *ql = 0;
    ql_push(&ql, (void *)data);
    ql_push(&ql, (void *)data);
    ql_foreach(ql, my_callback);
    CuAssertIntEquals(tc, 152, gtotal);
    ql_foreachx(ql, my_callbackx, &total);
    CuAssertIntEquals(tc, 152, total);
    ql_free(ql);
}
Example #10
0
static void test_mapreduce(CuTest * tc)
{
    int buffer;
    int result = 0;
    struct quicklist *ql = 0;
    ql_push(&ql, (void *)data);
    ql_push(&ql, (void *)data);
    ql_map_reduce(ql, my_map, my_reduce, &buffer, &result);
    CuAssertIntEquals(tc, 152, result);
    ql_free(ql);
}
Example #11
0
/* Feuersturm: Betrifft sehr viele Gegner (in der Regel alle),
 * macht nur vergleichsweise geringen Schaden */
int sp_immolation(struct castorder * co)
{
    fighter * fi = co->magician.fig;
    int level = co->level;
    const spell * sp = co->sp;
    battle *b = fi->side->battle;
    troop at;
    int force, qi, killed = 0;
    const char *damage;
    quicklist *fgs, *ql;
    message *m;

    /* 2d4 HP */
    damage = spell_damage(5);
    /* Betrifft alle Gegner */
    force = 99999;

    if (!count_enemies(b, fi, FIGHT_ROW, AVOID_ROW, SELECT_ADVANCE | SELECT_FIND)) {
        message *m =
            msg_message("battle::out_of_range", "mage spell", fi->unit, sp);
        message_all(b, m);
        msg_release(m);
        return 0;
    }

    at.fighter = fi;
    at.index = 0;

    fgs = fighters(b, fi->side, FIGHT_ROW, AVOID_ROW, FS_ENEMY);
    for (qi = 0, ql = fgs; ql; ql_advance(&ql, &qi, 1)) {
        fighter *df = (fighter *)ql_get(ql, qi);
        int n = df->alive - df->removed;
        troop dt;

        dt.fighter = df;
        while (n != 0) {
            dt.index = --n;
            killed += terminate(dt, at, AT_COMBATSPELL, damage, false);
            if (--force == 0)
                break;
        }
        if (force == 0)
            break;
    }
    ql_free(fgs);

    m =
        msg_message("battle::combatspell", "mage spell killed", fi->unit, sp,
        killed);
    message_all(b, m);
    msg_release(m);
    return level;
}
Example #12
0
static void test_push_returns_end(CuTest * tc)
{
    struct quicklist *result, *ql = NULL;
    int i = 0, qi = 0;
    do {
        result = ql_push(&ql, 0);
        i++;
    } while (result == ql);
    ql_advance(&ql, &qi, i - 1);
    CuAssertPtrEquals(tc, result, ql);
    ql_free(ql);
}
Example #13
0
void spellbook_clear(spellbook *sb)
{
  quicklist *ql;
  int qi;

  assert(sb);
  for (qi = 0, ql = sb->spells; ql; ql_advance(&ql, &qi, 1)) {
    spellbook_entry *sbe = (spellbook_entry *) ql_get(ql, qi);
    free(sbe);
  }
  ql_free(sb->spells);
}
Example #14
0
void free_region(region *r) {
    region **bucket;

    bucket = &regionhash[r->uid & RHASHMASK];
    while (*bucket!=r) {
        bucket = &(*bucket)->nexthash_;
    }
    *bucket = r->nexthash_;
    free(r->name_);
    while (r->units) {
        unit *u = r->units;
        r->units = u->next;
        free_unit(u);
    }
    ql_foreach(r->ships, (ql_cb)free_ship);
    ql_free(r->ships);
    r->ships = 0;
    ql_foreach(r->buildings, (ql_cb)free_building);
    ql_free(r->buildings);
    r->buildings = 0;
    free(r);
}
Example #15
0
static void test_insert(CuTest * tc)
{
    struct quicklist *ql = NULL;
    int i;
    for (i = 0; i != 32; ++i) {
        CuAssertIntEquals(tc, i, ql_length(ql));
        ql_insert(&ql, 0, (void *)(data + 31 - i));
    }
    for (i = 0; i != 32; ++i) {
        CuAssertPtrEquals(tc, (void *)(data + i), ql_get(ql, i));
    }
    ql_free(ql);
}
Example #16
0
static void test_advance(CuTest * tc)
{
    struct quicklist *ql = NULL, *qli;
    int i, n = 31;
    for (i = 0; i != 32; ++i) {
        ql_insert(&ql, 0, (void *)(data + i));
    }
    for (i = 0, qli = ql; qli; ql_advance(&qli, &i, 1), n--) {
        void * g = ql_get(qli, i);
        CuAssertPtrEquals(tc, (void *)(data + n), g);
    }

    ql_free(ql);
}
Example #17
0
static void test_delete_rand(CuTest * tc)
{
    struct quicklist *ql = NULL;
    int i;
    for (i = 0; i != 32; ++i) {
        ql_push(&ql, (void *)(data + i));
    }
    CuAssertIntEquals(tc, 32, ql_length(ql));
    ql_delete(&ql, 0);
    CuAssertPtrEquals(tc, (void *)(data + 1), ql_get(ql, 0));
    CuAssertIntEquals(tc, 31, ql_length(ql));
    ql_delete(&ql, 30);
    CuAssertIntEquals(tc, 30, ql_length(ql));
    ql_free(ql);
}
Example #18
0
static void test_insert_many(CuTest * tc)
{
    struct quicklist *ql = NULL;
    int i;
    for (i = 0; i != 32; ++i) {
        ql_push(&ql, (void *)(data + i));
    }
    for (i = 0; i != 32; ++i) {
        CuAssertIntEquals(tc, 32 - i, ql_length(ql));
        CuAssertPtrEquals(tc, (void *)(data + i), ql_get(ql, 0));
        CuAssertPtrEquals(tc, (void *)(data + 31), ql_get(ql, ql_length(ql) - 1));
        ql_delete(&ql, 0);
    }
    CuAssertPtrEquals(tc, 0, ql);
    ql_free(ql);
}
Example #19
0
static void test_push_doesnt_invalidate_iterator(CuTest * tc)
{
    struct quicklist *list = NULL, *ql = NULL;
    int i, qi = 0;
    ql_push(&list, (void*)data);
    ql = list;
    for (i = 0; i != 42; ++i) {
        void * n;
        n = ql_get(ql, qi);
        CuAssertPtrEquals(tc, (void *)(data + i), n);
        ql_push(&list, (void *)(data + (i * 2 + 1)));
        ql_advance(&ql, &qi, 1);
        ql_push(&list, (void *)(data + (i * 2 + 2)));
    }
    ql_free(ql);
}
Example #20
0
int sp_healing(struct castorder * co)
{
    fighter * fi = co->magician.fig;
    int level = co->level;
    double power = co->force;
    battle *b = fi->side->battle;
    unit *mage = fi->unit;
    int j = 0;
    int healhp = (int)power * 200;
    quicklist *fgs;
    message *msg;
    bool use_item = has_ao_healing(mage);

    /* bis zu 11 Personen pro Stufe (einen HP m�ssen sie ja noch
     * haben, sonst w�ren sie tot) k�nnen geheilt werden */

    if (use_item) {
        healhp *= 2;
    }

    /* gehe alle denen wir helfen der reihe nach durch, heile verwundete,
     * bis zu verteilende HP aufgebraucht sind */

    fgs = fighters(b, fi->side, FIGHT_ROW, AVOID_ROW, FS_HELP);
    scramble_fighters(fgs);
    j += heal_fighters(fgs, &healhp, false);
    j += heal_fighters(fgs, &healhp, true);
    ql_free(fgs);

    if (j <= 0) {
        level = j;
    }
    if (use_item) {
        msg =
            msg_message("healing_effect_1", "mage amount item", mage, j,
            get_resourcetype(R_AMULET_OF_HEALING));
    }
    else {
        msg = msg_message("healing_effect_0", "mage amount", mage, j);
    }
    message_all(b, msg);
    msg_release(msg);

    return level;
}
Example #21
0
static void
get_island_info(region * root, int *size_p, int *inhabited_p, int *maxage_p)
{
    int qi, size = 0, maxage = 0, inhabited = 0;
    quicklist *ql, *island = NULL;

    ql_push(&island, root);
    fset(root, RF_MARK);

    for (ql = island, qi = 0; ql; ql_advance(&ql, &qi, 1)) {
        int d;
        region *r = (region *)ql_get(ql, qi);
        if (r->units) {
            unit *u;
            for (u = r->units; u; u = u->next) {
                if (!fval(u->faction, FFL_NOIDLEOUT) && u->faction->age > maxage) {
                    maxage = u->faction->age;
                }
            }
            ++inhabited;
        }
        ++size;
        for (d = 0; d != MAXDIRECTIONS; ++d) {
            region *rn = rconnect(r, d);
            if (rn && !fval(rn, RF_MARK) && rn->land) {
                ql_push(&island, rn);
                fset(rn, RF_MARK);
            }
        }
    }
    for (ql = island, qi = 0; ql; ql_advance(&ql, &qi, 1)) {
        region *r = (region *)ql_get(ql, qi);
        freset(r, RF_MARK);
    }
    ql_free(island);
    if (size_p)
        *size_p = size;
    if (inhabited_p)
        *inhabited_p = inhabited;
    if (maxage_p)
        *maxage_p = maxage;
}
Example #22
0
void wormholes_update(void)
{
    const building_type *bt_wormhole = bt_find("wormhole");
    quicklist *rlist = 0;
    int count = 0;
    region **match;

    if (bt_wormhole == NULL) {
        return;
    }

    select_wormhole_regions(&rlist, &count);
    if (count < 2) {
        return;
    }
    match = (region **)malloc(sizeof(region *) * count);
    sort_wormhole_regions(rlist, match, count);
    ql_free(rlist);
    make_wormholes(match, count, bt_wormhole);
    free(match);
}
Example #23
0
static void test_find(CuTest *tc) {
    struct quicklist *ql = 0;
    struct quicklist *il;
    int i;

    ql_push(&ql, (void *)data);
    ql_push(&ql, (void *)(data + 1));
    ql_push(&ql, (void *)data);

    il = ql; i = 0;
    CuAssertIntEquals(tc, ql_true, ql_find(&il, &i, (void *)data, 0));
    CuAssertIntEquals(tc, 0, i);

    ql_advance(&il, &i, 1);
    CuAssertIntEquals(tc, ql_true, ql_find(&il, &i, (void *)data, 0));
    CuAssertIntEquals(tc, 2, i);

    ql_advance(&il, &i, 1);
    CuAssertIntEquals(tc, ql_false, ql_find(&il, &i, (void *)data, 0));
    ql_free(ql);
}
Example #24
0
static void test_insert_atend(CuTest * tc)
{
    struct quicklist *ql = NULL;
    ql_iter qi;
    int i;
    for (i = 0; i != QL_MAXSIZE; ++i) {
        ql_insert(&ql, i, (void *)(data + i));
    }
    CuAssertIntEquals(tc, QL_MAXSIZE, ql_length(ql));
    qi = qli_init(&ql);
    for (i = 0; qli_more(qi); ++i) {
        void *ptr = qli_next(&qi);
        CuAssertPtrEquals(tc, (void *)(data + i), ptr);
        if (i < QL_MAXSIZE - 1) {
            CuAssertPtrEquals(tc, ql, qi.l);
        }
        else {
            CuAssertPtrEquals(tc, 0, qi.l);
        }
    }
    ql_free(ql);
}
void age_borders(void)
{
    quicklist *deleted = NULL, *ql;
    int i;

    for (i = 0; i != BORDER_MAXHASH; ++i) {
        connection *bhash = borders[i];
        for (; bhash; bhash = bhash->nexthash) {
            connection *b = bhash;
            for (; b; b = b->next) {
                if (b->type->age) {
                    if (b->type->age(b) == AT_AGE_REMOVE) {
                        ql_push(&deleted, b);
                    }
                }
            }
        }
    }
    for (ql = deleted, i = 0; ql; ql_advance(&ql, &i, 1)) {
        connection *b = (connection *)ql_get(ql, i);
        erase_border(b);
    }
    ql_free(deleted);
}
Example #26
0
static void test_find_cb(CuTest *tc) {
    int a = 42;
    int b = 23;
    int c = 42;
    struct quicklist *ql = 0;
    struct quicklist *il;
    int i;

    ql_push(&ql, (void *)&a);
    ql_push(&ql, (void *)&b);
    ql_push(&ql, (void *)&c);

    il = ql; i = 0;
    CuAssertIntEquals(tc, ql_true, ql_find(&il, &i, (void *)&a, cb_match_int));
    CuAssertIntEquals(tc, 0, i);

    ql_advance(&il, &i, 1);
    CuAssertIntEquals(tc, ql_true, ql_find(&il, &i, (void *)&a, cb_match_int));
    CuAssertIntEquals(tc, 2, i);

    ql_advance(&il, &i, 1);
    CuAssertIntEquals(tc, ql_false, ql_find(&il, &i, (void *)&a, cb_match_int));
    ql_free(ql);
}
Example #27
0
void do_markets(void)
{
    quicklist *traders = 0;
    unit *markets[MAX_MARKETS];
    region *r;
    for (r = regions; r; r = r->next) {
        if (r->land) {
            faction *f = region_get_owner(r);
            const struct race *rc = f ? f->race : NULL;
            int p = rpeasants(r);
            int numlux = rc_luxury_trade(rc), numherbs = rc_herb_trade(rc);
            numlux = (p + numlux - MIN_PEASANTS) / numlux;
            numherbs = (p + numherbs - MIN_PEASANTS) / numherbs;
            if (numlux > 0 || numherbs > 0) {
                int d, nmarkets = 0;
                const item_type *lux = r_luxury(r);
                const item_type *herb = r->land->herbtype;

                nmarkets += get_markets(r, markets + nmarkets, MAX_MARKETS - nmarkets);
                for (d = 0; d != MAXDIRECTIONS; ++d) {
                    region *r2 = rconnect(r, d);
                    if (r2 && r2->buildings) {
                        nmarkets +=
                            get_markets(r2, markets + nmarkets, MAX_MARKETS - nmarkets);
                    }
                }
                if (nmarkets) {
                    while (lux && numlux--) {
                        int n = rng_int() % nmarkets;
                        unit *u = markets[n];
                        item *items;
                        attrib *a = a_find(u->attribs, &at_market);
                        if (a == NULL) {
                            a = a_add(&u->attribs, a_new(&at_market));
                            ql_push(&traders, u);
                        }
                        items = (item *)a->data.v;
                        i_change(&items, lux, 1);
                        a->data.v = items;
                        /* give 1 luxury */
                    }
                    while (herb && numherbs--) {
                        int n = rng_int() % nmarkets;
                        unit *u = markets[n];
                        item *items;
                        attrib *a = a_find(u->attribs, &at_market);
                        if (a == NULL) {
                            a = a_add(&u->attribs, a_new(&at_market));
                            ql_push(&traders, u);
                        }
                        items = (item *)a->data.v;
                        i_change(&items, herb, 1);
                        a->data.v = items;
                        /* give 1 herb */
                    }
                }
            }
        }
    }

    if (traders) {
        quicklist *qliter = traders;
        int qli = 0;
        for (qli = 0; qliter; ql_advance(&qliter, &qli, 1)) {
            unit *u = (unit *)ql_get(qliter, qli);
            attrib *a = a_find(u->attribs, &at_market);
            item *items = (item *)a->data.v;

            a->data.v = NULL;
            while (items) {
                item *itm = items;
                items = itm->next;

                if (itm->number) {
                    ADDMSG(&u->faction->msgs, msg_message("buyamount",
                        "unit amount resource", u, itm->number, itm->type->rtype));
                    itm->next = NULL;
                    i_add(&u->items, itm);
                }
                else {
                    i_free(itm);
                }
            }

            a_remove(&u->attribs, a);
        }
        ql_free(traders);
    }
}
Example #28
0
void free_terrains(void) {
    ql_foreach(terrains, (ql_cb)free_terrain);
    ql_free(terrains);
    terrains = 0;
}
Example #29
0
void free_regions(void) {
    ql_foreach(regions, (ql_cb)free_region);
    ql_free(regions);
    regions = 0;
}
Example #30
0
void free_buildingtypes(void) {
    ql_foreach(buildingtypes, free_buildingtype);
    ql_free(buildingtypes);
    buildingtypes = 0;
}