/** Returns the string named `name`. This symbol must exist. */ public string getstr(string name) { Parser_Value v = getval(name); Misc.assert((v.spec.type & ~PARSE_T.OPT) == PARSE_T.STR); return((string)v.value); }
public char getchar(string name) { Parser_Value v = getval(name); Misc.assert((v.spec.type & ~PARSE_T.OPT) == PARSE_T.CHAR); return((char)v.value); }
public random_value getrand(string name) { Parser_Value v = getval(name); Misc.assert((v.spec.type & ~PARSE_T.OPT) == PARSE_T.RAND); return((random_value)v.value); }
//All below functions had flags and size. flags was a byte* and size was a size_t /** * Sets multiple bitflags in a bitfield. * * The flags specified in `...` are set in `flags`. The bitfield size is * supplied in `size`. true is returned when changes were made, false * otherwise. * * WARNING: FLAG_END must be the final argument in the `...` list. <- LIES */ public bool set(params int[] values) { bool delta = false; /* Process each flag in the va-args */ for (int i = 0; i < values.Length; i++) { int f = values[i]; int flag_offset = FLAG_OFFSET(f); byte flag_binary = FLAG_BINARY(f); Misc.assert(flag_offset < size); /* !flag_has() */ if ((data[flag_offset] & flag_binary) == 0) { delta = true; } /* flag_on() */ data[flag_offset] |= flag_binary; } return(delta); }
static Parser.Error parse_prefs_e(Parser p) { int tvi, a; prefs_data d = p.priv as prefs_data; Misc.assert(d != null); if (d.bypass) { return(Parser.Error.NONE); } tvi = TVal.find_idx(p.getsym("tval")); if (tvi < 0 || tvi >= Misc.tval_to_attr.Length) { return(Parser.Error.UNRECOGNISED_TVAL); } a = p.getint("attr"); if (a != 0) { Misc.tval_to_attr[tvi] = Utilities.num_to_attr(a); } return(Parser.Error.NONE); }
static Parser.Error parse_prefs_c(Parser p) { int mode; prefs_data d = p.priv as prefs_data; Misc.assert(d != null); if (d.bypass) { return(Parser.Error.NONE); } mode = p.getint("mode"); if (mode < 0 || mode >= (int)Keymap.Mode.MAX) { return(Parser.Error.OUT_OF_BOUNDS); } ui_event[] temp = UIEvent.keypress_from_text(p.getstr("key")); if (temp[0].type != ui_event_type.EVT_KBRD || temp.Length > 1) { return(Parser.Error.FIELD_TOO_LONG); } Keymap.add(mode, temp[0].key, d.keymap_buffer, d.user); return(Parser.Error.NONE); }
static Parser.Error parse_prefs_m(Parser p) { Message_Type type; string attr; prefs_data d = p.priv as prefs_data; Misc.assert(d != null); if (d.bypass) { return(Parser.Error.NONE); } type = (Message_Type)p.getint("type"); attr = p.getsym("attr"); ConsoleColor a = Utilities.color_text_to_attr(attr); if (a < 0) { return(Parser.Error.INVALID_COLOR); } Message.color_define(type, a); return(Parser.Error.NONE); }
public uint getuint(string name) { Parser_Value v = getval(name); Misc.assert((v.spec.type & ~PARSE_T.OPT) == PARSE_T.UINT); return((uint)v.value); }
/** * Remove a keymap. Return true if one was removed. */ public static bool remove(int keymap, keypress trigger) { Keymap k; Keymap prev = null; Misc.assert(keymap >= 0 && keymap < (int)Mode.MAX); for (k = keymaps[keymap]; k != null; k = k.next) { if (k.key.code == trigger.code && k.key.mods == trigger.mods) { if (prev != null) { prev.next = k.next; } else { keymaps[keymap] = k.next; } return(true); } prev = k; } return(false); }
/* Places a trap. All traps are untyped until discovered. */ public static void place_trap(Cave c, int y, int x) { Misc.assert(Cave.cave_in_bounds(c, y, x)); Misc.assert(Cave.cave_isempty(c, y, x)); /* Place an invisible trap */ Cave.cave_set_feat(c, y, x, Cave.FEAT_INVIS); }
static Error parse_specs(Parser_Hook h, string fmt) { Misc.assert(h != null); Misc.assert(fmt != null); string[] split = fmt.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); if (split.Length == 0) { return(Error.GENERIC); } h.dir = split[0]; int i = 1; while (i < split.Length) { /* Lack of a type is legal; that means we're at the end of the * line. */ string stype = split[i++]; /* Lack of a name, on the other hand... */ if (i >= split.Length) { clean_specs(h); return(Error.GENERIC); } string name = split[i++]; /* Grab a type, check to see if we have a mandatory type * following an optional type. */ PARSE_T type = parse_type(stype); if (type == PARSE_T.NONE) { clean_specs(h); return(Error.GENERIC); } if ((type & PARSE_T.OPT) == 0 && h.specs.Count > 0 && (h.specs.Last().type & PARSE_T.OPT) != 0) { clean_specs(h); return(Error.GENERIC); } if (h.specs.Count > 0 && ((h.specs.Last().type & ~PARSE_T.OPT) == PARSE_T.STR)) { clean_specs(h); return(Error.GENERIC); } /* Save this spec. */ Hook_Spec hs = new Hook_Spec(); hs.type = type; hs.name = name; h.specs.Add(hs); } return(Error.NONE); }
/** * Tests if all of the multiple bitflags are set in a bitfield. * * true is returned if all of the flags specified in `...` are set in `flags`, * false otherwise. The bitfield size is supplied in `size`. * * WARNING: FLAG_END must be the final argument in the `...` list. */ public bool test_all(params int[] values) { int flag_offset; int flag_binary; bool delta = true; /* Process each flag in the va-args */ for (int i = 0; i < values.Length; i++) { int f = values[i]; flag_offset = FLAG_OFFSET(f); flag_binary = FLAG_BINARY(f); Misc.assert(flag_offset < size); /* !flag_has() */ if ((data[flag_offset] & flag_binary) == 0) { delta = false; break; } } return(delta); //size_t flag_offset; //int flag_binary; //int f; //va_list args; //bool delta = true; //va_start(args, size); ///* Process each flag in the va-args */ //for (f = va_arg(args, int); f != FLAG_END; f = va_arg(args, int)) //{ // flag_offset = FLAG_OFFSET(f); // flag_binary = FLAG_BINARY(f); // assert(flag_offset < size); // /* !flag_has() */ // if (!(flags[flag_offset] & flag_binary)) // { // delta = false; // break; // } //} //va_end(args); //return delta; }
/** * Tests if a flag is "on" in a bitflag set. * * true is returned when `flag` is on in `flags`, and false otherwise. * The flagset size is supplied in `size`. */ public bool has(int flag) { int flag_offset = FLAG_OFFSET(flag); byte flag_binary = FLAG_BINARY(flag); //if (flag == FLAG_END) return false; Misc.assert(flag_offset < size); return((data[flag_offset] & flag_binary) != 0); }
private Parser_Value getval(string name) { foreach (Parser_Value v in values) { if (v.spec.name == name) { return(v); } } Misc.assert(false); return(null); }
public void set_arg_direction(int n, int dir) { int idx = cmd_idx(command); Misc.assert(n <= CMD_MAX_ARGS); Misc.assert((game_cmds[idx].arg_type[n] & cmd_arg_type.arg_DIRECTION) != 0); arg[n] = new cmd_arg(); arg[n].value = dir; arg_type[n] = cmd_arg_type.arg_DIRECTION; arg_present[n] = true; }
public void set_arg_choice(int n, string choice) { int idx = cmd_idx(command); Misc.assert(n <= CMD_MAX_ARGS); Misc.assert((game_cmds[idx].arg_type[n] & cmd_arg_type.arg_STRING) != 0); arg[n] = new cmd_arg(); arg[n].text = choice; arg_type[n] = cmd_arg_type.arg_STRING; arg_present[n] = true; }
public void set_arg_item(int n, int item) { int idx = cmd_idx(command); Misc.assert(n <= CMD_MAX_ARGS); Misc.assert((game_cmds[idx].arg_type[n] & cmd_arg_type.arg_ITEM) != 0); arg[n] = new cmd_arg(); arg[n].value = item; arg_type[n] = cmd_arg_type.arg_ITEM; arg_present[n] = true; }
public void set_arg_number(int n, int num) { int idx = cmd_idx(command); Misc.assert(n <= CMD_MAX_ARGS); Misc.assert((game_cmds[idx].arg_type[n] & cmd_arg_type.arg_NUMBER) != 0); arg[n] = new cmd_arg(); arg[n].value = num; arg_type[n] = cmd_arg_type.arg_NUMBER; arg_present[n] = true; }
public void set_arg_choice(int n, int choice) { int idx = cmd_idx(command); Misc.assert(n <= CMD_MAX_ARGS); Misc.assert((game_cmds[idx].arg_type[n] & cmd_arg_type.arg_CHOICE) != 0); arg[n] = new cmd_arg(); arg[n].value = choice; arg_type[n] = cmd_arg_type.arg_CHOICE; arg_present[n] = true; }
public void set_arg_point(int n, int x, int y) { int idx = cmd_idx(command); Misc.assert(n <= CMD_MAX_ARGS); Misc.assert((game_cmds[idx].arg_type[n] & cmd_arg_type.arg_POINT) != 0); arg[n] = new cmd_arg(); arg[n].point = new Loc(); arg[n].point.x = x; arg[n].point.y = y; arg_type[n] = cmd_arg_type.arg_POINT; arg_present[n] = true; }
public static void add_handler(Event_Type type, Handler fn, object user) { event_handler_entry e; Misc.assert(fn != null); /* Make a new entry */ e = new event_handler_entry(); e.fn = fn; e.user = user; /* Add it to the head of the appropriate list */ e.next = event_handlers[(int)type]; event_handlers[(int)type] = e; }
/** * Find a keymap, given a keypress. */ public static keypress[] find(int keymap, keypress kc) { Keymap k; Misc.assert(keymap >= 0 && keymap < (int)Keymap.Mode.MAX); for (k = keymaps[keymap]; k != null; k = k.next) { if (k.key.code == kc.code && k.key.mods == kc.mods) { return(k.actions); } } return(null); }
Region active; /* Subregion actually active for selection */ /** * Initialise a menu, using the skin and iter functions specified. */ public void Init(skin_id skin_id, menu_iter iter) { menu_skin skin = menu_find_skin(skin_id); Misc.assert(skin != null, "menu skin not found!"); Misc.assert(iter != null, "menu iter not found!"); /* Wipe the struct */ //memset(menu, 0, sizeof *menu); //meh /* Menu-specific initialisation */ row_funcs = iter; this.skin = skin; cursor = 0; }
/** * Load another file. */ static Parser.Error parse_prefs_load(Parser p) { prefs_data d = p.priv as prefs_data; string file; Misc.assert(d != null); if (d.bypass) { return(Parser.Error.NONE); } file = p.getstr("file"); process_pref_file(file, true, d.user); return(Parser.Error.NONE); }
/** * Clears one flag in a bitfield. * * The bitflag identified by `flag` is cleared in `flags`. The bitfield size * is supplied in `size`. true is returned when changes were made, false * otherwise. */ public bool off(int flag) { int flag_offset = FLAG_OFFSET(flag); int flag_binary = FLAG_BINARY(flag); Misc.assert(flag_offset < size); if ((data[flag_offset] & flag_binary) == 0) { return(false); } data[flag_offset] &= (byte)~flag_binary; return(true); }
/** * Add a keymap to the mappings table. */ public static void add(int keymap, keypress trigger, keypress[] actions, bool user) { Keymap k = new Keymap(); Misc.assert(keymap >= 0 && keymap < (int)Mode.MAX); remove(keymap, trigger); k.key = trigger; k.actions = make(actions); k.user = user; k.next = keymaps[keymap]; keymaps[keymap] = k; return; }
static Parser.Error parse_prefs_expr(Parser p) { prefs_data d = p.priv as prefs_data; string v; string str; string expr; char f = '\0'; //Nick: No default originally, I am just guessing here... Misc.assert(d != null); /* XXX this can be avoided with a rewrite of process_pref_file_expr */ str = expr = p.getstr("expr"); /* Parse the expr */ v = process_pref_file_expr(ref expr, ref f); /* Set flag */ d.bypass = (v == "0"); return(Parser.Error.NONE); }
static Parser.Error parse_prefs_a(Parser p) { string act; prefs_data d = p.priv as prefs_data; Misc.assert(d != null); if (d.bypass) { return(Parser.Error.NONE); } act = p.getstr("act"); ui_event[] evts = UIEvent.keypress_from_text(act); d.keymap_buffer = new keypress[evts.Count()]; for (int i = 0; i < evts.Count(); i++) { d.keymap_buffer[i] = evts[i].key; } return(Parser.Error.NONE); }
/** Registers a parser hook. * * Hooks have the following format: * <fmt> ::= <name> [<type> <name>]* [?<type> <name>]* * <type> ::= int | str | sym | rand | char * The first <name> is called the directive for this hook. Any other hooks with * the same directive are superseded by this hook. It is an error for a * mandatory field to follow an optional field. It is an error for any field to * follow a field of type `str`, since `str` fields are not delimited and will * consume the entire rest of the line. */ public Error Register(string fmt, ParseFunc pf) { //Misc.assert(p); //if p (self) was null, we wouldn't be here Misc.assert(fmt != null); Misc.assert(pf != null); Parser_Hook h = new Parser_Hook(); h.func = pf; /*h.next = p.hooks; * h.func = func;*/ Error r = parse_specs(h, fmt); if (r != Error.NONE) { return(r); } hooks.Add(h); //p.hooks = h; //mem_free(cfmt); return(Error.NONE); }
/* Compute the direction (in the angband 123456789 sense) from a point to a * point. We decide to use diagonals if dx and dy are within a factor of two of * each other; otherwise we choose a cardinal direction. */ public static Direction direction_to(Loc from, Loc to) { int adx = Math.Abs(to.x - from.x); int ady = Math.Abs(to.y - from.y); int dx = to.x - from.x; int dy = to.y - from.y; if (dx == 0 && dy == 0) { return(Direction.NONE); } if (dx >= 0 && dy >= 0) { if (adx < ady * 2 && ady < adx * 2) { return(Direction.NE); } else if (adx > ady) { return(Direction.E); } else { return(Direction.N); } } else if (dx > 0 && dy < 0) { if (adx < ady * 2 && ady < adx * 2) { return(Direction.SE); } else if (adx > ady) { return(Direction.E); } else { return(Direction.S); } } else if (dx < 0 && dy > 0) { if (adx < ady * 2 && ady < adx * 2) { return(Direction.NW); } else if (adx > ady) { return(Direction.W); } else { return(Direction.N); } } else if (dx <= 0 && dy <= 0) { if (adx < ady * 2 && ady < adx * 2) { return(Direction.SW); } else if (adx > ady) { return(Direction.W); } else { return(Direction.S); } } Misc.assert(false); return(Direction.UNKNOWN); }