citylife.cpp

Go to the documentation of this file.

/*
 * Crossfire -- cooperative multi-player graphical RPG and adventure game
 *
 * Copyright (c) 1999-2021 The Crossfire Development Team
 *
 * 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 <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <unordered_map>
#include <vector>
#include <string>
 
#include <assert.h>
#include "global.h"
#include "object.h"
#include "sproto.h"
 
#define CITYLIFE_NAME   "citylife"
 
#define FIRST_MOVE_KEY  "citylife_first_move"
 
struct spawn_point {
    int x;
    int y;
};
 
struct spawn_zone {
    int sx, sy, ex, ey;
};
 
struct mapzone {
    mapzone() : population(0) { };
 
    std::vector<spawn_point> points;                
    std::vector<spawn_zone> zones;                  
    int population;                                 
    std::vector<std::string> available_archetypes;  
};
 
static std::unordered_map<std::string, mapzone *> maps;
 
 
static const mapzone *get_zone_for_map(mapstruct *map) {
    auto find = maps.find(map->path);
    return find == maps.end() ? nullptr : find->second;
}
 
static object *get_npc(const mapzone *zone) {
    int idx = RANDOM()%zone->available_archetypes.size();
    archetype *arch = try_find_archetype(zone->available_archetypes[idx].c_str());
 
    if (!arch) {
        LOG(llevError, CITYLIFE_NAME ": get_npc() invalid archetype %s!\n", zone->available_archetypes[idx].c_str());
        return NULL;
    }
 
    object *npc = arch_to_object(arch);
    object *evt;
 
 
    SET_FLAG(npc, FLAG_RANDOM_MOVE);
    /* Prevent disease spreading in cities, mostly rabies. */
    SET_FLAG(npc, FLAG_UNDEAD);
    /* add a key so NPC will not disappear in the house it came from */
    object_set_value(npc, FIRST_MOVE_KEY, "1", 1);
 
    evt = create_archetype("event_time");
    evt->slaying = add_string(CITYLIFE_NAME);
    evt->title = add_string(CITYLIFE_NAME);
    object_insert_in_ob(evt, npc);
 
    evt = create_archetype("event_attack");
    evt->slaying = add_string(CITYLIFE_NAME);
    evt->title = add_string(CITYLIFE_NAME);
    SET_FLAG(evt, FLAG_UNIQUE);
    object_insert_in_ob(evt, npc);
 
    return npc;
}
 
static void add_npc_to_zone(const mapzone *zone, mapstruct *map) {
    int which;
    object *npc = get_npc(zone);
 
    if (!npc)
        return;
    which = RANDOM() % zone->zones.size();
    if (!object_teleport(npc, map, zone->zones[which].sx+RANDOM()%(zone->zones[which].ex-zone->zones[which].sx), zone->zones[which].sy+RANDOM()%(zone->zones[which].ey-zone->zones[which].sy))) {
        object_free_drop_inventory(npc);
    }
}
 
static void add_npc_to_point(const mapzone *zone, mapstruct *map) {
    int which;
    object *npc = get_npc(zone);
 
    which = RANDOM() % zone->points.size();
    if (!object_teleport(npc, map, zone->points[which].x, zone->points[which].y)) {
        object_free_drop_inventory(npc);
    }
}
 
static void add_npcs_to_map(mapstruct *map) {
    int add;
    const mapzone *zone = get_zone_for_map(map);
 
    if (!zone)
        return;
 
    add = 1+RANDOM()%zone->population;
    LOG(llevDebug, CITYLIFE_NAME ": adding %d NPC to map %s.\n", add, map->path);
 
    while (--add >= 0) {
        add_npc_to_zone(zone, map);
    }
}
 
static void add_npc_to_random_map(void) {
    int count;
    mapstruct *list[50];
    mapzone *zones[50];
    count = 0;
 
    for (auto map = maps.cbegin(); map != maps.cend() && count < 50; map++) {
        if ((list[count] = has_been_loaded(map->first.c_str())) && (list[count]->in_memory == MAP_IN_MEMORY)) {
            zones[count] = map->second;
            count++;
        }
    }
    if (!count)
        return;
 
    int selected = RANDOM() % count;
    add_npc_to_point(zones[selected], list[selected]);
}
 
static int citylife_globalEventListener(int *type, ...) {
    va_list args;
    int rv = 0;
    mapstruct *map;
    int code;
 
    va_start(args, type);
    code = va_arg(args, int);
 
    switch (code) {
    case EVENT_MAPLOAD:
        map = va_arg(args, mapstruct *);
        add_npcs_to_map(map);
        break;
 
    case EVENT_CLOCK:
        if (RANDOM()%40 == 0)
            add_npc_to_random_map();
    }
    va_end(args);
 
    return rv;
}
 
