void Start()
 {
     nma = GetComponent<NavMeshAgent>();
     attri = GetComponent<Attributes>();
     StartCoroutine("WaitATick");
     nma.stoppingDistance = attri.range;
 }

            protected Attributes _attributes; // start tags get attributes on construction. End tags get attributes on first new attribute (but only for parser convenience, not used).

            public void NewAttribute()
            {
                if (_attributes == null)
                {
                    _attributes = new Attributes();
                }

                if (_pendingAttributeName != null)
                {
                    NSoup.Nodes.Attribute attribute;
                    if (_pendingAttributeValue == null)
                    {
                        attribute = new NSoup.Nodes.Attribute(_pendingAttributeName, "");
                    }
                    else
                    {
                        attribute = new NSoup.Nodes.Attribute(_pendingAttributeName, _pendingAttributeValue.ToString());
                    }

                    _attributes.Add(attribute);
                }
                _pendingAttributeName = null;
                if (_pendingAttributeValue != null)
                {
                    _pendingAttributeValue.Remove(0, _pendingAttributeValue.Length);
                }
            }

        public ControllerContext(ILog log, Attributes startupAttributes)
        {
            Ensure.NotNull(log, nameof(log));

            Log = log;
            StartupAttributes = startupAttributes ?? new Attributes();
        }

 private static Attributes CopyAttributes(Attributes source) {
   if (source == null) {
     return null;
   } else {
     return new Attributes(source.Name, source.Args, CopyAttributes(source.Prev));
   }
 }

 public override int Calculate(Attributes propertyAttrs, int val)
 {
     if (!Empty)
         foreach (List<EffectNode> list in effects)
             list.ForEach(node => node.Effect.Affect(propertyAttrs, node.Attributes, ref val));
     return val;
 }

 /// <summary>
 /// Creates a new weapon with specified name and attributes.
 /// </summary>
 public Weapon(WeaponProperties data, CombatProperties propes, Attributes attri, StatusEffectProperties effect)
 {
     WeaponData = data;
     CombatProperties = propes;
     Attributes = attri;
     Effect = effect;
 }

 // attribute names are generally caught in one hop, not accumulated
 // but values are accumulated, from e.g. & in hrefs
 // start tags get attributes on construction. End tags get attributes on first new attribute (but only for parser convenience, not used).
 internal void NewAttribute()
 {
     if (attributes == null)
     {
         attributes = new Attributes();
     }
     if (pendingAttributeName != null)
     {
         Attribute attribute;
         if (pendingAttributeValue == null)
         {
             attribute = new Attribute(pendingAttributeName, string.Empty);
         }
         else
         {
             attribute = new Attribute(pendingAttributeName, pendingAttributeValue.ToString());
         }
         attributes.Put(attribute);
     }
     pendingAttributeName = null;
     if (pendingAttributeValue != null)
     {
         pendingAttributeValue.Remove(0, pendingAttributeValue.Length);
     }
 }

    public equipment(string name, equipSlots.equipmentType type, equipSlots.slots slot, int equipmentTier, int minlevel, int maxlevel, float health, float resource, float power, float defense, float mindmg, float maxdmg, float movespeed, float attackspeed, string flavortxt)
    {
        equipmentAttributes = new Attributes();
        equipmentName = name;
        equipmentType = type;
        flavorText = flavortxt;
        validSlot = slot;
        tier = equipmentTier;
        minlvl = minlevel;
        maxlvl = maxlevel;
        equipmentAttributes.Health = health;
        equipmentAttributes.Resource = resource;
        equipmentAttributes.Power = power;
        equipmentAttributes.Defense = defense;
        equipmentAttributes.MinDamage = mindmg;
        equipmentAttributes.MaxDamage = maxdmg;
        equipmentAttributes.AttackSpeed = attackspeed;
        equipmentAttributes.MovementSpeed = movespeed;

        slotList.Add("Head", equipSlots.slots.Head);
        slotList.Add("Legs", equipSlots.slots.Legs);
        slotList.Add("Feet", equipSlots.slots.Feet);
        slotList.Add("Chest", equipSlots.slots.Chest);
        slotList.Add("Main", equipSlots.slots.Main);
        slotList.Add("Off", equipSlots.slots.Off);

        twohand = false;
        ranged = false;
        onhit = "";

        prefixname = "";
        suffixname = "";

        modelname = "default";
    }

 public Screen(int x, int y)
 {
     Width = x;
     Height = y;
     Buffer = new char[y * x];
     Attributes = new Attributes[Buffer.Length];
 }

    public affix(string name, equipSlots.affixtype type, float health, float resource, float power, float defense, float mindmg, float maxdmg, float movespeed, float attackspeed, equipSlots.slots[] validslots)
    {
        affixAttributes = new Attributes();
        affixName = name;
        affixType = type;
        affixAttributes.Health = health;
        affixAttributes.Resource = resource;
        affixAttributes.Power = power;
        affixAttributes.Defense = defense;
        affixAttributes.MinDamage = mindmg;
        affixAttributes.MaxDamage = maxdmg;
        affixAttributes.AttackSpeed = attackspeed;
        affixAttributes.MovementSpeed = movespeed;

        foreach (equipSlots.slots slot in validslots)
        {
            affixSlots.Add(slot);
        }

        slotList.Add("Head", equipSlots.slots.Head);
        slotList.Add("Legs", equipSlots.slots.Legs);
        slotList.Add("Feet", equipSlots.slots.Feet);
        slotList.Add("Chest", equipSlots.slots.Chest);
        slotList.Add("Main", equipSlots.slots.Main);
        slotList.Add("Off", equipSlots.slots.Off);
    }

    public void InitializeStats(int level)
    {
        Attributes tempatts = new Attributes();
        _entity = GetComponent<Entity>();

        tempatts.Health = baseHP + scalingHP * (level - 1);
        tempatts.Resource = baseResource + scalingResource * (level - 1);
        tempatts.Power = basePower + scalingPower * (level - 1);
        tempatts.Defense = baseDefense + scalingDefense * (level - 1);
        tempatts.MinDamage = baseMinDmg + scalingMinDmg * (level - 1);
        tempatts.MaxDamage = baseMaxDmg + scalingMaxDmg * (level - 1);
        tempatts.MovementSpeed = baseMoveSpd + scalingMoveSpd * (level - 1);
        tempatts.AttackSpeed = baseAttackSpd + scalingAttackSpd * (level - 1);

        LootDropChance = UnityEngine.Random.Range(0f, 3f);

        MinLootDrops = 1;
        MaxLootDrops = 5;

        _entity.baseAtt = tempatts;

        GetComponent<Entity>().UpdateCurrentAttributes();

        GetComponent<AIController>().doesWander = wanders;
        GetComponent<AIController>().aggroRadius = _aggroRadius;
        GetComponent<AIPursuit>().doesFlee= flees;
    }

        internal string TestVideoConversion()
        {
            var readWriteFactory = new ReadWriteClassFactory();

            var attributes = new Attributes
            {
                ReadWriterEnableHardwareTransforms = true,
                SourceReaderEnableVideoProcessing = true
            };

            var readers = VideoFiles.Select(f => f.CreateSourceReader(readWriteFactory, attributes)).ToArray();

            var testOuputFile = readers.First().FileName + ".tmp.test.wmv";
            try
            {
                using (var sinkWriter = readWriteFactory.CreateSinkWriterFromURL(testOuputFile, attributes))
                {
                    var writeToSink = ConnectStreams(readers, sinkWriter);
                }
            }
            catch(Exception e)
            {
                return e.Message;
            }
            finally
            {
                if (readers != null)
                    foreach (var r in readers)
                        r.Dispose();

                File.Delete(testOuputFile);
            }

            return null;
        }

        public SourceReaderExtra CreateSourceReader(ReadWriteClassFactory readWriteFactory, Attributes attributes)
        {
            TraceDebug.WriteLine("Attempting to open file {0}".F(this.FileName));
            var reader = readWriteFactory.CreateSourceReaderFromURL(this.FileName, attributes);
            TraceDebug.WriteLine("Opened file {0}.  Duration: {1}".F(this.FileName, reader.Duration.FromNanoToSeconds()));

            return new SourceReaderExtra(this.FileName,  this.State,  reader);
        }

 /// <summary>
 /// Create a new Node.
 /// </summary>
 /// <param name="baseUri">base URI</param>
 /// <param name="attributes">attributes (not null, but may be empty)</param>
 internal Node(string baseUri, Attributes attributes)
 {
     Validate.NotNull(baseUri);
     Validate.NotNull(attributes);
     childNodes = new List<Node>(4);
     this.baseUri = baseUri.Trim();
     this.attributes = attributes;
 }

        public override System.Web.UI.WebControls.WebControl RenderControl(Attributes.Setting setting, Object sender)
        {
            tb.ID = setting.GetName();

            tb.TextMode = TextBoxMode.Password;
            tb.CssClass = "guiInputText guiInputStandardSize";
            return tb;
        }

 public CreatedAttribute(Attributes attribute, bool isPhysical, int minRating, int maxRating)
 {
     IsPhysical = isPhysical;
     CurrentRating = minRating;
     MinRating = minRating;
     Attribute = attribute;
     _maxRating = maxRating;
 }

        public override System.Web.UI.WebControls.WebControl RenderControl(Attributes.Setting setting, Object sender)
        {
            cc.ShowXPath = false;
            cc.ID = setting.GetName().Replace(" ", "_");

            cc.Value = _val;
            return (System.Web.UI.WebControls.WebControl)cc;
        }

 /// <summary>
 /// Returns a string for all attributes on the list "a".  Each attribute is
 /// followed by a space.
 /// </summary>
 public static string AttributesToString(Attributes a)
 {
     if (a == null) {
     return "";
       } else {
     return AttributesToString(a.Prev) + OneAttributeToString(a) + " ";
       }
 }

 public ItemWithAttributes(Attributes attributes)
 {
     Attributes = attributes;
     statusParticleTextureData = getTextureDataForStatus(Attributes.Status);
     statusParticleTimer = 0.0f;
     affiliationTint = getColorForAffiliation(Attributes.Affiliation);
     affiliationTintAlpha = 0.0f;
     incAffiliationTintAlpha = true;
 }

 // render opcode 5 - change picture
 /**
    * @see <a href="XRenderChangePicture.html">XRenderChangePicture</a>
    */
 public void change(Attributes attr)
 {
     Request request = new Request (display, render.major_opcode, 5,
       5+attr.count ());
     request.write4 (id);
     request.write4 (attr.bitmask);
     attr.write (request);
     display.send_request (request);
 }