recipe.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 <assert.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>
#include <memory>
 
#include "object.h"
#include "assets.h"
#include "AssetsManager.h"
 
static void build_stringlist(const char *str, char ***result_list, size_t *result_size);
 
static recipelist *formulalist;
 
static recipelist *init_recipelist(void) {
    recipelist *tl = (recipelist *)malloc(sizeof(recipelist));
    if (tl == NULL)
        fatal(OUT_OF_MEMORY);
    tl->total_chance = 0;
    tl->number = 0;
    tl->items = NULL;
    tl->next = NULL;
    return tl;
}
 
static recipe *get_empty_formula(void) {
    // This used to be a malloc followed by setting everything to zero.
    // So just use calloc to make it faster.
    // SilverNexus -- 2018-10-22
    recipe *t = (recipe *)calloc(1, sizeof(recipe));
    if (t == NULL)
        fatal(OUT_OF_MEMORY);
    return t;
}
 
recipelist *get_formulalist(int i) {
    recipelist *fl = formulalist;
    int number = i;
 
    while (fl && number > 1) {
        if (!(fl = fl->next))
            break;
        number--;
    }
    return fl;
}
 
static int check_recipe(const recipe *rp) {
    size_t i;
    int result;
 
    result = 1;
    for (i = 0; i < rp->arch_names; i++) {
        if (try_find_archetype(rp->arch_name[i]) != NULL) {
            if (strcmp(rp->title, "NONE")) {
                const artifact *art = locate_recipe_artifact(rp, i);
 
                if (!art) {
                    LOG(llevError, "Formula %s of %s has no artifact.\n", rp->arch_name[i], rp->title);
                    result = 0;
                }
            }
        } else {
            LOG(llevError, "Can't find archetype %s for formula %s\n", rp->arch_name[i], rp->title);
            result = 0;
        }
    }
 
    return result;
}
 
bool check_recipes() {
    const recipelist *rl = formulalist;
    int abort = 0;
    while (rl) {
        const recipe *rp = rl->items;
        while (rp) {
            if (!check_recipe(rp)) {
                abort = 1;
            }
            rp = rp->next;
        }
        rl = rl->next;
    }
    return !abort;
}
 