static int eventListener(int *type, ...) {
    va_list args;
    object *ground, *who, *event;
    const char *value;
 
    va_start(args, type);
 
    who = va_arg(args, object *);
    va_arg(args, object *);
    va_arg(args, object *);
    va_arg(args, char *);
    va_arg(args, int);
    event = va_arg(args, object *);
    va_arg(args, talk_info *);
    va_end(args);
 
    assert(who);
    assert(event);
 
    if (event->subtype == EVENT_ATTACKED) {
        LOG(llevInfo, "citylife: %s attacked, reverting to default behaviour\n", who->name);
        object *th = object_find_by_type_subtype(who, EVENT_CONNECTOR, EVENT_TIME);
        if (th) {   // Should not be NULL, but play it safe
            object_remove(th);
            object_free(th, 0);
        }   // Attacked hook is unique thus removed by the event handler
        CLEAR_FLAG(who, FLAG_RANDOM_MOVE);
        CLEAR_FLAG(who, FLAG_STAND_STILL);
        return 0; // Let default behaviour apply, NPC becomes aggressive
    }
 
    value = object_get_value(who, FIRST_MOVE_KEY);
    if (!value) {
        LOG(llevInfo, "citylife: removing event from object %s which we didn't generate\n", who->name);
        object_remove(event);
        return 1;
    }
    // Set the flag regardless of whether we tried to move through an exit
    if (strcmp(value, "1") == 0) {
        object_set_value(who, FIRST_MOVE_KEY, "0", 1);
 
        /* must set inventory as no drop, else it'll just drop on the ground */
        for (object *inv = who->inv; inv; inv = inv->below)
            SET_FLAG(inv, FLAG_NO_DROP);
    }
    /* should our npc disappear? -- Only attempt this if not first move */
    else if (RANDOM()%100 < 30) {
        int16_t sx = who->x, sy = who->y;
        mapstruct *map = who->map;
        if (!(get_map_flags(who->map, &map, who->x, who->y, &sx, &sy) & P_OUT_OF_MAP)) {
            for (ground = GET_MAP_OB(map, sx, sy); ground; ground = ground->above) {
                if (ground->type == EXIT) {
                    object_remove(who);
                    object_free_drop_inventory(who);
                    return 1;
                }
            }
        }
    }
 
    /* We have to move manually, because during the night NPCs don't move. */
    move_ob(who, 1 + RANDOM() % 8, NULL);
 
    return 1;
}
 
static void check_zone(const mapzone *zone, const char *path) {
    if (zone->population == 0) {
        LOG(llevError, "zone for %s has population of 0!\n", path);
    }
    if (zone->available_archetypes.empty()) {
        LOG(llevError, "zone for %s has no archetype!\n", path);
    }
    if (zone->zones.empty()) {
        LOG(llevError, "zone for %s has no zone!\n", path);
    }
    if (zone->points.empty()) {
        LOG(llevError, "zone for %s has no spawn point!\n", path);
    }
}
 
static void load_citylife(BufferReader *reader, const char *filename) {
    char *line;
    mapzone *zone = nullptr;
    char *split[4];
    std::string path;
 
    while ((line = bufferreader_next_line(reader)) != NULL) {
        if (line[0] == '\0' || line[0] == '#') {
            continue;
        }
 
        char *space = strchr(line, ' ');
        if (!space) {
            LOG(llevError, "citylife: invalid line in file %s:%zu\n", filename, bufferreader_current_line(reader));
            continue;
        }
        *space = '\0';
        space++;
 
        if (strcmp(line, "map") == 0) {
            if (zone) {
                check_zone(zone, path.c_str());
            }
            path = space;
            auto existing = maps.find(path);
            if (existing == maps.end()) {
                zone = new mapzone();
                maps[path] = zone;
            } else {
                zone = existing->second;
            }
            continue;
        }
        if (!zone) {
            LOG(llevError, "citylife: error, missing 'map' in file %s:%zu\n", filename, bufferreader_current_line(reader));
            continue;
        }
        if (strcmp(line, "population") == 0) {
            zone->population = atoi(space);
            continue;
        }
        if (strcmp(line, "zone") == 0) {
            size_t found = split_string(space, split, 4, ' ');
            if (found != 4) {
                LOG(llevError, "citylife: 'zone' should have 4 values in file %s:%zu\n", filename, bufferreader_current_line(reader));
            } else {
                spawn_zone z;
                z.sx = atoi(split[0]);
                z.sy = atoi(split[1]);
                z.ex = atoi(split[2]);
                z.ey = atoi(split[3]);
                zone->zones.push_back(z);
            }
            continue;
        }
        if (strcmp(line, "point") == 0) {
            size_t found = split_string(space, split, 2, ' ');
            if (found != 2) {
                LOG(llevError, "citylife: 'point' should have 2 values in file %s:%zu\n", filename, bufferreader_current_line(reader));
            } else {
                spawn_point p;
                p.x = atoi(split[0]);
                p.y = atoi(split[1]);
                zone->points.push_back(p);
            }
            continue;
        }
        if (strcmp(line, "arch") == 0) {
            zone->available_archetypes.push_back(space);
            continue;
        }
        LOG(llevError, "citylife: unknown line %s in file %s:%zu\n", line, filename, bufferreader_current_line(reader));
    }
 
    if (zone) {
        check_zone(zone, path.c_str());
    }
}
 
static event_registration c, m;
 
void citylife_init(Settings *settings) {
    c = events_register_global_handler(EVENT_CLOCK, citylife_globalEventListener);
    m = events_register_global_handler(EVENT_MAPLOAD, citylife_globalEventListener);
    events_register_object_handler(CITYLIFE_NAME, eventListener);
 
    settings->add_hook(".citylife", load_citylife);
 
    /* Disable the plugin in case it's still there */
    settings->disabled_plugins.push_back(strdup("citylife"));
}
 
void citylife_close() {
    events_unregister_global_handler(EVENT_CLOCK, c);
    events_unregister_global_handler(EVENT_MAPLOAD, m);
    events_unregister_object_handler(CITYLIFE_NAME);
    for (auto map : maps) {
        delete map.second;
    }
    maps.clear();
}