init.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 <stdlib.h>
#include <string.h>
 
#include "object.h"
#include "output_file.h"
 
#include "assets.h"
#include "AssetsManager.h"
 
const char *const resist_save[NROFATTACKS] = {
    "physical ", "magic ", "fire ", "electricity ", "cold ", "confusion ", "acid ",
    "drain ", "weaponmagic ", "ghosthit ", "poison ", "slow ", "paralyze ",
    "turn_undead ", "fear ", "cancellation ", "deplete ", "death ", "chaos ",
    "counterspell ", "godpower ", "holyword ", "blind ", "internal ", "life_stealing ",
    "disease "
};
 
const char *const attacktype_desc[NROFATTACKS] = {
    "physical", "magic", "fire", "electricity", "cold", "confusion", "acid",
    "drain", "weapon magic", "ghost hit", "poison", "slow", "paralyze",
    "turn undead", "fear", "cancellation", "deplete", "death", "chaos",
    "counterspell", "god power", "holy word", "blind", "internal", "life stealing",
    "disease"
};
 
const char *const resist_plus[NROFATTACKS] = {
    "armour", "resist magic", "resist fire", "resist electricity", "resist cold",
    "resist confusion", "resist acid", "resist drain",
    "resist weaponmagic", "resist ghosthit", "resist poison", "resist slow",
    "resist paralyzation", "resist turn undead", "resist fear",
    "resist cancellation", "resist depletion", "resist death", "resist chaos",
    "resist counterspell", "resist god power", "resist holy word",
    "resist blindness", "resist internal", "resist life stealing",
    "resist diseases"
};
 
const char *const resist_color[NROFATTACKS] = {
  "#FF15CD", "#930C76", "red", "blue", "#2CFFFF", NULL, NULL, NULL, NULL, NULL, "green", NULL, NULL,
  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
};
 
const char *const change_resist_msg[NROFATTACKS] = {
    "physical", "magic", "fire", "electricity", "cold", "confusion", "acid",
    "draining", "weapon magic", "ghosts", "poison", "slow", "paralyze",
    "turn undead", "fear", "cancellation", "depletion", "death attacks", "chaos",
    "counterspell", "god power", "holy word", "blinding attacks", "internal",
    "life stealing", "disease"
};
 
attackmess_t attack_mess[NROFATTACKMESS][MAXATTACKMESS];
 
Chaos_Attacks ATTACKS[22] = {
    { AT_PHYSICAL, 0 },
    { AT_PHYSICAL, 0 },  /*face = explosion*/
    { AT_PHYSICAL, 0 },
    { AT_MAGIC, 1 },
    { AT_MAGIC, 1 },   /* face = last-burnout */
    { AT_MAGIC, 1 },
    { AT_FIRE, 2 },
    { AT_FIRE, 2 },    /* face = fire....  */
    { AT_FIRE, 2 },
    { AT_ELECTRICITY, 3 },
    { AT_ELECTRICITY, 3 },  /* ball_lightning */
    { AT_ELECTRICITY, 3 },
    { AT_COLD, 4 },
    { AT_COLD, 4 },    /* face=icestorm*/
    { AT_COLD, 4 },
    { AT_CONFUSION, 5 },
    { AT_POISON, 7 },
    { AT_POISON, 7 },  /* face = acid sphere.  generator */
    { AT_POISON, 7 },  /* poisoncloud face */
    { AT_SLOW, 8 },
    { AT_PARALYZE, 9 },
    { AT_FEAR, 10 }
};
 
player *first_player;                
mapstruct *first_map;                
std::vector<region *> all_regions;
artifactlist *first_artifactlist;    
long trying_emergency_save; 
long nroferrors;            
FILE *logfile;                    
int exiting;                      
long nrofartifacts;               
long nrofallowedstr;              
archetype *empty_archetype;       
char first_map_path[MAX_BUF];     
char first_map_ext_path[MAX_BUF]; 
long ob_count;
 
