Пример #1
0
const char *nhnet_root_plselection_prompt(char *buf, int buflen, int rolenum,
        int racenum, int gendnum, int alignnum)
{
    json_t *jmsg;
    char *str, *ret;

    if (!nhnet_active())
        return nh_root_plselection_prompt(buf, buflen, rolenum,
                                          racenum, gendnum, alignnum);

    if (!api_entry())
        return NULL;

    jmsg = json_pack("{si,si,si,si}", "role", rolenum, "race", racenum,
                     "gend", gendnum, "align", alignnum);
    jmsg = send_receive_msg("get_root_pl_prompt", jmsg);
    if (json_unpack(jmsg, "{ss!}", "prompt", &str) == -1) {
        print_error("Incorrect return object in nhnet_root_plselection_prompt");
        ret = NULL;
    } else {
        strncpy(buf, str, buflen-1);
        buf[buflen-1] = '\0';
        ret = buf;
    }
    json_decref(jmsg);

    api_exit();
    return ret;
}
Пример #2
0
void nhnet_describe_pos(int x, int y, struct nh_desc_buf *bufs)
{
    const char *bgdesc, *trapdesc, *objdesc, *mondesc, *invisdesc, *effectdesc;
    json_t *jmsg;

    if (!nhnet_active())
        return nh_describe_pos(x, y, bufs);

    if (!api_entry())
        return;

    jmsg = send_receive_msg("describe_pos", json_pack("{si,si}", "x", x, "y", y));
    json_unpack(jmsg, "{ss,ss,ss,ss,ss,ss,si!}",
                "bgdesc", &bgdesc,	"trapdesc", &trapdesc,
                "objdesc", &objdesc,	"mondesc", &mondesc,
                "invisdesc", &invisdesc,"effectdesc", &effectdesc,
                "objcount", &bufs->objcount);

    strncpy(bufs->bgdesc, bgdesc, BUFSZ-1);
    strncpy(bufs->trapdesc, trapdesc, BUFSZ-1);
    strncpy(bufs->objdesc, objdesc, BUFSZ-1);
    strncpy(bufs->mondesc, mondesc, BUFSZ-1);
    strncpy(bufs->invisdesc, invisdesc, BUFSZ-1);
    strncpy(bufs->effectdesc, effectdesc, BUFSZ-1);
    json_decref(jmsg);

    api_exit();
}
Пример #3
0
nh_bool nhnet_view_replay_step(struct nh_replay_info *info,
                               enum replay_control action, int count)
{
    int ret;
    json_t *jmsg;
    const char *nextcmd;

    if (!nhnet_active())
        return nh_view_replay_step(info, action, count);

    if (!api_entry())
        return FALSE;

    jmsg = send_receive_msg("view_step", json_pack("{si,si,s:{si,si,si,si}}",
                            "action", action, "count", count, "info", "actions", info->actions,
                            "max_actions", info->max_actions, "moves", info->moves,
                            "max_moves", info->max_moves));
    if (json_unpack(jmsg, "{si,s:{ss,si,si,si,si}}", "return", &ret, "info",
                    "nextcmd", &nextcmd, "actions", &info->actions, "max_actions",
                    &info->max_actions, "moves", &info->moves, "max_moves",
                    &info->max_moves) == -1) {
        print_error("Incorrect return object in nhnet_view_replay_step");
    } else
        strncpy(info->nextcmd, nextcmd, sizeof(info->nextcmd) - 1);

    api_exit();
    return ret;
}
Пример #4
0
nh_bool nhnet_exit_game(int exit_type)
{
    json_t *jmsg;
    int ret;

    if (!nhnet_active())
        return nh_exit_game(exit_type);

    xmalloc_cleanup();

    if (!api_entry())
        return 0;

    jmsg = json_pack("{si}", "exit_type", exit_type);
    jmsg = send_receive_msg("exit_game", jmsg);
    if (json_unpack(jmsg, "{si!}", "return", &ret) == -1) {
        print_error("Incorrect return object in nhnet_exit_game");
        ret = 0;
    }
    json_decref(jmsg);

    current_game = 0;

    api_exit();
    return ret;
}
Пример #5
0
nh_bool nhnet_view_replay_start(int fd, struct nh_window_procs *rwinprocs,
                                struct nh_replay_info *info)
{
    int ret;
    json_t *jmsg;
    const char *nextcmd;

