Extractor_Serializer.NewParser.ParseReqs C# (CSharp) Method

ParseReqs() public method

The parse reqs.
public ParseReqs ( List rreqs ) : List
rreqs List /// The rreqs. ///
return List
        public List<Requirement> ParseReqs(List<rawreqs> rreqs)
        {
            int numreqs = rreqs.Count;

            List<Requirement> output = new List<Requirement>();
            Requirement aor = null;
            for (int i = 0; i < numreqs; i++)
            {
                rawreqs rr = rreqs[i];
                if (aor == null)
                {
                    aor = new Requirement();
                }

                aor.Target = ItemTarget.Self; // 0x13
                aor.Statnumber = rr.stat;
                aor.Operator = (Operator)Enum.ToObject(typeof(Operator), rr.ops);
                aor.Value = rr.val;
                aor.ChildOperator = Operator.Unknown;

                if ((i < numreqs - 1)
                    && (
                    (aor.Operator == Operator.OnTarget)
                    || (aor.Operator == Operator.OnSelf)
                    || (aor.Operator == Operator.OnUser)
                        || (aor.Operator == Operator.OnValidTarget)
                        || (aor.Operator == Operator.OnInvalidTarget)
                        || (aor.Operator == Operator.OnValidUser)
                        || (aor.Operator == Operator.OnInvalidUser)
                        || (aor.Operator == Operator.OnGeneralBeholder)
                        || (aor.Operator == Operator.OnCaster)
                        || (aor.Operator == Operator.Unknown2)))
                {
                    aor.Target = (ItemTarget)(int)aor.Operator;
                    i++;
                    rr = rreqs[i];
                    aor.Statnumber = rr.stat;
                    aor.Value = rr.val;
                    aor.Operator = (Operator)Enum.ToObject(typeof(Operator), rr.ops);
                }

                if (!((i >= numreqs - 1) || (numreqs == 2)))
                {
                    int anum = rreqs[i + 1].stat;
                    int aval = rreqs[i + 1].val;
                    int aop = rreqs[i + 1].ops;

                    if ((((aop == (int)Operator.Or) || (aop == (int)Operator.And)) || (aop == (int)Operator.Not)) || (anum == (int)Operator.EqualTo))
                    {
                        aor.ChildOperator = (Operator)Enum.ToObject(typeof(Operator), aop);
                        i++;
                    }
                }
                output.Add(aor);
                aor = null;
            }

            if (output.Count > 1)
            {
                output[0].ChildOperator = output[1].ChildOperator;
            }
            else
            {
                output[0].ChildOperator = Operator.Or;
            }
            /*output[0].ChildOperator = Operator.Or;
            for (int i = 0; i < output.Count - 2; i++)
            {
                output[i].ChildOperator = output[i + 1].ChildOperator;
            }*/

            return output;
        }