void init_formulae(BufferReader *reader, const char *filename) {
    char *buf, *cp, *next;
    recipe *formula = NULL;
    recipelist *fl;
    linked_char *tmp;
    int value;
 
    if (!formulalist)
        formulalist = init_recipelist();
 
    while ((buf = bufferreader_next_line(reader)) != NULL) {
        if (*buf == '#' || *buf == '\0')
            continue;
        cp = buf;
        while (*cp == ' ') /* Skip blanks */
            cp++;
 
        if (!strncmp(cp, "Remove ", 7)) {
            if (strcmp(cp + 7, "*") == 0) {
                free_all_recipes();
                formulalist = init_recipelist();
            } else {
                LOG(llevError, "Recipes: only '*' is accepted for 'Remove' at %s:%zu\n", filename, bufferreader_current_line(reader));
            }
            continue;
        }
        if (!strncmp(cp, "Object", 6)) {
            formula = get_empty_formula();
            formula->title = add_string(strchr(cp, ' ')+1);
        } else if (formula == NULL) {
            LOG(llevError, "recipe.c: First key in formulae file %s is not \"Object\".\n", filename);
            fatal(SEE_LAST_ERROR);
        } else if (!strncmp(cp, "keycode", 7)) {
            formula->keycode = add_string(strchr(cp, ' ')+1);
        } else if (sscanf(cp, "trans %d", &value)) {
            formula->transmute = value;
        } else if (sscanf(cp, "yield %d", &value)) {
            formula->yield = value;
        } else if (sscanf(cp, "chance %d", &value)) {
            formula->chance = value;
        } else if (sscanf(cp, "exp %d", &value)) {
            formula->exp = value;
        } else if (sscanf(cp, "diff %d", &value)) {
            formula->diff = value;
        } else if (!strncmp(cp, "ingred", 6)) {
            int numb_ingred;
            formula->ingred_count = 1;
            cp = strchr(cp, ' ')+1;
            do {
                if ((next = strchr(cp, ',')) != NULL) {
                    *(next++) = '\0';
                    formula->ingred_count++;
                }
                tmp = (linked_char *)malloc(sizeof(linked_char));
                /* trim the string */
                while (*cp == ' ')
                  cp++;
                while (*cp != '\0' && cp[strlen(cp) - 1] == ' ')
                  cp[strlen(cp) - 1] = '\0';
                tmp->name = add_string(cp);
                tmp->next = formula->ingred;
                formula->ingred = tmp;
                /* each ingredient's ASCII value is coadded. Later on this
                 * value will be used allow us to search the formula lists
                 * quickly for the right recipe.
                 */
                formula->index += strtoint(cp);
            } while ((cp = next) != NULL);
            /* now find the correct (# of ingred ordered) formulalist */
            numb_ingred = formula->ingred_count;
            fl = formulalist;
            while (numb_ingred != 1) {
                if (!fl->next)
                    fl->next = init_recipelist();
                fl = fl->next;
                numb_ingred--;
            }
            formula->next = fl->items;
            fl->items = formula;
        } else if (!strncmp(cp, "arch", 4)) {
            build_stringlist(strchr(cp, ' ')+1, &formula->arch_name, &formula->arch_names);
        } else if (!strncmp(cp, "skill", 5)) {
            formula->skill = add_string(strchr(cp, ' ')+1);
        } else if (!strncmp(cp, "cauldron", 8)) {
            formula->cauldron = add_string(strchr(cp, ' ')+1);
        } else if (!strncmp(cp, "failure_arch ", 13)) {
            formula->failure_arch = add_string(strchr(cp, ' ')+1);
        } else if (!strncmp(cp, "failure_message ", 16)) {
            formula->failure_message = add_string(strchr(cp, ' ')+1);
        } else if (sscanf(cp, "min_level %d", &value)) {
            formula->min_level = value;
        } else if (!strncmp(cp, "tool ", 5)) {
            build_stringlist(strchr(cp, ' ')+1, &formula->tool, &formula->tool_size);
        } else if (sscanf(cp, "combination %d", &value)) {
            formula->is_combination = value ? 1 : 0;
        } else
            LOG(llevError, "Unknown input in file %s: %s\n", filename, buf);
    }
    /* Set the total chance and count for each formula list.
     * This needs to be done at the end to avoid dependancies on the field order in the file
     */
    for (fl = formulalist; fl; fl = fl->next) {
        fl->total_chance = 0;
        fl->number = 0;
        for (formula = fl->items; formula; formula = formula->next) {
            fl->total_chance += formula->chance;
            fl->number++;
        }
    }
    LOG(llevDebug, "done.\n");
}
 
bool check_formulae(void) {
    recipelist *fl;
    recipe *check, *formula;
    int numb = 1, tool_match;
    size_t tool_i,tool_j;
    bool success = true;
 
    LOG(llevDebug, "Checking formulae lists...\n");
 
    for (fl = formulalist; fl != NULL; fl = fl->next) {
        for (formula = fl->items; formula != NULL; formula = formula->next) {
            for (check = formula->next; check != NULL; check = check->next)
                /* If one recipe has a tool and another a caudron, we should be able to handle it */
                if (check->index == formula->index && check->cauldron == formula->cauldron && (check->tool_size == formula->tool_size)) {
                    /* Check the tool list to make sure they have no matches */
                    if (check->tool_size > 0 && check->tool && formula->tool)
                    {
                        tool_match = 0;
                        for (tool_i = 0; tool_i < formula->tool_size; ++tool_i)
                            /* If it turns out these lists are sorted, then we could optimize this better. */
                            for (tool_j = 0; tool_j < check->tool_size; ++tool_j)
                                if (strcmp(formula->tool[tool_i], check->tool[tool_j]) == 0) {
                                    tool_match = 1;
                                    break; /* TODO: break out of the double loop */
                                }
                    }
                    else
                        tool_match = 1; /* If we get here, we matched on the cauldron */
                    /* Check to see if we have a denoted match */
                    if (tool_match) {
                        /* if the recipes don't have the same facility, then no issue anyway. */
                        LOG(llevError, " ERROR: On %d ingred list:\n", numb);
                        LOG(llevError, "Formulae [%s] of %s and [%s] of %s have matching index id (%d)\n",
                            formula->arch_name[0], formula->title, check->arch_name[0], check->title, formula->index);
                        success = false;
                    }
                }
            for (size_t idx = 0; idx < formula->arch_names; idx++) {
                if (try_find_archetype(formula->arch_name[idx]) == NULL) {
                    LOG(llevError, "Formulae %s of %s (%d ingredients) references non existent archetype %s\n",
                        formula->arch_name[0], formula->title, numb, formula->arch_name[idx]);
                    success = false;
                }
            }
        }
        numb++;
    }
 
    return success;
}
 