    if (!nhnet_active())
        return nh_view_replay_start(fd, rwinprocs, info);

    if (!api_entry())
        return FALSE;

    alt_windowprocs = *rwinprocs;

    jmsg = send_receive_msg("view_start", json_pack("{si}", "gameid", fd));
    if (json_unpack(jmsg, "{si,s:{ss,si,si,si,si}}", "return", &ret, "info",
                    "nextcmd", &nextcmd, "actions", &info->actions, "max_actions",
                    &info->max_actions, "moves", &info->moves, "max_moves",
                    &info->max_moves) == -1) {
        print_error("Incorrect return object in nhnet_view_replay_step");
        ret = 0;
    } else
        strncpy(info->nextcmd, nextcmd, sizeof(info->nextcmd) - 1);

    api_exit();
    return ret;
}
Пример #6
0
nh_bool
nhnet_set_option(const char *name, union nh_optvalue value, nh_bool isstr)
{
    int ret, i;
    json_t *jmsg, *joval, *jobj;
    struct nh_option_desc *gameopts, *birthopts, *opt;
    struct nh_autopickup_rule *r;

    ret = nh_set_option(name, value, isstr);
    if (!nhnet_active())
        return ret;

    if (!api_entry())
        return FALSE;

    gameopts = nhnet_get_options(GAME_OPTIONS);
    birthopts = nhnet_get_options(CURRENT_BIRTH_OPTIONS);
    opt = NULL;
    for (i = 0; gameopts[i].name && !opt; i++)
        if (!strcmp(name, gameopts[i].name))
            opt = &gameopts[i];
    for (i = 0; birthopts[i].name && !opt; i++)
        if (!strcmp(name, birthopts[i].name))
            opt = &birthopts[i];

    if (opt) {
        if (isstr || opt->type == OPTTYPE_STRING)
            joval = json_string(value.s);
        else if (opt->type == OPTTYPE_INT || opt->type == OPTTYPE_ENUM ||
                 opt->type == OPTTYPE_BOOL) {
            joval = json_integer(value.i);
        } else if (opt->type == OPTTYPE_AUTOPICKUP_RULES) {
            joval = json_array();
            for (i = 0; value.ar && i < value.ar->num_rules; i++) {
                r = &value.ar->rules[i];
                jobj =
                    json_pack("{ss,si,si,si}", "pattern", r->pattern, "oclass",
                              r->oclass, "buc", r->buc, "action", r->action);
                json_array_append_new(joval, jobj);
            }
        }

        jmsg =
            json_pack("{ss,so,si}", "name", name, "value", joval, "isstr",
                      isstr);
        jmsg = send_receive_msg("set_option", jmsg);
        if (json_unpack(jmsg, "{si,so!}", "return", &ret, "option", &jobj) ==
            -1) {
            print_error("Bad response in nhnet_set_option");
        } else {
            free_option_data(opt);
            read_json_option(jobj, opt);
        }
        json_decref(jmsg);
    }
    api_exit();
    return ret;
}
Пример #7
0
struct nh_drawing_info *
nhnet_get_drawing_info(void)
{
    json_t *jmsg, *jbg, *jtraps, *jobjs, *jmons, *jwarn, *jexpt, *jzapt, *jzaps,
        *jeff, *jexps, *jswal, *jinvis;
    struct nh_drawing_info *di;

    if (!nhnet_active())
        return nh_get_drawing_info();

    if (!api_entry())
        return 0;

    jmsg = send_receive_msg("get_drawing_info", json_object());
    di = xmalloc(sizeof (struct nh_drawing_info));
    if (json_unpack
        (jmsg,
         "{si,si,si,si,si,si,si,si,si,so,so,so,so,so,so,so,so,so,so,so,so!}",
         "num_bgelements", &di->num_bgelements, "num_traps", &di->num_traps,
         "num_objects", &di->num_objects, "num_monsters", &di->num_monsters,
         "num_warnings", &di->num_warnings, "num_expltypes", &di->num_expltypes,
         "num_zaptypes", &di->num_zaptypes, "num_effects", &di->num_effects,
         "feature_offset", &di->bg_feature_offset, "bgelements", &jbg, "traps",
         &jtraps, "objects", &jobjs, "monsters", &jmons, "warnings", &jwarn,
         "expltypes", &jexpt, "zaptypes", &jzapt, "effects", &jeff, "explsyms",
         &jexps, "zapsyms", &jzaps, "swallowsyms", &jswal, "invis",
         &jinvis) == -1 || !json_is_array(jbg) || !json_is_array(jobjs) ||
        !json_is_array(jmons) || !json_is_array(jwarn) || !json_is_array(jexpt)
        || !json_is_array(jzapt) || !json_is_array(jeff) ||
        !json_is_array(jexps) || !json_is_array(jswal) ||
        !json_is_array(jinvis)) {
        print_error("Incorrect return object in nhnet_get_drawing_info");
        di = NULL;
    } else {
        di->bgelements = read_symdef_array(jbg);
        di->traps = read_symdef_array(jtraps);
        di->objects = read_symdef_array(jobjs);
        di->monsters = read_symdef_array(jmons);
        di->warnings = read_symdef_array(jwarn);
        di->expltypes = read_symdef_array(jexpt);
        di->zaptypes = read_symdef_array(jzapt);
        di->effects = read_symdef_array(jeff);
        di->explsyms = read_symdef_array(jexps);
        di->zapsyms = read_symdef_array(jzaps);
        di->swallowsyms = read_symdef_array(jswal);
        di->invis = read_symdef_array(jinvis);
    }
    json_decref(jmsg);

    api_exit();
    return di;
}
Пример #8
0
struct nh_roles_info *nhnet_get_roles(void)
{
    struct nh_roles_info *ri = NULL;
    json_t *jmsg, *jroles_m, *jroles_f, *jraces, *jgenders, *jaligns, *jmatrix;
    nh_bool *matrix;
    int i, size;