const char *undead_name; /* Used in hit_player() in main.c */
sstring blocks_prayer;   
std::vector<materialtype_t *> materials;
 
static void init_environ(void);
static void init_defaults(void);
static void init_dynamic(void);
static void init_clocks(void);
 
/*
 * Default values for settings.
 * Anything with non-zero defaults in include/global.h must be set here.
 */
struct Settings settings = {
    .logfilename = nullptr,
    .csport = CSPORT,
    .debug = llevInfo,
    .log_callback = nullptr,
    .dumpvalues = 0,
    .dumparg = nullptr,
    .confdir = CONFDIR,
    .datadir = DATADIR,
    .localdir = LOCALDIR,
    .playerdir = PLAYERDIR,
    .mapdir = MAPDIR,
    .regions = REGIONS,
    .uniquedir = UNIQUE_DIR,
    .templatedir = TEMPLATE_DIR,
    .tmpdir = TMPDIR,
    .stat_loss_on_death = STAT_LOSS_ON_DEATH,
    .pk_luck_penalty = PK_LUCK_PENALTY,
    .permanent_exp_ratio = PERMANENT_EXPERIENCE_RATIO,
    .death_penalty_ratio = DEATH_PENALTY_RATIO,
    .death_penalty_level = DEATH_PENALTY_LEVEL,
    .balanced_stat_loss = BALANCED_STAT_LOSS,
    .not_permadeth = NOT_PERMADETH,
    .simple_exp = SIMPLE_EXP,
    .reset_loc_time = RESET_LOCATION_TIME,
    .set_title = SET_TITLE,
    .resurrection = RESURRECTION,
    .search_items = SEARCH_ITEMS,
    .spell_encumbrance = SPELL_ENCUMBRANCE,
    .spell_failure_effects = SPELL_FAILURE_EFFECTS,
    .casting_time = CASTING_TIME,
    .real_wiz = REAL_WIZ,
    .recycle_tmp_maps = RECYCLE_TMP_MAPS,
    .always_show_hp = ALWAYS_SHOW_HP,
    .spellpoint_level_depend = SPELLPOINT_LEVEL_DEPEND,
    .set_friendly_fire = SET_FRIENDLY_FIRE,
    .who_format = { 0 },
    .who_wiz_format = { 0 },
    .motd = MOTD,
    .rules = "rules",
    .news = "news",
    .meta_on = false,
    .meta_server = { 0 },
    .meta_host = { 0 },
    .meta_port = 0,
    .meta_comment = { 0 },
    .worldmapstartx = 0,
    .worldmapstarty = 0,
    .worldmaptilesx = 0,
    .worldmaptilesy = 0,
    .worldmaptilesizex = 0,
    .worldmaptilesizey = 0,
    .fastclock = 0,
    .emergency_mapname = nullptr,
    .emergency_x = EMERGENCY_X,
    .emergency_y = EMERGENCY_Y,
    .max_level = 0,
    .item_power_factor = 1.0,
    /* Armor enchantment stuff */
    .armor_max_enchant = ARMOR_MAX_ENCHANT,
    .armor_weight_reduction = ARMOR_WEIGHT_REDUCTION,
    .armor_weight_linear = ARMOR_WEIGHT_LINEAR,
    .armor_speed_improvement = ARMOR_SPEED_IMPROVEMENT,
    .armor_speed_linear = ARMOR_SPEED_LINEAR,
    .no_player_stealing = 1,
    .create_home_portals = 0,
    .personalized_blessings = 1,
    .pk_max_experience = 5000000,
    .pk_max_experience_percent = 10,
    .allow_denied_spells_writing = 0,
    .allow_broken_converters = 0,
    .log_timestamp = 0,
    .log_timestamp_format = nullptr,
    .starting_stat_min = 3,
    .starting_stat_max = 18,
    .starting_stat_points = 85,
    .roll_stat_points = 115,
    .max_stat = 0,     /* max_stat - will be loaded from stats file */
    .special_break_map = 1,     /* 1 for historical reasons */
    .disabled_plugins = { },
    .ignore_plugin_compatibility = 0,
    .account_block_create = 0,
    .account_trusted_host = nullptr,
    .crypt_mode = 0,
    .min_name = 0,
    .collector_hooks = {},
    .ignore_assets_errors = 0,
    .assets_tracker = nullptr,
    .fatal_hook = nullptr,
    .stat_file = nullptr,
};
 
