protected override void OnInitialise() { List<byte[]> DestSource = Fetch(); // Carry out the subtraction and discard the results(That is how comparison works in assembly, it has the same flags as subtraction). Result = Bitwise.Subtract(DestSource[0], DestSource[1], out _); }
public Capabilities WithFlags(FlagSet flags) { var result = this.Copy(); result.Flags = flags; return(result); }
public TaskPathwayPickEdge(RandoLogic logic, LinkedNode node, FlagSet state, bool forceWarp) : base(logic) { // TODO: advance forward through any obligatory edges this.Node = node; this.State = state; this.ForceWarp = forceWarp; }
internal override void Apply(FlagSet set) { if (!string.IsNullOrEmpty(EnvironmentVariable)) { foreach (var variable in EnvironmentVariable.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries)) { var envVar = variable.Trim(); var envVal = Environment.GetEnvironmentVariable(envVar); if (string.IsNullOrEmpty(envVal)) { continue; } Value = decimal.Parse(envVal); break; } } if (Value == default(decimal) && DefaultValue != default(decimal)) { Value = DefaultValue; } set.AddFlag(this); }
public WordEntry(string word, FlagSet flags, MorphSet morphs, WordEntryOptions options) { Word = word; Flags = flags; Morphs = morphs; Options = options; }
internal override void Apply(FlagSet set) { if (!string.IsNullOrEmpty(EnvironmentVariable)) { foreach (var variable in EnvironmentVariable.Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries)) { var envVar = variable.Trim(); var envVal = Environment.GetEnvironmentVariable(envVar); if (string.IsNullOrEmpty(envVal)) { continue; } bool envValBool; if (bool.TryParse(envVal, out envValBool)) { Value = envValBool; break; } } } if (!set.HasFlag(this)) { set.AddFlag(this); } }
public void ChooseMajorValues(int tieBreaker) { //don't touch character body layout //we'll let the texture do that GeneralAge = FlagSet.GetFlagBitValue(GeneralAge, tieBreaker, 1); Ethnicity = FlagSet.GetFlagBitValue(Ethnicity, tieBreaker, 1); }
public static void UpdateState(FlagSet state, string name, bool set) { var orig = state.TryGetValue(name, out var x) ? x : FlagState.Unset; if (set) { if (orig == FlagState.One || orig == FlagState.Unset) { state[name] = FlagState.UnsetToSet; } else if (orig == FlagState.SetToUnset) { state[name] = FlagState.Both; } } else { if (orig == FlagState.One || orig == FlagState.Set) { state[name] = FlagState.SetToUnset; } else if (orig == FlagState.UnsetToSet) { state[name] = FlagState.Both; } } }
public override bool Next() { var receipt = this.WorkingPossibility(); if (receipt == null) { return(false); } this.TriedRooms.Add(receipt.NewRoom.Static); this.AddReceipt(receipt); var newNode = receipt.NewRoom.Nodes["main"]; var state = new FlagSet(); foreach (var node in LinkedNodeSet.Closure(newNode, this.Logic.Caps.WithFlags(state), null, true).Nodes) { foreach (var setter in node.Static.FlagSetters) { TaskPathwayPickRoom.UpdateState(state, setter.Item1, setter.Item2); newNode = node; } } this.AddNextTask(new TaskPathwayPickEdge(this.Logic, newNode, state, false)); if (this.Logic.Settings.Strawberries != StrawberryDensity.None) { this.AddLastTask(new TaskPathwayBerryOffshoot(this.Logic, newNode, state)); } return(true); }
private void HandleRequirements(Requirement r, FlagSet mutState, FlagSet immState) { switch (r) { case Possible _: return; case Conjunction rc: { foreach (var sr in rc.Children) { this.HandleRequirements(sr, mutState, immState); } break; } case Disjunction rd: { // maybe this could be handled by having a TaskSatisfyDisjunction which tries to add the children one at a time? var sr = rd.Children[this.Logic.Random.Next(rd.Children.Count)]; this.HandleRequirements(sr, mutState, immState); break; } default: { if (r is FlagRequirement fr) { mutState[fr.Flag] = fr.Set ? FlagState.Set : FlagState.Unset; } this.AddNextTask(new TaskPathwaySatisfyRequirement(this.Logic, this.Node, r, immState)); break; } } }
protected override void OnInitialise() { // Fetch operands List <byte[]> Operands = Fetch(); // Subtract and store the result flags. Like cmp, only the flags are stored. ResultFlags = Bitwise.Subtract(Operands[1], Operands[0], out _); }
private void RunAsSubcommand(CommandContext context) { if (this.GetCommand(helpCommand.Name) == null && !HideHelp) { Commands.Add(helpCommand); if (!this.HasFlag(helpFlag)) { Flags.Add(helpFlag); } } var flagSet = new FlagSet(Name); foreach (var flag in Flags) { flag.Apply(flagSet); } flagSet.Parse(context.Args().Skip(1).ToArray()); Flags.NormalizeFlags(flagSet); var subContext = new CommandContext(this, flagSet, context); //var ctxArgs = subContext.Args(); var ctxArgs = subContext.Args(); if (ctxArgs.Any()) { var name = ctxArgs.First(); var c = this.GetCommand(name); if (c != null) { if (c.Flags.Any()) { foreach (var flag in c.Flags) { flag.Apply(flagSet); } flagSet.Parse(subContext.Args().ToArray()); Flags.NormalizeFlags(flagSet); } subContext.ConsoleCommand = c; if (!CheckHelp(subContext, c)) { c.Action(subContext); } return; } else { flagSet.Set("help", true); CheckHelp(subContext, context.ConsoleCommand); return; } } Action(context); }
public TaskPathwaySatisfyRequirement(RandoLogic logic, LinkedNode node, Requirement req, FlagSet state, LinkedNode originalNode = null, bool internalOnly = false, int tries = 0) : base(logic) { this.Node = node; this.InternalOnly = internalOnly; this.Req = req; this.OriginalNode = originalNode ?? node; this.Tries = this.BaseTries = tries; this.State = state; }
public override void Execute() { // Perform the decrement byte[] Result; FlagSet ResultFlags = Bitwise.Decrement(Fetch()[0], out Result); // Store results Set(Result); ControlUnit.SetFlags(ResultFlags); }
public IEnumerable <bool> run_interaction(Inventory inventory, FlagSet flags, UIController controller) { var entry = ghost.GetEntryPoint("follow"); if (entry == null) { return(null); } return(ghost.run_graph_interaction(entry, inventory, flags, controller)); }
public TaskPathwayPickRoom(RandoLogic Logic, UnlinkedEdge edge, FlagSet state) : base(Logic) { this.Edge = edge; this.State = state; float progress = (Logic.Map.Worth - PathwayMinimums[(int)Logic.Settings.Length]) / PathwayRanges[(int)Logic.Settings.Length]; this.IsEnd = progress > Math.Sqrt(Logic.Random.NextFloat()); this.FakeEnd = this.IsEnd && Logic.Random.Next(100) == 0; }
public override void Execute() { // Calculate the result of incrementation byte[] Result; FlagSet ResultFlags = Bitwise.Increment(Fetch()[0], out Result); // Set the result. Bitwise.Increment() does not set the carry flag. Set(Result); ControlUnit.SetFlags(ResultFlags); }
public Options(Writer Writer = default, FlagSet Flagset = default, Fetcher Fetch = default, Symbolizer Sym = default, ObjTool Obj = default, UI UI = default, Func <ptr <HTTPServerArgs>, error> HTTPServer = default, http.RoundTripper HTTPTransport = default) { this.Writer = Writer; this.Flagset = Flagset; this.Fetch = Fetch; this.Sym = Sym; this.Obj = Obj; this.UI = UI; this.HTTPServer = HTTPServer; this.HTTPTransport = HTTPTransport; }
public override void Execute() { // Fetch operands List <byte[]> DestSource = Fetch(); // Subtract operand 1 from operand 0 and discard the result, keeping only the flags. This is // the essence of a compare in assembly. FlagSet Result = Bitwise.Subtract(DestSource[0], DestSource[1], out _); ControlUnit.SetFlags(Result); }
public void TestSetOutput() { var flags = new FlagSet("test", ErrorHandling.ContinueOnError); var writer = new StringWriter(); flags.SetOutput(writer); flags.Parse(new[] { "-unknown" }); var output = writer.ToString(); Assert.True(output.Contains("-unknown"), $"expected output mentioning unknown; got \"{output}\""); }
public override void Execute() { // Fetch operands List <byte[]> DestSource = Fetch(); // AND the operands and discard the result FlagSet ResultFlags = Bitwise.And(DestSource[0], DestSource[1], out _); // Set the flags to the result. ControlUnit.SetFlags(ResultFlags); }
private void ShowChoices(FlagSet flag_set) { if (choice_node.answers.Count > 0) { var choices = new List <ListController <int> .ListElement>(); for (int i = 0; i < choice_node.answers.Count; i++) { Port port = choice_node.GetPort($"answers[{i}]"); var answer = choice_node.answers[i]; if (port.IsConnected && port.ConnectedPorts[0].node is InteractionNode) { if ((port.ConnectedPorts[0].node as InteractionNode).FlagsMeetRequirements(flag_set)) { var choice = new ListController <int> .ListElement() { text = answer.list_text, value = i, choosable = true, }; if (answer.unique_preview) { choice.description = answer.preview; } else if (answer.show_preview && port.ConnectedPorts[0].node is DialogueNode) { choice.description = (port.ConnectedPorts[0].node as DialogueNode).Dialogue; } else { choice.description = null; } choices.Add(choice); } } else { choices.Add(new ListController <int> .ListElement() { text = answer.list_text, description = answer.show_preview || answer.unique_preview ? answer.preview : null, choosable = true, value = i }); } } if (choices.Count > 0) { this.choice_controller.ShowList(choices); return; } } choice_node = null; }
public override void Execute() { // Fetch operands List <byte[]> Operands = Fetch(); // Perform the rotate and store the results. The callee will ignore "ControlUnit.Flags.Carry == FlagState.ON" if $UseCarry == false. byte[] Result; FlagSet ResultFlags = Bitwise.RotateRight(Operands[0], Operands[1][0], UseCarry, ControlUnit.Flags.Carry == FlagState.ON, out Result); // Set the results. Set(Result); ControlUnit.SetFlags(ResultFlags); }
public override void Execute() { // Fetch operand(only one is used/provided) byte[] Operand = Fetch()[0]; // Negate it byte[] Result; FlagSet ResultFlags = Bitwise.Negate(Operand, out Result); // Set results. Set(Result); ControlUnit.SetFlags(ResultFlags); }
public override void Execute() { // Fetch operands List <byte[]> Operands = Fetch(); // Perform multiplication of the last two operands(read summary) byte[] Result; FlagSet ResultFlags = Bitwise.Multiply(Operands[Operands.Count - 1], Operands[Operands.Count - 2], (Settings | OpcodeSettings.SIGNED) == Settings, (int)Capacity, out Result); // Set results. Set(Result); ControlUnit.SetFlags(ResultFlags); }
public override void Execute() { // Fetch operands List <byte[]> Operands = Fetch(); // Perform rotation. See Bitwise.RotateLeft(). byte[] Result; FlagSet ResultFlags = Bitwise.RotateLeft(Operands[0], Operands[1][0], UseCarry, ControlUnit.Flags.Carry == FlagState.ON, out Result); // Set results. Set(Result); ControlUnit.SetFlags(ResultFlags); }
public override void Execute() { // Fetch operands List <byte[]> DestSource = Fetch(); // Subtract operands[1] from operands[0]. If the carry flag is set, and would be used as a borrow, tell Bitwise.Subtract to start with a borrow. byte[] Result; FlagSet ResultFlags = Bitwise.Subtract(DestSource[0], DestSource[1], out Result, (ControlUnit.Flags.Carry == FlagState.ON && UseBorrow)); // Set the results Set(Result); ControlUnit.SetFlags(ResultFlags); }
public override void Execute() { // Fetch operands List <byte[]> DestSource = Fetch(); // Perform AND. The position of the two arguments is not important. byte[] Result; FlagSet ResultFlags = Bitwise.And(DestSource[0], DestSource[1], out Result); // Set results Set(Result); ControlUnit.SetFlags(ResultFlags); }
public override void Execute() { // Fetch operands List <byte[]> DestSource = Fetch(); // XOR the operands and store in result byte[] Result; FlagSet ResultFlags = Bitwise.Xor(DestSource[0], DestSource[1], out Result); // Set the result and flags. Set(Result); ControlUnit.SetFlags(ResultFlags); }
public override void Execute() { // Fetch operands List <byte[]> DestSource = Fetch(); // Perform the OR. byte[] Result; FlagSet ResultFlags = Bitwise.Or(DestSource[0], DestSource[1], out Result); // Store results Set(Result); ControlUnit.SetFlags(ResultFlags); }