    if (!nhnet_active())
        return nh_get_roles();

    if (!api_entry())
        return NULL;

    jmsg = send_receive_msg("get_roles", json_object());
    ri = xmalloc(sizeof(struct nh_roles_info));
    if (json_unpack(jmsg, "{si,si,si,si,si,si,si,si,so,so,so,so,so,so}",
                    "num_roles", &ri->num_roles, "num_races", &ri->num_races,
                    "num_genders", &ri->num_genders, "num_aligns", &ri->num_aligns,
                    "def_role", &ri->def_role, "def_race", &ri->def_race,
                    "def_gend", &ri->def_gend, "def_align", &ri->def_align,
                    "rolenames_m", &jroles_m, "rolenames_f", &jroles_f,
                    "racenames", &jraces, "gendnames", &jgenders,
                    "alignnames", &jaligns, "matrix", &jmatrix) == -1 ||
            !json_is_array(jroles_m) || !json_is_array(jroles_f) ||
            !json_is_array(jraces)   || !json_is_array(jgenders) ||
            !json_is_array(jaligns)  || !json_is_array(jmatrix)  ||
            json_array_size(jroles_m) != ri->num_roles ||
            json_array_size(jroles_f) != ri->num_roles ||
            json_array_size(jraces)   != ri->num_races ||
            json_array_size(jgenders) != ri->num_genders ||
            json_array_size(jaligns)  != ri->num_aligns) {
        print_error("Incorrect return object in nhnet_get_roles");
        ri = NULL;
    } else {
        ri->rolenames_m = read_string_array(jroles_m);
        ri->rolenames_f = read_string_array(jroles_f);
        ri->racenames = read_string_array(jraces);
        ri->gendnames = read_string_array(jgenders);
        ri->alignnames = read_string_array(jaligns);

        size = json_array_size(jmatrix);
        matrix = xmalloc(size * sizeof(nh_bool));
        for (i = 0; i < size; i++)
            matrix[i] = json_integer_value(json_array_get(jmatrix, i));
        ri->matrix = matrix;
    }

