/************************************************************************** * Original Diku Mud copyright (C) 1990, 1991 by Sebastian Hammer, * * Michael Seifert, Hans Henrik St{rfeldt, Tom Madsen, and Katja Nyboe. * * * * Merc Diku Mud improvements copyright (C) 1992, 1993 by Michael * * Chastain, Michael Quan, and Mitchell Tse. * * * * In order to use any part of this Merc Diku Mud, you must comply with * * both the original Diku license in 'license.doc' as well the Merc * * license in 'license.txt'. In particular, you may not remove either of * * these copyright notices. * * * * Much time and thought has gone into this software and you are * * benefiting. We hope that you share your changes too. What goes * * around, comes around. * *************************************************************************** * ROM 2.4 is copyright 1993-1998 Russ Taylor * * ROM has been brought to you by the ROM consortium * * Russ Taylor (rtaylor@hypercube.org) * * Gabrielle Taylor (gtaylor@hypercube.org) * * Brian Moore (zump@rom.org) * * By using this code, you have agreed to follow the terms of the * * ROM license, in the file Rom24/doc/rom.license * *************************************************************************** * 1stMud ROM Derivative (c) 2001-2004 by Markanth * * http://www.firstmud.com/ <markanth@firstmud.com> * * By using this code you have agreed to follow the term of * * the 1stMud license in ../doc/1stMud/LICENSE * ***************************************************************************/ #include "merc.h" #include "tables.h" #include "interp.h" Do_Fun (do_flag) { char arg1[MAX_INPUT_LENGTH], arg2[MAX_INPUT_LENGTH], arg3[MAX_INPUT_LENGTH]; char word[MAX_INPUT_LENGTH]; CharData *victim; ObjData *obj; flag_t *flag, old = 0, pnew = 0, marked = 0, pos; char type; FlagTable *flag_table; argument = one_argument (argument, arg1); argument = one_argument (argument, arg2); argument = one_argument (argument, arg3); type = argument[0]; if (type == '=' || type == '-' || type == '+') argument = one_argument (argument, word); if (NullStr (arg1)) { cmd_syntax (ch, NULL, n_fun, "mob <name> <field> <flags>", "char <name> <field> <flags>", "obj <name> <field> <flags>", NULL); chprintln (ch, " mob flags: act,aff,off,imm,res,vuln,form,part"); chprintln (ch, " char flags: plr,comm,aff,imm,res,vuln"); chprintln (ch, " obj flags: extra,wear"); chprintln (ch, " +: add flag, -: remove flag, = set equal to"); chprintln (ch, " otherwise flag toggles the flags listed."); return; } if (NullStr (arg2)) { chprintln (ch, "What do you wish to set flags on?"); return; } if (NullStr (arg3)) { chprintln (ch, "You need to specify a flag to set."); return; } if (NullStr (argument)) { chprintln (ch, "Which flags do you wish to change?"); return; } if (!str_prefix (arg1, "mob") || !str_prefix (arg1, "char")) { victim = get_char_world (ch, arg2); if (victim == NULL) { chprintln (ch, "You can't find them."); return; } if (!str_prefix (arg3, "act")) { if (!IsNPC (victim)) { chprintln (ch, "Use plr for PCs."); return; } flag = &victim->act; flag_table = act_flags; } else if (!str_prefix (arg3, "plr")) { if (IsNPC (victim)) { chprintln (ch, "Use act for NPCs."); return; } flag = &victim->act; flag_table = plr_flags; } else if (!str_prefix (arg3, "aff")) { flag = &victim->affected_by; flag_table = affect_flags; } else if (!str_prefix (arg3, "immunity")) { flag = &victim->imm_flags; flag_table = imm_flags; } else if (!str_prefix (arg3, "resist")) { flag = &victim->res_flags; flag_table = imm_flags; } else if (!str_prefix (arg3, "vuln")) { flag = &victim->vuln_flags; flag_table = imm_flags; } else if (!str_prefix (arg3, "form")) { if (!IsNPC (victim)) { chprintln (ch, "Form can't be set on PCs."); return; } flag = &victim->form; flag_table = form_flags; } else if (!str_prefix (arg3, "parts")) { if (!IsNPC (victim)) { chprintln (ch, "Parts can't be set on PCs."); return; } flag = &victim->parts; flag_table = part_flags; } else if (!str_prefix (arg3, "comm")) { if (IsNPC (victim)) { chprintln (ch, "Comm can't be set on NPCs."); return; } flag = &victim->comm; flag_table = comm_flags; } else { chprintln (ch, "That's not an acceptable flag."); return; } } else if (!str_prefix (arg1, "object")) { obj = get_obj_world (ch, arg2); if (obj == NULL) { chprintln (ch, "You can't find that object."); return; } if (!str_prefix (arg3, "extra")) { flag = &obj->extra_flags; flag_table = extra_flags; } else if (!str_prefix (arg3, "wear")) { flag = &obj->wear_flags; flag_table = wear_flags; } else { chprintln (ch, "That's not an acceptable flag."); return; } } else { do_flag (n_fun, ch, ""); return; } old = *flag; if (type != '=') pnew = old; for (;;) { argument = one_argument (argument, word); if (NullStr (word)) break; pos = flag_value (flag_table, word); if (pos == NO_FLAG) { chprintln (ch, "That flag doesn't exist!"); return; } else SetBit (marked, pos); } for (pos = 0; flag_table[pos].name != NULL; pos++) { if (!flag_table[pos].settable && IsSet (old, flag_table[pos].bit)) { SetBit (pnew, flag_table[pos].bit); continue; } if (IsSet (marked, flag_table[pos].bit)) { switch (type) { case '=': case '+': SetBit (pnew, flag_table[pos].bit); break; case '-': RemBit (pnew, flag_table[pos].bit); break; default: if (IsSet (pnew, flag_table[pos].bit)) RemBit (pnew, flag_table[pos].bit); else SetBit (pnew, flag_table[pos].bit); } } } *flag = pnew; return; } #define STNM(flag) #flag, flag const struct flag_stat_type flag_stat_table[] = { {STNM (area_flags), false}, {STNM (sex_flags), true}, {STNM (exit_flags), false}, {STNM (room_flags), false}, {STNM (sector_flags), true}, {STNM (type_flags), true}, {STNM (extra_flags), false}, {STNM (wear_flags), false}, {STNM (act_flags), false}, {STNM (plr_flags), false}, {STNM (comm_flags), false}, {STNM (affect_flags), false}, {STNM (apply_flags), true}, {STNM (wear_loc_flags), true}, {STNM (wear_loc_strings), true}, {STNM (container_flags), false}, {STNM (mprog_flags), false}, {STNM (rprog_flags), false}, {STNM (oprog_flags), false}, {STNM (info_flags), false}, {STNM (form_flags), false}, {STNM (part_flags), false}, {STNM (ac_type), true}, {STNM (size_flags), true}, {STNM (position_flags), true}, {STNM (off_flags), false}, {STNM (imm_flags), false}, {STNM (res_flags), false}, {STNM (vuln_flags), false}, {STNM (weapon_types), true}, {STNM (weapon_flags), false}, {STNM (apply_types), true}, {STNM (desc_flags), false}, {STNM (log_flags), true}, {STNM (target_flags), true}, {STNM (chan_types), true}, {STNM (mud_flags), false}, {STNM (autoset_types), true}, {STNM (board_flags), false}, {STNM (cmd_flags), false}, {STNM (stat_types), true}, {STNM (clan_flags), false}, {STNM (signal_flags), false}, {STNM (cmd_categories), true}, {STNM (msp_types), true}, {STNM (help_types), true}, {STNM (to_flags), false}, {STNM (color_attributes), true}, {STNM (color_foregrounds), true}, {STNM (color_backgrounds), true}, {STNM (vt100_flags), false}, #ifndef DISABLE_I3 {STNM (i3perm_names), true}, #endif {STNM (cmdline_flags), false}, {STNM (ethos_types), true}, {NULL, NULL, 0} }; int is_stat (FlagTable * flag_table) { int flag; for (flag = 0; flag_stat_table[flag].structure; flag++) if (flag_stat_table[flag].structure == flag_table) return flag_stat_table[flag].stat; logf ("flag_table[0] == '%s': not in flag_stat_table", flag_table[0].name); return -1; } flag_t flag_value (FlagTable * flag_table, const char *argument) { FlagTable *f; flag_t marked; bool found = false; if (is_stat (flag_table)) { if ((f = flag_lookup (argument, flag_table)) == NULL) return NO_FLAG; return f->bit; } marked = 0; for (;;) { char word[MAX_INPUT_LENGTH]; argument = one_argument (argument, word); if (NullStr (word)) break; if ((f = flag_lookup (word, flag_table)) != NULL) { SetBit (marked, f->bit); found = true; } } if (found) return marked; else return NO_FLAG; } const char * flag_string (FlagTable * flag_table, flag_t bits) { static char buf[3][MSL]; static int cnt = 0; int flag; int stat; cnt = (cnt + 1) % 3; buf[cnt][0] = '\0'; stat = is_stat (flag_table); for (flag = 0; flag_table[flag].name != NULL; flag++) { if (!stat) { if (IsSet (bits, flag_table[flag].bit)) { strcat (buf[cnt], " "); strcat (buf[cnt], flag_table[flag].name); } } else if (flag_table[flag].bit == bits) { strcat (buf[cnt], " "); strcat (buf[cnt], flag_table[flag].name); break; } } return (buf[cnt][0] != '\0') ? buf[cnt] + 1 : stat ? "unknown" : "none"; } char * flagtable_names (FlagTable * flag_table) { static int i; static char buf[5][512]; int flag; ++i, i %= 5; buf[i][0] = '\0'; for (flag = 0; flag_table[flag].name != NULL; flag++) { strcat (buf[i], " "); strcat (buf[i], flag_table[flag].name); } return buf[i] + 1; }