private void InitializeFromConsoleContext()
{
var xml = ConsoleContext.GetBxl();
Id = xml.ChooseAttr("id", "code");
DataOnly = xml.ResolveFlag("dataonly");
Format = xml.Attr("format");
Query = xml.AttrOrValue("query");
Standalone = xml.ResolveFlag("standalone");
var j = xml.Attr("json");
foreach (var attribute in xml.Attributes())
{
if (attribute.Name.LocalName.StartsWith("p."))
{
Parameters[attribute.Name.LocalName.Substring(2)] = attribute.Value;
}
}
if (!string.IsNullOrWhiteSpace(j))
{
Json = j.jsonify();
}
var flags = xml.Attr("flags").SmartSplit();
foreach (var fl in flags)
{
Flags.Add(fl);
}
}
public BaseEntity(params ComponentFlags[] flags)
{
foreach (ComponentFlags flag in flags)
{
Flags.Add(flag);
}
}
public void MergeFlags(SpellShape other)
{
foreach (var flag in other.Flags.Where(f => !Flags.Contains(f)))
{
Flags.Add(flag);
}
}
public void SetFlag(string id)
{
if (!Flags.Contains(id))
{
Flags.Add(id);
}
}
public experimentVariableSet()
{
Flags.Add("TW", new List <string>());
Flags.Add("TC", new List <string>());
Flags.Add("RX", new List <string>());
Flags.Add("DFC", new List <string>());
Flags.Add("LPF", new List <string>());
}
public void AddFlag(string flag)
{
if (Flags == null)
{
Flags = new List <string>();
}
Flags.Add(flag);
}
public Projectile(Tanks.Tank owner, GameCore game, bool authorized, float density = 1,
float bounciness = 0.1f, Vector2 position = default(Vector2), float rotation = 0)
: base(game, authorized, density, bounciness, position, rotation)
{
Owner = owner;
//Default for projectiles
Flags.Add("PassesThroughTankBlocks");
}
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 void Resolve_Nosynonyms_ArgumentFound_ReturnsArgument()
{
var flags = new Flags();
flags.Add("argument");
var result = flags.Resolve("argument");
Assert.That(result, Is.EqualTo("argument"));
}
public void Resolve_Twosynonyms_ResolveSecondsynonym_ReturnsArgument()
{
var flags = new Flags();
flags.Add("argument", "-a", "--a");
var result = flags.Resolve("--a");
Assert.That(result, Is.EqualTo("argument"));
}
public void SetFlag(ItemFlag flag)
{
if (Locked)
{
throw new InvalidOperationException("This ItemType is locked and cannot be altered.");
}
Flags.Add(flag);
}
public void SetFlag(Flag flag, bool value)
{
if (Flags.ContainsKey(flag))
{
Flags.Remove(flag);
}
Flags.Add(flag, value);
}
public CommandLineTemplate WithFlag(StringTemplate id, string prefix = "")
{
Assert.IsNotNull(id);
Assert.IsNotNull(prefix);
id.Content = prefix + id.Content;
Flags.Add(id);
return(this);
}
public IProjectTree AddFlag(string flag)
{
if (!Flags.Contains(flag))
{
Flags = Flags.Add(flag);
}
return(this);
}
/// <summary>
/// Removes the current message from server
/// </summary>
/// <returns><code>true</code> if the message could be removed, otherwise false</returns>
public bool Remove()
{
if (!Flags.Add(MessageFlags.Deleted) || !_folder.Expunge())
{
return(false);
}
_folder.Messages.RemoveInternal(this);
return(true);
}
public void SetFlags(string flagNames)
{
var flags = flagNames.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
foreach (var flagName in flags.Where(flagName => !Flags.Contains(flagName)))
{
Flags.Add(flagName);
}
}
public static bool ParseWDT(uint FileDataId)
{
long streamPos = 0;
CASC = GameObject.Find("[CASC]").GetComponent <CascHandler>().cascHandler;
if (CASC.FileExists(FileDataId))
{
using (var stream = CASC.OpenFile(FileDataId))
using (var reader = new BinaryReader(stream))
{
WDTflagsdata WDTFlags = new WDTflagsdata();
while (streamPos < stream.Length)
{
stream.Position = streamPos;
WDTChunkId ChunkId = (WDTChunkId)reader.ReadUInt32();
uint ChunkSize = reader.ReadUInt32();
streamPos = stream.Position + ChunkSize;
switch (ChunkId)
{
case WDTChunkId.MVER:
ReadMVER(reader);
break;
case WDTChunkId.MPHD:
ReadMPHD(reader, WDTFlags);
break;
case WDTChunkId.MAIN:
ReadMAIN(reader, WDTFlags);
break;
case WDTChunkId.MAID:
ReadMAID(reader, FileDataId);
break;
default:
SkipUnknownChunk(stream, ChunkId, ChunkSize);
break;
}
}
if (!Flags.ContainsKey(FileDataId))
{
Flags.Add(FileDataId, WDTFlags);
}
}
return(true);
}
else
{
return(false);
}
}
public Flags Clone()
{
Flags f = new Flags();
foreach (var item in this)
{
f.Add(item.Key, item.Value);
}
return(f);
}
internal void AddFlags(string s)
{
if (Flags == null)
{
Flags = new List <string>();
}
if (!Flags.Contains(s))
{
Flags.Add(s);
}
}
public void SetFlag(string flag, bool value)
{
if (!Flags.ContainsKey(flag))
{
Flags.Add(flag, value);
}
else
{
Flags[flag] = value;
}
}
private void Flag_Changed(object sender, System.Windows.RoutedEventArgs e)
{
Flags.Clear();
foreach (KmlPart part in Parts)
{
if (part.Flag != "" && !Flags.Any(x => x.ToLower() == part.Flag.ToLower()))
{
Flags.Add(part.Flag);
}
}
}
private void CreateFlagForTeam(Bitmap allFlags, int x, int y, string name)
{
Bitmap flag = new Bitmap(24, 16);
using (Graphics gr = Graphics.FromImage(flag))
{
gr.Clear(Color.White);
gr.DrawImage(allFlags, new Rectangle(0, 0, 24, 16), x, y, 24, 16, GraphicsUnit.Pixel);
}
Flags.Add(name, flag);
}
void DefineFlag([NotNull] ZilAtom flag)
{
if (!Flags.ContainsKey(flag))
{
// create flag builder
var fb = Game.DefineFlag(flag.Text);
Flags.Add(flag, fb);
UniqueFlags++;
// create constant
Constants.Add(flag, fb);
}
}
private void Toggle(ViewerState state)
{
if (HasFlag("C", false))
{
// It is expended, collapse it.
Flags.Remove(Flags.FirstOrDefault(f => f.Value == "C" && !f.Status));
}
else
{
Flags.Add(new Flag(false, "C"));
}
state.Document.Reload();
}
public override bool SetFlag(string flag)
{
if (HasFlag(flag))
{
return(false);
}
lock (Flags)
{
Flags.Add(flag);
}
Server.Commit(this);
return(true);
}
void LoadString(string s)
{
if (s.Contains('='))
{
var parts = s.Split(new[] { '=' });
if (!string.IsNullOrEmpty(parts[0]))
{
Data[parts[0]] = parts[1];
}
}
else
{
Flags.Add(s);
}
}
public void EditFlag(string flag, StoryModel model)
{
int index = Flags.IndexOf(flag);
if (index == -1)
{
Flags.Add(flag);
model.AddFlagToIndex(flag);
}
else
{
Flags.RemoveAt(index);
model.CollateFlags();
}
}
private void fillLists()
{
this.Colors = this.api.GetColours();
this.Flags = new List <bool>();
Flags.Add(false);
Flags.Add(true);
this.Sizes = this.api.GetSizes();
this.SizesUnits = this.api.GetSizeUnits();
this.WeightUnits = this.api.GetWeightUnits();
this.ProductLines = this.api.GetLines();
this.Classes = this.api.GetClasses();
this.Styles = this.api.GetStyles();
this.ProductSubCategories = this.api.GetSubcategories();
this.ModelIds = this.api.GetModels();
}
/// <summary>
/// Exchange the flag of all parts that match the oldFlag.
/// Party where it doesn't match, will not be changed.
/// </summary>
/// <param name="oldFlag">The old flag name to change</param>
/// <param name="newFlag">The new flag name to apply</param>
public void FlagExchange(string oldFlag, string newFlag)
{
if (Flags.All(x => x.ToLower() != oldFlag.ToLower()))
{
return;
}
Flags.Clear();
foreach (KmlPart part in Parts)
{
part.FlagExchange(oldFlag, newFlag);
if (!Flags.Contains(part.Flag))
{
Flags.Add(part.Flag);
}
}
}
public override bool SetFlag(string flag)
{
lock (Flags)
{
if (!Flags.Contains(flag))
{
Flags.Add(flag);
Server.Commit(this);
return(true);
}
else
{
return(false);
}
}
}
// WDT files specify exactly which map tiles are present in a world, if any, and can also reference a "global" WMO.
// They have a chunked file structure.
public static void Load(string Path, string MapName)
{
string WDTpath = Path + MapName + ".wdt";
Stream WDTstream = Casc.GetFileStream(WDTpath);
WDTflagsdata WDTflags = new WDTflagsdata();
ReadMVER(WDTstream);
ReadMPHD(WDTstream, MapName, WDTflags);
ReadMAIN(WDTstream, WDTflags);
// wmo only worlds specific chunk parsing here :
Flags.Add(MapName, WDTflags);
WDTstream.Close();
WDTstream = null;
}
public bool AddFlag(String name, String shortcut)
{
bool result = false;
if (Flags.Contains(name) == false)
{
Flags.Add(name);
if (String.IsNullOrEmpty(shortcut) == false)
{
Shortcuts.Add(shortcut, name);
}
result = true;
}
return(result);
}