static long recipe_find_ingredient_cost(const char *name);
 
void dump_alchemy(void) {
    recipelist *fl = formulalist;
    recipe *formula = NULL;
    linked_char *next;
    int num_ingred = 1;
 
    fprintf(stdout, "name,index,num_ingreds,chance,skill,difficulty,exp,cauldron,yield,ingredients,ingred_price,result_price\n");
    while (fl) {
        for (formula = fl->items; formula != NULL; formula = formula->next) {
            const archetype *at = NULL;
            const artifact *art = NULL;
            char buf[MAX_BUF];
            size_t i;
 
            for (i = 0; i < formula->arch_names; i++) {
                const char *string = formula->arch_name[i];
 
                if ((at = try_find_archetype(string)) != NULL) {
                    art = locate_recipe_artifact(formula, i);
                    if (!art && strcmp(formula->title, "NONE"))
                        LOG(llevError, "Formula %s has no artifact\n", formula->title);
                    else {
                        if (strcmp(formula->title, "NONE"))
                            snprintf(buf, sizeof(buf), "%s of %s", string, formula->title);
                        else
                            strlcpy(buf, string, sizeof(buf));
                        fprintf(stdout, "%s,%d,%d,%d,%s,", buf, formula->index, num_ingred, formula->chance, formula->skill);
                        fprintf(stdout, "%d,%d,", formula->diff, formula->exp);
                        fprintf(stdout, "%s,%d,", formula->cauldron, formula->yield);
                        int ingred_cost = 0;
                        if (formula->ingred != NULL) {
                            int nval = 0, tval = 0;
                            fprintf(stdout, "\"");
                            for (next = formula->ingred; next != NULL; next = next->next) {
                                if (nval != 0)
                                    fprintf(stdout, ",");
                                fprintf(stdout, "%s(%d)", next->name, (nval = strtoint(next->name)));
                                ingred_cost += recipe_find_ingredient_cost(next->name);
                                tval += nval;
                            }
                            fprintf(stdout, "\",");
                            if (tval != formula->index)
                                fprintf(stdout, "WARNING:ingredient list and formula values not equal.\n");
                        }
                        fprintf(stdout, "%d,", ingred_cost);
                        int result_price = price_base(&at->clone);
                        if (art != NULL && art->item != NULL)
                            result_price *= art->item->value;
                        fprintf(stdout, "%d\n", result_price);
                    }
                } else
                    LOG(llevError, "Can't find archetype:%s for formula %s\n", string, formula->title);
            }
        }
        fl = fl->next;
        num_ingred++;
    }
}
 
archetype *find_treasure_by_name(const treasure *t, const char *name, int depth) {
    treasurelist *tl;
    archetype *at;
 
    if (depth > 10)
        return NULL;
 
    while (t != NULL) {
        if (t->name != NULL) {
            tl = find_treasurelist(t->name);
            at = find_treasure_by_name(tl->items, name, depth+1);
            if (at != NULL)
                return at;
        } else {
            if (!strcasecmp(t->item->clone.name, name))
                return t->item;
        }
        if (t->next_yes != NULL) {
            at = find_treasure_by_name(t->next_yes, name, depth);
            if (at != NULL)
                return at;
        }
        if (t->next_no != NULL) {
            at = find_treasure_by_name(t->next_no, name, depth);
            if (at != NULL)
                return at;
        }
        t = t->next;
    }
    return NULL;
}
 