struct Statistics statistics;
 
const char *const spellpathnames[NRSPELLPATHS] = {
    "Protection",
    "Fire",
    "Frost",
    "Electricity",
    "Missiles",
    "Self",
    "Summoning",
    "Abjuration",
    "Restoration",
    "Detonation",
    "Mind",
    "Creation",
    "Teleportation",
    "Information",
    "Transmutation",
    "Transferrence",
    "Turning",
    "Wounding",
    "Death",
    "Light"
};
 
 
static void init_emergency_mappath(void) {
    char filename[MAX_BUF], tmpbuf[MAX_BUF];
    FILE *fp;
    int online = 0;
 
    settings.emergency_mapname = strdup_local(EMERGENCY_MAPPATH);
 
    /* If this file doesn't exist, not a big deal */
    snprintf(filename, sizeof(filename), "%s/%s/.emergency", settings.datadir, settings.mapdir);
    fp = fopen(filename, "r");
    if (fp != NULL) {
        while (fgets(tmpbuf, MAX_BUF-1, fp)) {
            if (tmpbuf[0] == '#')
                continue; /* ignore comments */
 
            if (online == 0) {
                tmpbuf[strlen(tmpbuf)-1] = 0; /* kill newline */
                free(settings.emergency_mapname);
                settings.emergency_mapname = strdup_local(tmpbuf);
            } else if (online == 1) {
                settings.emergency_x = atoi(tmpbuf);
            } else if (online == 2) {
                settings.emergency_y = atoi(tmpbuf);
            }
            online++;
            if (online > 2)
                break;
        }
        fclose(fp);
        if (online <= 2)
            LOG(llevError, "Online read partial data from %s\n", filename);
        LOG(llevDebug, "emergency map set to %s (%d, %d)\n",
                settings.emergency_mapname,
                settings.emergency_x, settings.emergency_y);
    }
}
 
void load_assets(void) {
    assets_collect(settings.datadir, ASSETS_ALL);
    assets_end_load();
}
 
void init_library(void) {
    init_environ();
    init_hash_table();
    init_globals();
    init_stats();       /* Needs to be fairly early, since the loader will check
                         * against the settings.max_stat value */
 
    for (int mess = 0; mess < MAXATTACKMESS; mess++) {
        for (int level = 0; level < MAXATTACKMESS; level++) {
            attack_mess[mess][level].level = -1;
            attack_mess[mess][level].buf1 = NULL;
            attack_mess[mess][level].buf2 = NULL;
            attack_mess[mess][level].buf3 = NULL;
        }
    }
 
    assets_init();
    i18n_init();
    init_objects();
    init_block();
 
    load_assets();
 
    init_clocks();
    init_emergency_mappath();
    init_experience();
 
    if (getManager()->dumpUndefined() > 0 && !settings.ignore_assets_errors) {
        LOG(llevError, "Assets errors, please fix and restart.\n");
        fatal(SEE_LAST_ERROR);
    }
 
    init_dynamic();
}
 
