arch.cpp

Go to the documentation of this file.

/*
 * Crossfire -- cooperative multi-player graphical RPG and adventure game
 *
 * Copyright (c) 1999-2014 Mark Wedel and the Crossfire Development Team
 * Copyright (c) 1992 Frank Tore Johansen
 *
 * Crossfire is free software and comes with ABSOLUTELY NO WARRANTY. You are
 * welcome to redistribute it under certain conditions. For details, please
 * see COPYING and LICENSE.
 *
 * The authors can be reached via e-mail at <crossfire@metalforge.org>.
 */
 
#include "global.h"
 
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
 
#include "loader.h"
 
#include <string>
#include <map>
#include "assets.h"
#include "AssetsManager.h"
 
archetype *find_archetype_by_object_name(const char *name) {
    return getManager()->archetypes()->findByObjectName(name);
}
 
archetype *find_archetype_by_object_type_name(int type, const char *name) {
    return getManager()->archetypes()->findByObjectTypeName(type, name);
}
 
archetype *get_archetype_by_skill_name(const char *skill, int type) {
    return getManager()->archetypes()->findBySkillNameAndType(skill, type);
}
 
archetype *get_archetype_by_type_subtype(int type, int subtype) {
    return getManager()->archetypes()->findByTypeSubtype(type, subtype);
}
 
object *create_archetype_by_object_name(const char *name) {
    archetype *at;
    char tmpname[MAX_BUF];
    size_t i;
 
    strncpy(tmpname, name, MAX_BUF-1);
    tmpname[MAX_BUF-1] = 0;
    for (i = strlen(tmpname); i > 0; i--) {
        tmpname[i] = 0;
        at = getManager()->archetypes()->findByObjectName(tmpname);
        if (at != NULL) {
            return arch_to_object(at);
        }
    }
    return create_singularity(name);
}
 
void dump_arch(archetype *at, StringBuffer *sb) {
    object_dump(&at->clone, sb);
}
 
void dump_all_archetypes(void) {
    getManager()->archetypes()->each([] (const auto arch) {
        StringBuffer *sb;
        char *diff;
 
        sb = stringbuffer_new();
        dump_arch(arch, sb);
        diff = stringbuffer_finish(sb);
        LOG(llevDebug, "%s\n", diff);
        free(diff);
    });
}
 
void free_arch(archetype *at) {
    if (at->name)
        free_string(at->name);
    if (at->clone.name)
        free_string(at->clone.name);
    if (at->clone.name_pl)
        free_string(at->clone.name_pl);
    if (at->clone.title)
        free_string(at->clone.title);
    if (at->clone.race)
        free_string(at->clone.race);
    if (at->clone.slaying)
        free_string(at->clone.slaying);
    if (at->clone.msg)
        free_string(at->clone.msg);
    object_free_key_values(&at->clone);
    free(at);
}
 
archetype *get_archetype_struct(void) {
    archetype *arch;
 
    arch = (archetype *)CALLOC(1, sizeof(archetype));
    if (arch == NULL)
        fatal(OUT_OF_MEMORY);
    arch->name = NULL;
    arch->clone.other_arch = NULL;
    arch->clone.name = NULL;
    arch->clone.name_pl = NULL;
    arch->clone.title = NULL;
    arch->clone.race = NULL;
    arch->clone.slaying = NULL;
    arch->clone.msg = NULL;
    object_clear(&arch->clone);  /* to initial state other also */
    CLEAR_FLAG((&arch->clone), FLAG_FREED); /* This shouldn't matter, since object_copy() */
    SET_FLAG((&arch->clone), FLAG_REMOVED); /* doesn't copy these flags... */
    arch->head = NULL;
    arch->more = NULL;
    arch->clone.arch = arch;
    return arch;
}
 
object *arch_to_object(archetype *at) {
    object *op;
 
    if (at == NULL) {
        LOG(llevError, "Couldn't find archetype.\n");
        return NULL;
    }
    op = object_new();
    object_copy_with_inv(&at->clone, op, true);
    op->arch = at;
    return op;
}
 
object *create_singularity(const char *name) {
    object *op;
    char buf[MAX_BUF];
 
    snprintf(buf, sizeof(buf), "%s (%s)", ARCH_SINGULARITY, name);
    op = object_new();
    op->arch = empty_archetype;
    op->name = add_string(buf);
    op->name_pl = add_string(buf);
    SET_FLAG(op, FLAG_NO_PICK);
    return op;
}
 
object *create_archetype(const char *name) {
    archetype *at;
 
    at = try_find_archetype(name);
    if (at == NULL)
        return create_singularity(name);
    return arch_to_object(at);
}
 
object *object_create_arch(archetype *at) {
    object *op, *prev = NULL, *head = NULL;
 
    while (at) {
        op = arch_to_object(at);
        op->x = at->clone.x;
        op->y = at->clone.y;
        if (head)
            op->head = head, prev->more = op;
        if (!head)
            head = op;
        prev = op;
        at = at->more;
    }
    return (head);
}
 
/*** end of arch.cpp ***/