static long recipe_find_ingredient_cost(const char *name) {
    long mult;
    const char *cp;
    char part1[100];
    char part2[100];
 
    /* same as atoi(), but skip number */
    mult = 0;
    while (isdigit(*name)) {
        mult = 10*mult+(*name-'0');
        name++;
    }
    if (mult > 0)
        name++;
    else
        mult = 1;
    /* first, try to match the name of an archetype */
 
    long value = 0;
    bool found = false;
    getManager()->archetypes()->each([&value, &found, &name, &part1] (const archetype *at) {
        if (found) {
            return;
        }
 
        if (at->clone.title != NULL) {
            /* inefficient, but who cares? */
            snprintf(part1, sizeof(part1), "%s %s", at->clone.name, at->clone.title);
            if (!strcasecmp(part1, name)) {
                value = price_base(&at->clone);
                found = true;
                return;
            }
        }
        if (!strcasecmp(at->clone.name, name)) {
            value = price_base(&at->clone);
            found = true;
            return;
        }
    });
    if (found) {
        return mult * value;
    }
 
    /* second, try to match an artifact ("arch of something") */
    cp = strstr(name, " of ");
    if (cp != NULL) {
        safe_strncpy(part1, name, sizeof(part1));
        part1[cp-name] = '\0';
        safe_strncpy(part2, cp + 4, sizeof(part2));
        getManager()->archetypes()->each([&value, &found, &part1, &part2] (const archetype *at) {
            if (found) {
                return;
            }
 
            if (!strcasecmp(at->clone.name, part1) && at->clone.title == NULL) {
                /* find the first artifact derived from that archetype (same type) */
                for (auto al = first_artifactlist; al != NULL; al = al->next) {
                    if (al->type == at->clone.type) {
                        for (const auto art : al->items) {
                            if (!strcasecmp(art->item->name, part2)) {
                                value = price_base(&at->clone) * art->item->value;
                                found = true;
                                return;
                            }
                        }
                    }
                }
            }
        });
    }
    if (found) {
        return mult * value;
    }
 
    /* third, try to match a body part ("arch's something") */
    cp = strstr(name, "'s ");
    if (cp != NULL) {
        safe_strncpy(part1, name, sizeof(part1));
        part1[cp-name] = '\0';
        safe_strncpy(part2, cp + 3, sizeof(part2));
        /* examine all archetypes matching the first part of the name */
        getManager()->archetypes()->each([&value, &found, &part1, &part2] (const archetype *at) {
            if (found) {
                return;
            }
            if (!strcasecmp(at->clone.name, part1) && at->clone.title == NULL) {
                if (at->clone.randomitems != NULL) {
                    auto at2 = find_treasure_by_name(at->clone.randomitems->items, part2, 0);
                    if (at2 != NULL) {
                        value = price_base(&at2->clone);
                        found = true;
                        return;
                    }
                }
            }
        });
    }
    if (found) {
        return mult * value;
    }
 
    /* failed to find any matching items -- formula should be checked */
    LOG(llevError, "Couldn't find cost for ingredient %s\n", name);
    return -1;
}
 