static void init_environ(void) {
    char *cp;
 
    cp = getenv("CROSSFIRE_LIBDIR");
    if (cp)
        settings.datadir = cp;
    cp = getenv("CROSSFIRE_LOCALDIR");
    if (cp)
        settings.localdir = cp;
    cp = getenv("CROSSFIRE_PLAYERDIR");
    if (cp)
        settings.playerdir = cp;
    cp = getenv("CROSSFIRE_MAPDIR");
    if (cp)
        settings.mapdir = cp;
    cp = getenv("CROSSFIRE_UNIQUEDIR");
    if (cp)
        settings.uniquedir = cp;
    cp = getenv("CROSSFIRE_TEMPLATEDIR");
    if (cp)
        settings.templatedir = cp;
    cp = getenv("CROSSFIRE_TMPDIR");
    if (cp)
        settings.tmpdir = cp;
}
 
void init_globals(void) {
    memset(&statistics, 0, sizeof(struct Statistics));
 
    /* Log to stderr by default. */
    logfile = stderr;
 
    /* Try to open the log file specified on the command-line. */
    if (settings.logfilename != NULL) {
        logfile = fopen(settings.logfilename, "a");
 
        /* If writable, set buffer mode to per-line. */
        if (logfile != NULL) {
            setvbuf(logfile, NULL, _IOLBF, 0);
        } else {
            logfile = stderr;
 
            LOG(llevError, "Could not open '%s' for logging.\n",
                    settings.logfilename);
        }
    }
 
    exiting = 0;
    first_player = NULL;
    first_map = NULL;
    first_artifactlist = NULL;
    *first_map_ext_path = 0;
    nrofartifacts = 0;
    nrofallowedstr = 0;
    undead_name = add_string("undead");
    blocks_prayer = add_string("blocks_prayer");
    trying_emergency_save = 0;
    init_defaults();
}
 
void free_globals(void) {
    int msg, attack;
 
    FREE_AND_CLEAR_STR(undead_name);
    FREE_AND_CLEAR_STR(blocks_prayer);
    for (msg = 0; msg < NROFATTACKMESS; msg++)
        for (attack = 0; attack < MAXATTACKMESS; attack++) {
            free(attack_mess[msg][attack].buf1);
            free(attack_mess[msg][attack].buf2);
            free(attack_mess[msg][attack].buf3);
        }
 
    free(settings.emergency_mapname);
 
    clear_friendly_list();
    free_experience();
 
    for (auto region : all_regions) {
        FREE_AND_CLEAR(region->name);
        FREE_AND_CLEAR(region->jailmap);
        FREE_AND_CLEAR(region->msg);
        FREE_AND_CLEAR(region->longname);
        FREE_AND_CLEAR(region);
    }
    all_regions.clear();
 
    assets_free();
}
 
static void init_defaults(void) {
    nroferrors = 0;
}
 
static void init_dynamic(void) {
    archetype *at = get_archetype_by_type_subtype(MAP, MAP_TYPE_LEGACY);
    if (!at) {
        LOG(llevError, "You need a archetype for a legacy map, with type %d and subtype %d\n", MAP, MAP_TYPE_LEGACY);
        fatal(SEE_LAST_ERROR);
    }
    if (EXIT_PATH(&at->clone)) {
        mapstruct *first;
 
        strlcpy(first_map_path, EXIT_PATH(&at->clone), sizeof(first_map_path));
        first = ready_map_name(first_map_path, 0);
        if (!first) {
            LOG(llevError, "Initial map %s can't be found! Please ensure maps are correctly installed.\n", first_map_path);
            LOG(llevError, "Unable to continue without initial map.\n");
            fatal(SEE_LAST_ERROR);
        }
        delete_map(first);
    } else {
        LOG(llevError, "Legacy map must have a 'slaying' field!\n");
        fatal(SEE_LAST_ERROR);
    }
 
    if (!get_archetype_by_type_subtype(MAP, MAP_TYPE_DEFAULT)) {
        LOG(llevError, "Can not find object of type MAP subtype MAP_TYPE_DEFAULT.\n");
        LOG(llevError, "Are the archetype files up to date? Can not continue.\n");
        fatal(SEE_LAST_ERROR);
    }
}
 