    json_decref(jmsg);
    api_exit();
    return ri;
}
Пример #9
0
int
nhnet_command(const char *cmd, int rep, struct nh_cmd_arg *arg)
{
    int ret;
    json_t *jmsg, *jarg;

    if (!nhnet_active())
        return nh_command(cmd, rep, arg);

    if (!api_entry())
        return ERR_NETWORK_ERROR;

    xmalloc_cleanup();

    switch (arg->argtype) {
    case CMD_ARG_DIR:
        jarg = json_pack("{si,si}", "argtype", arg->argtype, "d", arg->d);
        break;

    case CMD_ARG_POS:
        jarg =
            json_pack("{si,si,si}", "argtype", arg->argtype, "x", arg->pos.x,
                      "y", arg->pos.y);
        break;

    case CMD_ARG_OBJ:
        jarg =
            json_pack("{si,si}", "argtype", arg->argtype, "invlet",
                      arg->invlet);
        break;

    case CMD_ARG_NONE:
    default:
        jarg = json_pack("{si}", "argtype", arg->argtype);
        break;
    }

    jmsg =
        json_pack("{ss,so,si}", "command", cmd ? cmd : "", "arg", jarg, "count",
                  rep);
    jmsg = send_receive_msg("game_command", jmsg);
    if (json_unpack(jmsg, "{si!}", "return", &ret) == -1) {
        print_error("Incorrect return object in nhnet_command");
        ret = 0;
    }

    json_decref(jmsg);
    api_exit();
    return ret;
}
Пример #10
0
void nhnet_view_replay_finish(void)
{
    if (!nhnet_active())
        return nh_view_replay_finish();

    xmalloc_cleanup();

    alt_windowprocs = windowprocs;

    if (!api_entry())
        return;

    send_receive_msg("view_finish", json_object());

    api_exit();
}
Пример #11
0
struct nh_cmd_desc *nhnet_get_object_commands(int *count, char invlet)
{
    int i, defkey, altkey;
    json_t *jmsg, *jarr, *jobj;
    struct nh_cmd_desc *cmdlist = NULL;
    const char *name, *desc;

    if (!nhnet_active())
        return nh_get_object_commands(count, invlet);

    if (!api_entry())
        return 0;

    jmsg = json_pack("{si}", "invlet", invlet);
    jmsg = send_receive_msg("get_obj_commands", jmsg);
    if (json_unpack(jmsg, "{so!}", "cmdlist", &jarr) == -1 ||
            !json_is_array(jarr)) {
        print_error("Incorrect return object in nhnet_get_object_commands");
    } else {
        *count = json_array_size(jarr);
        cmdlist = xmalloc(*count * sizeof(struct nh_cmd_desc));

        for (i = 0; i < *count; i++) {
            jobj = json_array_get(jarr, i);
            json_unpack(jobj, "{ss,ss,si,si,si!}",
                        "name", &name,
                        "desc", &desc,
                        "def", &defkey,
                        "alt", &altkey,
                        "flags", &cmdlist[i].flags);
            strcpy(cmdlist[i].name, name);
            strcpy(cmdlist[i].desc, desc);
            cmdlist[i].defkey = defkey;
            cmdlist[i].altkey = altkey;
        }
    }