void dump_alchemy_costs(void) {
    recipelist *fl = formulalist;
    recipe *formula = NULL;
    linked_char *next;
    int num_ingred = 1;
    int num_errors = 0;
    long cost;
    long tcost;
 
    fprintf(logfile, "\n");
    while (fl) {
        fprintf(logfile, "\n Formulae with %d ingredient%s  %d Formulae with total_chance=%d\n", num_ingred, num_ingred > 1 ? "s." : ".", fl->number, fl->total_chance);
        for (formula = fl->items; formula != NULL; formula = formula->next) {
            const artifact *art = NULL;
            const archetype *at = NULL;
            char buf[MAX_BUF];
            size_t i;
 
            for (i = 0; i < formula->arch_names; i++) {
                const char *string = formula->arch_name[i];
 
                if ((at = try_find_archetype(string)) != NULL) {
                    art = locate_recipe_artifact(formula, i);
                    if (!art && strcmp(formula->title, "NONE"))
                        LOG(llevError, "Formula %s has no artifact\n", formula->title);
                    else {
                        if (!strcmp(formula->title, "NONE"))
                            strlcpy(buf, string, sizeof(buf));
                        else
                            snprintf(buf, sizeof(buf), "%s of %s", string, formula->title);
                        fprintf(logfile, "\n%-40s bookchance %3d  skill %s\n", buf, formula->chance, formula->skill);
                        if (formula->ingred != NULL) {
                            tcost = 0;
                            for (next = formula->ingred; next != NULL; next = next->next) {
                                cost = recipe_find_ingredient_cost(next->name);
                                if (cost < 0)
                                    num_errors++;
                                fprintf(logfile, "\t%-33s%5ld\n", next->name, cost);
                                if (cost < 0 || tcost < 0)
                                    tcost = -1;
                                else
                                    tcost += cost;
                            }
                            if (art != NULL && art->item != NULL)
                                cost = price_base(&at->clone)*art->item->value;
                            else
                                cost = price_base(&at->clone);
                            fprintf(logfile, "\t\tBuying result costs: %5ld", cost);
                            if (formula->yield > 1) {
                                fprintf(logfile, " to %ld (max %d items)\n", cost*formula->yield, formula->yield);
                                cost = cost*(formula->yield+1L)/2L;
                            } else
                                fprintf(logfile, "\n");
                            fprintf(logfile, "\t\tIngredients cost:    %5ld\n\t\tComment: ", tcost);
                            if (tcost < 0)
                                fprintf(logfile, "Could not find some ingredients.  Check the formula!\n");
                            else if (tcost > cost)
                                fprintf(logfile, "Ingredients are much too expensive.  Useless formula.\n");
                            else if (tcost*2L > cost)
                                fprintf(logfile, "Ingredients are too expensive.\n");
                            else if (tcost*10L < cost)
                                fprintf(logfile, "Ingredients are too cheap.\n");
                            else
                                fprintf(logfile, "OK.\n");
                        }
                    }
                } else
                    LOG(llevError, "Can't find archetype:%s for formula %s\n", string, formula->title);
            }
        }
        fprintf(logfile, "\n");
        fl = fl->next;
        num_ingred++;
    }
    if (num_errors > 0)
        fprintf(logfile, "WARNING: %d objects required by the formulae do not exist in the game.\n", num_errors);
}
 
static const char *ingred_name(const char *name) {
    const char *cp = name;
 
    if (atoi(cp))
        cp = strchr(cp, ' ')+1;
    return cp;
}
 
static int numb_ingred(const char *buf) {
    int numb;
 
    if ((numb = atoi(buf)))
        return numb;
    else
        return 1;
}
 
int strtoint(const char *buf) {
    const char *cp = ingred_name(buf);
    int val = 0, len = strlen(cp), mult = numb_ingred(buf);
 
    while (len) {
        val += tolower(*cp);
        cp++; len--;
    }
    return val*mult;
}
 
const artifact *locate_recipe_artifact(const recipe *rp, size_t idx) {
    std::unique_ptr<object, void(*)(object *)> item(create_archetype(rp->arch_name[idx]), object_free_drop_inventory);
    const artifactlist *at = NULL;
 
    if (!item)
        return (artifact *)NULL;
 
    if ((at = find_artifactlist(item->type)))
        for (auto art : at->items)
            if (!strcmp(art->item->name, rp->title) && legal_artifact_combination(item.get(), art))
                return art;
 
    return nullptr;
}
 
static recipelist *get_random_recipelist(void) {
    recipelist *fl = NULL;
    int number = 0, roll = 0;
 
    /* first, determine # of recipelist we have */
    for (fl = get_formulalist(1); fl; fl = fl->next)
        number++;
 
    /* now, randomly choose one */
    if (number > 0)
        roll = RANDOM()%number;
 
    fl = get_formulalist(1);
    while (roll && fl) {
        if (fl->next)
            fl = fl->next;
        else
            break;
        roll--;
    }
    if (!fl) /* failed! */
        LOG(llevError, "get_random_recipelist(): no recipelists found!\n");
    else if (fl->total_chance == 0)
        fl = get_random_recipelist();
 
    return fl;
}
 