void write_todclock(void) {
    char filename[MAX_BUF];
    FILE *fp;
    OutputFile of;
 
    snprintf(filename, sizeof(filename), "%s/clockdata", settings.localdir);
    fp = of_open(&of, filename);
    if (fp == NULL)
        return;
    fprintf(fp, "%lu", todtick);
    of_close(&of);
}
 
static void init_clocks(void) {
    char filename[MAX_BUF];
    FILE *fp;
    static int has_been_done = 0;
 
    if (has_been_done)
        return;
    else
        has_been_done = 1;
 
    snprintf(filename, sizeof(filename), "%s/clockdata", settings.localdir);
    fp = fopen(filename, "r");
    if (fp == NULL) {
        LOG(llevError, "Can't open %s.\n", filename);
        todtick = 0;
        write_todclock();
        return;
    }
    /* Read TOD and default to 0 on failure. */
    if (fscanf(fp, "%lu", &todtick) == 1) {
        LOG(llevDebug, "clockdata: todtick is %lu\n", todtick);
        fclose(fp);
    } else {
        LOG(llevError, "Couldn't parse todtick, using default value 0\n");
        todtick = 0;
        fclose(fp);
        write_todclock();
    }
}
 
void init_attackmess(BufferReader *reader, const char *filename) {
    char *buf;
    char *cp, *p;
    int mess = -1, level;
    int mode = 0, total = 0;
 
    level = 0;
    while ((buf = bufferreader_next_line(reader)) != NULL) {
        if (*buf == '#' || *buf == '\0')
            continue;
        /*
         * Skip blanks -- strspn is slightly faster than a loop w/ optimization on
         * Also, note we go from the beginning of the line again, since cp was at the end.
         * While here, also skip tabs for more complete whitespace handling.
         *
         * SilverNexus 2018-01-21
         */
        cp = buf + strspn(buf, " \t");
 
        if (strncmp(cp, "TYPE:", 5) == 0) {
            p = strtok(buf, ":");
            p = strtok(NULL, ":");
            if (mode == 1) {
                attack_mess[mess][level].level = -1;
                free(attack_mess[mess][level].buf1);
                free(attack_mess[mess][level].buf2);
                free(attack_mess[mess][level].buf3);
                attack_mess[mess][level].buf1 = NULL;
                attack_mess[mess][level].buf2 = NULL;
                attack_mess[mess][level].buf3 = NULL;
            }
            level = 0;
            mess = atoi(p);
            mode = 1;
            continue;
        }
        if (mode == 1) {
            p = strtok(buf, "=");
            attack_mess[mess][level].level = atoi(buf);
            p = strtok(NULL, "=");
            free(attack_mess[mess][level].buf1);
            if (p != NULL)
                attack_mess[mess][level].buf1 = strdup_local(p);
            else
                attack_mess[mess][level].buf1 = strdup_local("");
            mode = 2;
            continue;
        } else if (mode == 2) {
            p = strtok(buf, "=");
            attack_mess[mess][level].level = atoi(buf);
            p = strtok(NULL, "=");
            free(attack_mess[mess][level].buf2);
            if (p != NULL)
                attack_mess[mess][level].buf2 = strdup_local(p);
            else
                attack_mess[mess][level].buf2 = strdup_local("");
            mode = 3;
            continue;
        } else if (mode == 3) {
            p = strtok(buf, "=");
            attack_mess[mess][level].level = atoi(buf);
            p = strtok(NULL, "=");
            free(attack_mess[mess][level].buf3);
            if (p != NULL)
                attack_mess[mess][level].buf3 = strdup_local(p);
            else
                attack_mess[mess][level].buf3 = strdup_local("");
            mode = 1;
            level++;
            total++;
            continue;
        }
    }
    LOG(llevDebug, "attackmsg %s: %d messages in %d categories\n", filename, total, mess+1);
}