    json_decref(jmsg);
    api_exit();
    return cmdlist;
}
Пример #12
0
struct nh_option_desc *
nhnet_get_options(enum nh_option_list list)
{
    struct nh_option_desc *olist;
    json_t *jmsg, *jarr, *jobj;
    int count, i;

    if (!nhnet_active())
        return nh_get_options(list);

    if (list >= 0 && list < OPTION_LIST_COUNT && option_lists[list])
        return option_lists[list];

    if (!api_entry()) {
        olist = xmalloc(sizeof (struct nh_option_desc));
        memset(olist, 0, sizeof (struct nh_option_desc));
        return olist;
    }

    jmsg = send_receive_msg("get_options", json_pack("{si}", "list", list));
    if (json_unpack(jmsg, "{so!}", "options", &jarr) == -1 ||
        !json_is_array(jarr)) {
        print_error("Incorrect return object in nhnet_get_options");
        olist = xmalloc(sizeof (struct nh_option_desc));
        memset(olist, 0, sizeof (struct nh_option_desc));
    } else {
        count = json_array_size(jarr);
        option_lists[list] = olist =
            malloc(sizeof (struct nh_option_desc) * (count + 1));
        memset(olist, 0, sizeof (struct nh_option_desc) * (count + 1));
        for (i = 0; i < count; i++) {
            jobj = json_array_get(jarr, i);
            read_json_option(jobj, &olist[i]);
        }
    }
    json_decref(jmsg);

    api_exit();
    return olist;
}
Пример #13
0
struct nh_topten_entry *nhnet_get_topten(int *out_len, char *statusbuf,
        const char *player, int top, int around, nh_bool own)
{
    struct nh_topten_entry *ttlist;
    json_t *jmsg, *jarr, *jobj;
    const char *msg, *plrole, *plrace, *plgend, *plalign, *name, *death, *entrytxt;
    int len, i, highlight;

    if (!nhnet_active())
        return nh_get_topten(out_len, statusbuf, player, top, around, own);

    *out_len = 0;
    if (!api_entry())
        return NULL;

    jmsg = json_pack("{ss,si,si,si}", "player", player ? player : "", "top", top,
                     "around", around, "own", own);
    jmsg = send_receive_msg("get_topten", jmsg);
    if (json_unpack(jmsg, "{so,ss!}", "toplist", &jarr, "msg", &msg) == -1 ||
            !json_is_array(jarr)) {
        print_error("Incorrect return object in nhnet_get_topten");
        ttlist = NULL;
    } else {
        len = json_array_size(jarr);
        strncpy(statusbuf, msg, BUFSZ-1);
        *out_len = len;
        ttlist = xmalloc((len+1) * sizeof(struct nh_topten_entry));
        memset(ttlist, 0, (len+1) * sizeof(struct nh_topten_entry));
        for (i = 0; i < len; i++) {
            jobj = json_array_get(jarr, i);
            json_unpack(jobj, "{si,si,si,si,si,si,si,si,si,si,si,si,si,ss,ss,ss,ss,ss,ss,ss,si!}",
                        "rank", &ttlist[i].rank,
                        "points", &ttlist[i].points,
                        "maxlvl", &ttlist[i].maxlvl,
                        "hp", &ttlist[i].hp,
                        "maxhp", &ttlist[i].maxhp,
                        "deaths", &ttlist[i].deaths,
                        "ver_major", &ttlist[i].ver_major,
                        "ver_minor", &ttlist[i].ver_minor,
                        "patchlevel", &ttlist[i].patchlevel,
                        "deathdate", &ttlist[i].deathdate,
                        "birthdate", &ttlist[i].birthdate,
                        "moves", &ttlist[i].moves,
                        "end_how", &ttlist[i].end_how,
                        "plrole", &plrole,
                        "plrace", &plrace,
                        "plgend", &plgend,
                        "plalign", &plalign,
                        "name", &name,
                        "death", &death,
                        "entrytxt", &entrytxt,
                        "highlight", &highlight);
            strncpy(ttlist[i].plrole, plrole, PLRBUFSZ - 1);
            strncpy(ttlist[i].plrace, plrace, PLRBUFSZ - 1);
            strncpy(ttlist[i].plgend, plgend, PLRBUFSZ - 1);
            strncpy(ttlist[i].plalign, plalign, PLRBUFSZ - 1);
            strncpy(ttlist[i].name, name, PL_NSIZ - 1);
            strncpy(ttlist[i].death, death, BUFSZ - 1);
            strncpy(ttlist[i].entrytxt, entrytxt, BUFSZ - 1);
            ttlist[i].highlight = highlight;
        }
    }
    json_decref(jmsg);

    api_exit();
    return ttlist;
}