recipe *get_random_recipe(recipelist *rpl) {
    recipelist *fl = rpl;
    recipe *rp = NULL;
    int r = 0;
 
    /* looks like we have to choose a random one */
    if (fl == NULL)
        if ((fl = get_random_recipelist()) == NULL)
            return rp;
 
    if (fl->total_chance > 0) {
        r = RANDOM()%fl->total_chance;
        for (rp = fl->items; rp; rp = rp->next) {
            r -= rp->chance;
            if (r < 0)
                break;
        }
    }
    return rp;
}
 
void free_all_recipes(void) {
    recipelist *fl, *flnext;
    recipe *formula = NULL, *next;
    linked_char *lchar, *charnext;
 
    LOG(llevDebug, "Freeing all the recipes\n");
    for (fl = formulalist; fl != NULL; fl = flnext) {
        flnext = fl->next;
 
        for (formula = fl->items; formula != NULL; formula = next) {
            next = formula->next;
 
            free(formula->arch_name[0]);
            free(formula->arch_name);
            if (formula->title)
                free_string(formula->title);
            if (formula->skill)
                free_string(formula->skill);
            if (formula->cauldron)
                free_string(formula->cauldron);
            if (formula->failure_arch)
                free_string(formula->failure_arch);
            if (formula->failure_message)
                free_string(formula->failure_message);
            for (lchar = formula->ingred; lchar; lchar = charnext) {
                charnext = lchar->next;
                free_string(lchar->name);
                free(lchar);
            }
            if (formula->tool)
                free(formula->tool[0]);
            free(formula->tool);
            free(formula);
        }
        free(fl);
    }
    formulalist = NULL;
}
 
static void build_stringlist(const char *str, char ***result_list, size_t *result_size) {
    char *dup;
    char *p;
    size_t size;
    size_t i;
 
    dup = strdup_local(str);
    if (dup == NULL)
        fatal(OUT_OF_MEMORY);
 
    size = 0;
    for (p = strtok(dup, ","); p != NULL; p = strtok(NULL, ","))
        size++;
 
    assert(size > 0);
    *result_list = static_cast<char **>(malloc(sizeof(**result_list) * size));
    if (*result_list == NULL)
        fatal(OUT_OF_MEMORY);
    *result_size = size;
 
    for (i = 0; i < size; i++) {
        (*result_list)[i] = dup;
        dup = dup+strlen(dup)+1;
    }
}
 
recipe *find_recipe_for_tool(const char *tool, recipe *from) {
    size_t t;
    recipelist *list = from ? get_formulalist(from->ingred_count) : formulalist;
    recipe *test = from ? from->next : list->items;
 
    while (list) {
        while (test) {
            for (t = 0; t < test->tool_size; t++) {
                if (strcmp(test->tool[t], tool) == 0) {
                    return test;
                }
            }
            test = test->next;
        }
 
        list = list->next;
    }
 
    return NULL;
}
 
const Face *recipe_get_face(const recipe *rp) {
    const artifact *art;
    archetype *arch;
    object *item;
    const Face *face;
 
    if (rp->arch_names == 0)
        return NULL;
 
    arch = try_find_archetype(rp->arch_name[0]);
    if (arch == NULL) {
        return NULL;
    }
    if (strcmp(rp->title, "NONE") == 0) {
        return arch->clone.face;
    }
 
    art = locate_recipe_artifact(rp, 0);
    if (art == NULL)
        return arch->clone.face;
 
    face = arch->clone.face;
    item = arch_to_object(arch);
    give_artifact_abilities(item, art->item);
    object_give_identified_properties(item);
    if (item->face != NULL && item->face != blank_face)
        face = item->face;
    object_free(item, FREE_OBJ_FREE_INVENTORY | FREE_OBJ_NO_DESTROY_CALLBACK);
 
    return face;
}
 
const char *recipe_get_difficulty_string(int difficulty) {
    if (difficulty < 5)
        return "basic";
    if (difficulty < 10)
        return "simple";
    if (difficulty < 15)
        return "advanced";
    if (difficulty < 20)
        return "complicated";
    if (difficulty < 25)
        return "difficult";
    if (difficulty < 30)
        return "challenging";
    if (difficulty < 35)
        return "frustrating";
    return "vexatious";
}