Esempio n. 1
0
    public override void OnTrigger(FieldInstance instance)
    {
        base.OnTrigger(instance);

        parentFsm.Event("BossAlert");
        PlaySound(61);
    }
Esempio n. 2
0
    public override void OnCollision(FieldInstance instance)
    {
        base.OnCollision(instance);

        IActionHandler target = Colliders[0] as IActionHandler;
        if (action is ActionSingle)
        {
            ActionSingle actionSingle = action as ActionSingle;
            if (target.IsActionApplicable(actionSingle.Type))
            {
                var result = target.ApplyAction(actionSingle, this);
                if (result != null && result.value != 0)
                {
                    OnHit(instance);
                }
            }
        }
        else
        {
            Debug.LogError("not implemented");
        }

        //Remove();
        RemoveOverlapEvent();
    }
Esempio n. 3
0
    public override void OnTrigger(FieldInstance instance)
    {
        base.OnTrigger(instance);

        (instance as HeroCharacter).TryAddItem(item);
        Remove();
    }
Esempio n. 4
0
    public override void OnTrigger(FieldInstance instance)
    {
        base.OnTrigger(instance);

        if (instance is HeroCharacter)
        {
            RemoveFromLayer();
            EmitEvent("StageCleared");
        }
    }
Esempio n. 5
0
File: Spot.cs Progetto: pb0/ID0_Test
    public override void OnTrigger(FieldInstance instance)
    {
        base.OnTrigger(instance);

        Action action = ActionPattern.Generate(actionPattern, Stat);
        if (action != null)
        {
            if (Fire(action, null))
            {
                FSMEvent("OnTrigger");
            }
        }
    }
Esempio n. 6
0
 public void AddChild(FieldInstance parent, FieldInstance child, float initX, float initY)
 {
     if (parent.Rect == null)
     {
         Debug.LogError("parent " + parent + " is not in layer");
     }
     parent.Rect.point.layer.AddSubject(child, initX, initY);
     AddFieldInstance(child);
 }
Esempio n. 7
0
 void MoveToAfterNext(FieldInstance entity, LinkedListNode<FieldInstance> next)
 {
     LinkedListNode<FieldInstance> current = fieldList.Find(entity);
     fieldList.Remove(current);
     fieldList.AddAfter(next, entity);
 }
Esempio n. 8
0
 public override void GetStatic(FieldInstance field)
 {
     throw new NotImplementedException();
 }
Esempio n. 9
0
    void AddFieldInstance(FieldInstance instance)
    {
        instance.SetField(this);

        if (fieldList.First == null || instance.Position < fieldList.First.Value.Position)
        {
            fieldList.AddFirst(instance);
        }
        else if (fieldList.Last.Value.Position <= instance.Position)
        {
            fieldList.AddLast(instance);
        }
        else
        {
            foreach (var entity in fieldList)
            {
                LinkedListNode<FieldInstance> current = fieldList.Find(entity);
                if (current.Value.Position <= instance.Position && instance.Position < current.Next.Value.Position)
                {
                    fieldList.AddAfter(current, instance);
                    break;
                }
            }
        }
    }
Esempio n. 10
0
        private object GetParsedValue(FieldInstance fieldInstanceType, object value)
        {
            ParseFieldValueAction action = LDtkFieldParser.GetParserMethodForType(fieldInstanceType);

            return(action?.Invoke(value));
        }
Esempio n. 11
0
 public override void PutField(FieldInstance field)
 {
     throw new NotImplementedException();
 }
Esempio n. 12
0
 public override FieldInstance ImplementField(FieldInstance field, FScript script)
 {
     return(base.ImplementField(field, script));
 }
Esempio n. 13
0
    protected override void OnHit(FieldInstance instance)
    {
        base.OnHit(instance);

        if (objectProjectile.ImpactSFX > 0)
        {
            instance.PlaySound(objectProjectile.ImpactSFX);
        }
    }
Esempio n. 14
0
 public override IFieldVisitor VisitField(FieldInstance field)
 {
     return(new TraceFieldVisitor(base.VisitField(field), sb));
 }
Esempio n. 15
0
 public override FieldInstance ImplementField(FieldInstance field)
 {
     return(base.ImplementField(field));
 }
Esempio n. 16
0
 public override FieldInstance HideFromDebug(FieldInstance field)
 {
     return(base.HideFromDebug(field));
 }
Esempio n. 17
0
 public override PropertyInstance ImplementGetter(PropertyInstance property, FieldInstance field)
 {
     return(base.ImplementGetter(property, field));
 }
Esempio n. 18
0
 public override MethodInstance ImplementGetter(MethodInstance method, FieldInstance field)
 {
     return(base.ImplementGetter(method, field));
 }
Esempio n. 19
0
 public VectorControl(FieldInstance mover)
 {
     this.mover = mover;
 }
Esempio n. 20
0
 bool ILDtkValueParser.TypeName(FieldInstance instance)
 {
     return(instance.IsString);
 }
Esempio n. 21
0
    public override void OnCollision(FieldInstance instance)
    {
        base.OnCollision(instance);

        FSMEvent("OnCollision");
    }
Esempio n. 22
0
        /// ------------------------------------------------------------------------------------
        public virtual IEnumerable <string> GetAllParticipants()
        {
            var allParticipants = MetaDataFile.GetStringValue(SessionFileType.kParticipantsFieldName, string.Empty);

            return(FieldInstance.GetMultipleValuesFromText(allParticipants));
        }
        public override void VisitEnd()
        {
            HashMap <String, List <MethodInfo> > nameToMethodsMap = new HashMap <String, List <MethodInfo> >();

            foreach (MethodInfo method in ReflectUtil.GetMethods(State.OriginalType))
            {
                List <MethodInfo> methodList = nameToMethodsMap.Get(method.Name);
                if (methodList == null)
                {
                    methodList = new List <MethodInfo>();
                    nameToMethodsMap.Put(method.Name, methodList);
                }
                methodList.Add(method);
            }
            foreach (IPropertyInfo propertyInfo in propertyInfos)
            {
                MethodInfo getter = ((MethodPropertyInfo)propertyInfo).Getter;
                MethodInfo setter = ((MethodPropertyInfo)propertyInfo).Setter;
                if (getter == null)
                {
                    // look for abstract definition of the getter
                    getter = ReflectUtil.GetDeclaredMethod(true, State.CurrentType, propertyInfo.PropertyType, "get_" + propertyInfo.Name);
                }
                if (setter == null)
                {
                    // look for abstract definition of the setter
                    setter = ReflectUtil.GetDeclaredMethod(true, State.CurrentType, typeof(void), "set_" + propertyInfo.Name,
                                                           propertyInfo.PropertyType);
                }
                MethodInstance m_getterTemplate = getter != null ? new MethodInstance(getter) : null;
                MethodInstance m_setterTemplate = setter != null ? new MethodInstance(setter) : null;
                MethodInstance m_getter         = MethodInstance.FindByTemplate(m_getterTemplate, true);
                MethodInstance m_setter         = MethodInstance.FindByTemplate(m_setterTemplate, true);

                if (m_getter != null && m_setter != null)
                {
                    // ensure both accessors are public
                    if (!m_getter.Access.HasFlag(MethodAttributes.Public))
                    {
                        IMethodVisitor mv = VisitMethod(m_getter.DeriveAccess(MethodAttributes.Public));
                        mv.LoadThis();
                        mv.LoadArgs();
                        mv.InvokeSuper(m_getter);
                        mv.ReturnValue();
                        mv.EndMethod();
                    }
                    if (!m_setter.Access.HasFlag(MethodAttributes.Public))
                    {
                        IMethodVisitor mv = VisitMethod(m_setter.DeriveAccess(MethodAttributes.Public));
                        mv.LoadThis();
                        mv.LoadArgs();
                        mv.InvokeSuper(m_getter);
                        mv.ReturnValue();
                        mv.EndMethod();
                    }
                    continue;
                }
                if (m_getter != null || m_setter != null)
                {
                    // at least one of the accessors is explicitly implemented
                    continue;
                }
                FieldInstance f_backingField = EnsureBackingField(propertyInfo);
                if (f_backingField == null)
                {
                    continue;
                }
                if (m_setterTemplate == null)
                {
                    m_setterTemplate = new MethodInstance(null, MethodAttributes.Public | MethodAttributes.SpecialName, m_setterTemplate != null ? m_setterTemplate.ReturnType : NewType.VOID_TYPE,
                                                          "set_" + propertyInfo.Name, f_backingField.Type);
                }
                // implement setter
                m_setterTemplate = ImplementSetter(m_setterTemplate, f_backingField);
                List <MethodInfo> allSettersWithSameName = nameToMethodsMap.Get(m_setterTemplate.Name);
                if (allSettersWithSameName != null)
                {
                    MethodInstance f_m_setterTemplate = m_setterTemplate;
                    foreach (MethodInfo setterWithSameName in allSettersWithSameName)
                    {
                        MethodInstance m_setterWithSameName = MethodInstance.FindByTemplate(setterWithSameName, true);
                        if (m_setterWithSameName != null)
                        {
                            // method is implemented, so nothing to do
                            continue;
                        }
                        IMethodVisitor mv = VisitMethod(new MethodInstance(setterWithSameName));
                        if (mv.Method.Parameters.Length != 1)
                        {
                            // this visitor handles only "true" setters with exactly one argument
                            continue;
                        }
                        mv.CallThisSetter(m_setterTemplate, delegate(IMethodVisitor mg)
                        {
                            mg.LoadArg(0);
                            mg.CheckCast(f_m_setterTemplate.Parameters[0].Type);
                        });
                        mv.ReturnVoidOrThis();
                        mv.EndMethod();
                    }
                }
                if (m_getterTemplate == null)
                {
                    m_getterTemplate = new MethodInstance(null, MethodAttributes.Public | MethodAttributes.SpecialName, f_backingField.Type, "get_" + propertyInfo.Name, null);
                }
                // implement getter
                m_getterTemplate = ImplementGetter(m_getterTemplate, f_backingField);
                List <MethodInfo> allGettersWithSameName = nameToMethodsMap.Get(m_getterTemplate.Name);
                if (allGettersWithSameName != null)
                {
                    foreach (MethodInfo getterWithSameName in allGettersWithSameName)
                    {
                        MethodInstance m_getterWithSameName = MethodInstance.FindByTemplate(getterWithSameName, true);
                        if (m_getterWithSameName != null)
                        {
                            // method is implemented, so nothing to do
                            continue;
                        }
                        IMethodVisitor mv = VisitMethod(new MethodInstance(getterWithSameName));
                        mv.CallThisGetter(m_getterTemplate);
                        mv.ReturnValue();
                        mv.EndMethod();
                    }
                }
            }
            base.VisitEnd();
        }
Esempio n. 24
0
        protected void ImplementSetPrimitives(Member[] primitiveMembers, FieldInstance[] f_primitives, FieldInstance[] f_nullFlags)
        {
            MethodInstance template_m_setPrimitives = new MethodInstance(null, typeof(RootCacheValue), typeof(void), "SetPrimitives", typeof(Object[]));

            IMethodVisitor    mv       = VisitMethod(template_m_setPrimitives);
            LocalVariableInfo loc_item = mv.NewLocal(objType);

            for (int primitiveIndex = 0, size = f_primitives.Length; primitiveIndex < size; primitiveIndex++)
            {
                FieldInstance f_primitive  = f_primitives[primitiveIndex];
                FieldInstance f_nullFlag   = f_nullFlags[primitiveIndex];
                Member        member       = primitiveMembers[primitiveIndex];
                Type          originalType = member.RealType;

                Script script_loadArrayValue = new Script(delegate(IMethodVisitor mg)
                {
                    mg.LoadArg(0);
                    mg.Push(primitiveIndex);
                    mg.ArrayLoad(objType);
                });

                Label l_finish = mv.NewLabel();

                if (f_nullFlag == null)
                {
                    if (!originalType.IsValueType)
                    {
                        mv.PutThisField(f_primitive, script_loadArrayValue);
                        continue;
                    }
                    script_loadArrayValue(mv);
                    mv.StoreLocal(loc_item);
                    mv.LoadLocal(loc_item);
                    mv.IfNull(l_finish);

                    mv.PutThisField(f_primitive, new Script(delegate(IMethodVisitor mg)
                    {
                        mg.LoadLocal(loc_item);
                        mg.Unbox(f_primitive.Type.Type);
                    }));

                    mv.Mark(l_finish);
                    continue;
                }

                Label l_itemIsNull = mv.NewLabel();

                script_loadArrayValue(mv);
                mv.StoreLocal(loc_item);

                mv.LoadLocal(loc_item);
                mv.IfNull(l_itemIsNull);

                mv.PutThisField(f_primitive, delegate(IMethodVisitor mg)
                {
                    mg.LoadLocal(loc_item);
                    mg.Unbox(f_primitive.Type.Type);
                });

                if (f_nullFlag != null)
                {
                    // field is a nullable numeric value in the entity, but a native numeric value in our RCV
                    mv.PutThisField(f_nullFlag, delegate(IMethodVisitor mg)
                    {
                        mg.Push(false);
                    });
                }

                mv.GoTo(l_finish);
                mv.Mark(l_itemIsNull);

                if (f_nullFlag != null)
                {
                    // field is a nullable numeric value in the entity, but a native numeric value in our RCV
                    mv.PutThisField(f_nullFlag, delegate(IMethodVisitor mg)
                    {
                        mg.Push(true);
                    });
                }
                else
                {
                    mv.PutThisField(f_primitive, delegate(IMethodVisitor mg)
                    {
                        mg.PushNullOrZero(f_primitive.Type.Type);
                    });
                }
                mv.Mark(l_finish);
            }
            mv.ReturnValue();
            mv.EndMethod();
        }
Esempio n. 25
0
    private static void ParseCustomFields <T>(T classFields, FieldInstance[] fields, LDtkLevel level)
    {
        for (int i = 0; i < fields.Length; i++)
        {
            FieldInstance fieldInstance = fields[i];
            string        variableName  = fieldInstance._Identifier;

            PropertyInfo variableDef = typeof(T).GetProperty(variableName);

            if (variableDef == null)
            {
                throw new FieldNotFoundException($"Error: Field \"{variableName}\" not found in {typeof(T).FullName}. Maybe you should run ldtkgen again to update the files?");
            }

            // Split any enums
            int enumTypeIndex = fieldInstance._Type.LastIndexOf('.');
            int arrayEndIndex = fieldInstance._Type.LastIndexOf('>');

            string variableType = fieldInstance._Type;

            if (enumTypeIndex != -1)
            {
                variableType = arrayEndIndex != -1
                    ? variableType.Remove(enumTypeIndex, arrayEndIndex - enumTypeIndex)
                    : variableType.Remove(enumTypeIndex, variableType.Length - enumTypeIndex);
            }

            switch (variableType)
            {
            case Field.IntType:
            case Field.BoolType:
            case Field.EnumType:
            case Field.FloatType:
            case Field.StringType:
            case Field.FilePathType:
                if (fieldInstance._Value != null)
                {
                    variableDef.SetValue(classFields, Convert.ChangeType(fieldInstance._Value.ToString(), variableDef.PropertyType));
                }

                break;

            case Field.IntArrayType:
            case Field.BoolArrayType:
            case Field.EnumArrayType:
            case Field.FloatArrayType:
            case Field.StringArrayType:
            case Field.FilePathArrayType:
            case Field.LocalEnumArrayType:
                object primativeArrayValues = JsonSerializer.Deserialize(fieldInstance._Value.ToString(), variableDef.PropertyType, new JsonSerializerOptions()
                {
                    Converters = { new JsonStringEnumConverter() }
                });
                variableDef.SetValue(classFields, Convert.ChangeType(primativeArrayValues, variableDef.PropertyType));
                break;

            case Field.LocalEnumType:
                variableDef.SetValue(classFields, Enum.Parse(variableDef.PropertyType, fieldInstance._Value.ToString()));
                break;

            case Field.ColorType:
                variableDef.SetValue(classFields, ParseStringToColor(fieldInstance._Value.ToString()));
                break;

            // Only Entities can have point fields
            case Field.PointType:
                if (fieldInstance._Value != null)
                {
                    if (variableDef.PropertyType == typeof(Vector2))
                    {
                        Vector2 vector = (Vector2)fieldInstance._Value;
                        variableDef.SetValue(classFields, vector);
                    }
                    else if (variableDef.PropertyType == typeof(Point))
                    {
                        Point point = JsonSerializer.Deserialize <Point>(fieldInstance._Value.ToString(), new JsonSerializerOptions()
                        {
                            Converters = { new CxCyConverter() }
                        });
                        variableDef.SetValue(classFields, point);
                    }
                }
                else
                {
                    if (variableDef.PropertyType == typeof(Vector2))
                    {
                        variableDef.SetValue(classFields, Vector2.Zero);
                    }
                    else if (variableDef.PropertyType == typeof(Point))
                    {
                        variableDef.SetValue(classFields, Point.Zero);
                    }
                }

                break;

            case Field.PointArrayType:
                List <Point> points = JsonSerializer.Deserialize <List <Point> >(fieldInstance._Value.ToString(), new JsonSerializerOptions()
                {
                    Converters = { new CxCyConverter() }
                });

                int gridSize = 0;
                for (int j = 0; j < level.LayerInstances.Length; j++)
                {
                    if (level.LayerInstances[j]._Type == LayerType.Entities)
                    {
                        gridSize = level.LayerInstances[j]._GridSize;
                    }
                }

                for (int j = 0; j < points.Count; j++)
                {
                    points[j]  = new Point(points[j].X * gridSize, points[j].Y * gridSize);
                    points[j] += level.Position;
                    points[j] += new Point(gridSize / 2);
                }

                variableDef.SetValue(classFields, points.ToArray());
                break;

            default:
                throw new FieldNotFoundException("Unknown Variable of type " + fieldInstance._Type);
            }
        }
    }
Esempio n. 26
0
        protected void ImplementPropertyChangeOnProperty(PropertyInstance propertyInfo,
                                                         PropertyInstance p_propertyChangeTemplate, MethodInstance m_firePropertyChange, FieldInstance f_propertyChangeSupport)
        {
            // add property change detection and notification
            if (propertyInfo.Getter == null || propertyInfo.Setter == null)
            {
                return;
            }
            if (InitializeEmbeddedMemberVisitor.IsEmbeddedMember(metaData, propertyInfo.Name))
            {
                return;
            }
            PropertyInstance p_getterMethodHandle = ImplementAssignedReadonlyProperty(propertyInfo.Name + "$MethodHandle",
                                                                                      new MethodHandleValueResolver(PropertyInfoProvider, propertyInfo.Name));
            Type           propertyType         = propertyInfo.PropertyType.Type;
            MethodInstance m_hasPropertyChanged = GetApplicableHasPropertyChangedOverload(propertyType);

            // check value type of last parameter
            bool isBoxingNeededForHasPropertyChanged = IsBoxingNeededForHasPropertyChangedOverload(m_hasPropertyChanged, propertyType);

            IMethodVisitor    mg              = VisitMethod(propertyInfo.Setter);
            Label             l_finish        = mg.NewLabel();
            Label             l_noOldValue    = mg.NewLabel();
            Label             l_noChangeCheck = mg.NewLabel();
            LocalVariableInfo loc_oldValue;

            if (isBoxingNeededForHasPropertyChanged)
            {
                loc_oldValue = mg.NewLocal(typeof(Object));
            }
            else
            {
                loc_oldValue = mg.NewLocal(propertyType);
            }
            LocalVariableInfo loc_valueChanged = mg.NewLocal <bool>();

            MethodInstance m_getSuper       = EnhancerUtil.GetSuperGetter(propertyInfo);
            bool           relationProperty = m_getSuper.Name.EndsWith(ValueHolderIEC.GetNoInitSuffix());

            // initialize flag with false
            mg.Push(false);
            mg.StoreLocal(loc_valueChanged);

            // initialize oldValue with null
            mg.PushNullOrZero(loc_oldValue.LocalType);
            mg.StoreLocal(loc_oldValue);

            if (relationProperty)
            {
                // check if a setter call to an UNINITIALIZED relation occured with value null
                // if it the case there would be no PCE because oldValue & newValue are both null
                // but we need a PCE in this special case
                Label         l_noSpecialHandling = mg.NewLabel();
                FieldInstance f_state             = State.GetAlreadyImplementedField(ValueHolderIEC.GetInitializedFieldName(propertyInfo.Name));
                mg.GetThisField(f_state);
                mg.PushEnum(ValueHolderState.INIT);
                mg.IfCmp(typeof(ValueHolderState), CompareOperator.EQ, l_noSpecialHandling);
                mg.Push(true);
                mg.StoreLocal(loc_valueChanged);
                mg.Mark(l_noSpecialHandling);
            }

            // check if value should be checked to decide for a PCE
            mg.LoadLocal(loc_valueChanged);
            mg.IfZCmp(CompareOperator.NE, l_noOldValue);

            // get old field value calling super property getter
            mg.LoadThis();
            mg.InvokeOnExactOwner(m_getSuper);
            if (isBoxingNeededForHasPropertyChanged)
            {
                mg.Box(propertyType);
            }
            mg.StoreLocal(loc_oldValue);

            mg.Mark(l_noOldValue);

            // set new field value calling super property setter
            mg.LoadThis();
            mg.LoadArg(0);
            mg.InvokeOnExactOwner(EnhancerUtil.GetSuperSetter(propertyInfo));
            mg.PopIfReturnValue(EnhancerUtil.GetSuperSetter(propertyInfo));

            // check if value should be checked to decide for a PCE
            mg.LoadLocal(loc_valueChanged);
            mg.IfZCmp(CompareOperator.NE, l_noChangeCheck);

            LocalVariableInfo loc_newValue = null;

            if (isBoxingNeededForHasPropertyChanged)
            {
                loc_newValue = mg.NewLocal(typeof(Object)); // loc_1  Object newValue
                // Object loc_1 = (Object)value;
                mg.LoadArg(0);
                mg.Box(propertyType);
                mg.StoreLocal(loc_newValue);
            }
            mg.CallThisGetter(p_propertyChangeTemplate);
            // call HasPropertyChanged (static)
            mg.LoadThis();              // "this" as Object obj
            mg.Push(propertyInfo.Name); // String propertyName
            mg.LoadLocal(loc_oldValue);
            if (loc_newValue != null)
            {
                mg.LoadLocal(loc_newValue);
            }
            else
            {
                mg.LoadArg(0);
            }
            mg.InvokeVirtual(m_hasPropertyChanged);
            //// if (!result)
            //// { return; }
            mg.IfZCmp(CompareOperator.EQ, l_finish);

            mg.Mark(l_noChangeCheck);
            // call firePropertyChange on this
            mg.LoadThis();
            // propertyChangeSupport
            mg.GetThisField(f_propertyChangeSupport);
            // property
            mg.CallThisGetter(p_getterMethodHandle);
            // oldValue
            mg.LoadLocal(loc_oldValue);
            if (!isBoxingNeededForHasPropertyChanged && propertyType.IsValueType)
            {
                // old value has not already been boxed but it is now necessary
                mg.ValueOf(propertyType);
            }
            // newValue
            if (loc_newValue != null)
            {
                mg.LoadLocal(loc_newValue);
            }
            else
            {
                mg.LoadArg(0);
                if (propertyType.IsValueType)
                {
                    mg.ValueOf(propertyType);
                }
            }
            // firePropertyChange(propertyChangeSupport, property, oldValue, newValue)
            mg.InvokeVirtual(m_firePropertyChange);

            // return
            mg.Mark(l_finish);
            mg.ReturnVoidOrThis();
            mg.EndMethod();
        }
Esempio n. 27
0
 public override void PutThisField(FieldInstance field, Script script)
 {
     throw new NotImplementedException();
 }
Esempio n. 28
0
        protected MethodInstance ImplementUsePropertyChangeSupport(PropertyInstance p_propertyChangeTemplate, FieldInstance f_propertyChangeSupport)
        {
            MethodInstance m_getPropertyChangeSupport = MethodInstance.FindByTemplate(template_m_usePropertyChangeSupport, true);

            if (m_getPropertyChangeSupport == null)
            {
                // create field that holds propertyChangeSupport
                f_propertyChangeSupport = ImplementField(f_propertyChangeSupport);
                IMethodVisitor mg = VisitMethod(template_m_usePropertyChangeSupport);
                HideFromDebug(mg.Method);
                Label l_pcsValid = mg.NewLabel();
                mg.GetThisField(f_propertyChangeSupport);
                mg.Dup();
                mg.IfNonNull(l_pcsValid);

                mg.Pop(); // remove 2nd null instance from stack caused by previous dup
                mg.PutThisField(f_propertyChangeSupport, delegate(IMethodVisitor mg2)
                {
                    mg.CallThisGetter(p_propertyChangeTemplate);
                    mg.LoadThis();
                    mg.InvokeVirtual(m_newPropertyChangeSupport);
                });
                mg.GetThisField(f_propertyChangeSupport);

                mg.Mark(l_pcsValid);
                mg.ReturnValue(); // return instance already on the stack by both branches
                mg.EndMethod();

                m_getPropertyChangeSupport = mg.Method;
            }
            return(m_getPropertyChangeSupport);
        }
Esempio n. 29
0
 bool ILDtkValueParser.TypeName(FieldInstance instance) => instance.IsBool;
Esempio n. 30
0
        protected PropertyInstance ImplementNotifyPropertyChangedSource(PropertyInstance p_propertyChangeTemplate,
                                                                        FieldInstance f_propertyChangeSupport)
        {
            MethodInstance m_onPropertyChanged_Values = MethodInstance.FindByTemplate(template_m_onPropertyChanged_Values, true);

            if (m_onPropertyChanged_Values == null)
            {
                IMethodVisitor mv = VisitMethod(template_m_onPropertyChanged_Values);
                mv.CallThisGetter(p_propertyChangeTemplate);
                mv.LoadThis();
                mv.GetThisField(f_propertyChangeSupport);

                // getMethodHandle(sender, propertyName)
                mv.CallThisGetter(p_propertyChangeTemplate);
                mv.LoadThis();
                mv.LoadArg(0);
                mv.InvokeVirtual(m_getMethodHandle);

                mv.LoadArg(1);
                mv.LoadArg(2);
                // firePropertyChange(sender, propertyChangeSupport, property, oldValue, newValue)
                mv.InvokeVirtual(m_firePropertyChange);
                mv.PopIfReturnValue(m_firePropertyChange);
                mv.ReturnVoidOrThis();
                mv.EndMethod();
                m_onPropertyChanged_Values = mv.Method;
            }
            MethodInstance m_onPropertyChanged = MethodInstance.FindByTemplate(template_m_onPropertyChanged, true);

            if (m_onPropertyChanged == null)
            {
                IMethodVisitor mv = VisitMethod(template_m_onPropertyChanged);
                mv.LoadThis();
                mv.LoadArg(0);
                mv.PushNull();
                mv.PushNull();
                mv.InvokeVirtual(m_onPropertyChanged_Values);
                mv.PopIfReturnValue(m_onPropertyChanged_Values);
                mv.ReturnVoidOrThis();
                mv.EndMethod();
                m_onPropertyChanged = mv.Method;
            }
            PropertyInstance p_pceHandlers = PropertyInstance.FindByTemplate(p_propertyChangeSupport, true);

            if (p_pceHandlers == null)
            {
                HideFromDebug(ImplementGetter(p_propertyChangeSupport.Getter, f_propertyChangeSupport));
                p_pceHandlers = PropertyInstance.FindByTemplate(p_propertyChangeSupport, false);
            }
            if (EmbeddedEnhancementHint.HasMemberPath(State.Context))
            {
                PropertyInstance p_parentEntity = EmbeddedTypeVisitor.GetParentObjectProperty(this);
                if (MethodInstance.FindByTemplate(p_parentChildEventHandler.Getter, true) == null)
                {
                    IMethodVisitor mv = VisitMethod(p_parentChildEventHandler.Getter);
                    mv.CallThisGetter(p_parentEntity);
                    mv.InvokeInterface(p_parentChildEventHandler.Getter);
                    mv.ReturnValue();
                    mv.EndMethod();
                    HideFromDebug(mv.Method);
                }
                if (MethodInstance.FindByTemplate(p_collectionEventHandler.Getter, true) == null)
                {
                    IMethodVisitor mv = VisitMethod(p_collectionEventHandler.Getter);
                    mv.CallThisGetter(p_parentEntity);
                    mv.InvokeInterface(p_collectionEventHandler.Getter);
                    mv.ReturnValue();
                    mv.EndMethod();
                    HideFromDebug(mv.Method);
                }
            }
            else
            {
                if (MethodInstance.FindByTemplate(p_parentChildEventHandler.Getter, true) == null)
                {
                    HideFromDebug(ImplementLazyInitProperty(p_parentChildEventHandler, delegate(IMethodVisitor mv)
                    {
                        MethodInstance method = new MethodInstance(null, typeof(NotifyPropertyChangedClassVisitor), typeof(PropertyChangedEventHandler), "CreateParentChildEventHandler", typeof(Object));
                        mv.LoadThis();
                        mv.InvokeStatic(method);
                    }));
                }
                if (MethodInstance.FindByTemplate(p_collectionEventHandler.Getter, true) == null)
                {
                    HideFromDebug(ImplementLazyInitProperty(p_collectionEventHandler, delegate(IMethodVisitor mv)
                    {
                        MethodInstance method = new MethodInstance(null, typeof(NotifyPropertyChangedClassVisitor), typeof(NotifyCollectionChangedEventHandler), "CreateCollectionEventHandler", typeof(Object));
                        mv.LoadThis();
                        mv.InvokeStatic(method);
                    }));
                }
            }

            //MethodAttributes ma = MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig;
            //{
            //    ConstructorInfo pceaCI = typeof(PropertyChangedEventArgs).GetConstructor(new Type[] { typeof(String) });

            //    MethodBuilder mb = VisitorUtil.DefineMethod(vs, onPropertyChangedMI_string, ma);
            //    ILGenerator gen = mb.GetILGenerator();
            //    gen.Emit(OpCodes.Ldarg_0);
            //    gen.Emit(OpCodes.Ldarg_1);
            //    gen.Emit(OpCodes.Newobj, pceaCI);
            //    gen.Emit(OpCodes.Call, onPropertyChangedMI_pceArg);
            //    gen.Emit(OpCodes.Ret);
            //}
            //{
            //    MethodBuilder mb = VisitorUtil.DefineMethod(vs, onPropertyChangedMI_pceArg, ma);
            //    ILGenerator gen = mb.GetILGenerator();
            //    gen.Emit(OpCodes.Ldarg_0);
            //    gen.Emit(OpCodes.Call, pctPI.GetGetMethod());
            //    gen.Emit(OpCodes.Ldarg_0);
            //    gen.Emit(OpCodes.Ldarg_1);
            //    gen.Emit(OpCodes.Call, FirePropertyChangedMI);
            //    gen.Emit(OpCodes.Ret);
            //}
            //    List<PropertyChangedEventHandler> PropertyChangedEventHandlers { get; }

            //void OnPropertyChanged(String propertyName);

            //void OnPropertyChanged(PropertyChangedEventArgs args);
            return(p_pceHandlers);
        }
Esempio n. 31
0
 public void RemoveInstance(FieldInstance instance)
 {
     removeTemp.Add(instance);
     instance.RemoveOverlapEvent();
 }
Esempio n. 32
0
    public FieldInstance FindForward(FieldInstance self, E_OverlapEvent overlapEvent)
    {
        SearchCondition condition = delegate(FieldInstance sample, ref bool stopSearch)
        {
            if (sample.ToLeft != self.ToLeft)
            {
                if (sample.overlapEvent == overlapEvent)
                {
                    return true;
                }
            }
            return false;
        };

        return Find(self, condition, self.ToLeft);
    }
Esempio n. 33
0
    private static void AdjustContactLine(FieldInstance[] conflicts)
    {
        List<FieldInstance> paused = new List<FieldInstance>();
        List<FieldInstance> stopped = new List<FieldInstance>();

        foreach (var entity in conflicts)
        {
            if (entity.IsMovementStopped())
            {
                stopped.Add(entity);
            }
            else if (entity.IsMovementPaused() && !(entity is Projectile))
            {
                paused.Add(entity);
            }
        }

        if (paused.Count == 0)
        {
            // do nothing
            return;
        }
        else if (paused.Count == 1 && stopped.Count == 1)
        {
            paused[0].Move(new Vector2(stopped[0].PosX - paused[0].PosX, 0));
        }
        else if (paused.Count == 2)
        {
            Debug.LogError("not implemented");
        }
    }
Esempio n. 34
0
 IEnumerable<FieldInstance> FindAll(FieldInstance start, SearchCondition condition, bool toLeft)
 {
     List<FieldInstance> ret = new List<FieldInstance>();
     LinkedListNode<FieldInstance> curr = fieldList.Find(start);
     while (curr != null)
     {
         bool stopSearch = false;
         if (condition(curr.Value, ref stopSearch))
         {
             ret.Add(curr.Value);
         }
         if (stopSearch)
         {
             break;
         }
         curr = toLeft ? curr.Previous : curr.Next;
     }
     return ret;
 }
Esempio n. 35
0
    public IEnumerable<FieldInstance> FindContacts(FieldInstance self, E_OverlapEvent overlapEvent)
    {
        SearchCondition condition = delegate(FieldInstance sample, ref bool stopSearch)
        {
            if (sample.PosX == self.PosX)
            {
                if (sample.ToLeft != self.ToLeft)
                {
                    if (sample.overlapEvent == overlapEvent)
                    {
                        return true;
                    }
                }
            }
            else
            {
                stopSearch = true;
            }
            return false;
        };

        List<FieldInstance> ret = new List<FieldInstance>();
        ret.AddRange(FindAll(self, condition, true));
        ret.AddRange(FindAll(self, condition, false));
        return ret;
    }
Esempio n. 36
0
    public override void OnCollisionDisappear(FieldInstance instance)
    {
        base.OnCollisionDisappear(instance);

        FSMEvent("OnCollisionDisappear");
    }
Esempio n. 37
0
 FieldInstance Find(FieldInstance start, SearchCondition condition, bool toLeft)
 {
     LinkedListNode<FieldInstance> curr = fieldList.Find(start);
     while (curr != null)
     {
         bool stopSearch = false;
         if (condition(curr.Value, ref stopSearch))
         {
             return curr.Value;
         }
         if (stopSearch)
         {
             break;
         }
         curr = toLeft ? curr.Previous : curr.Next;
     }
     return null;
 }
Esempio n. 38
0
 public FieldItem(FieldInstance parent, ItemCommand item)
     : base(E_OverlapEvent.Trigger, 1, 1, WorldAnchor.BottomLeft)
 {
     this.item = item;
 }
Esempio n. 39
0
 public FieldWrapper(FieldInstance baseInstance) : base(baseInstance.Info)
 {
     BaseInstance = baseInstance;
 }
Esempio n. 40
0
 protected virtual void OnHit(FieldInstance instance)
 {
 }
Esempio n. 41
0
    public override void OnCollision(FieldInstance instance)
    {
        base.OnCollision(instance);

        if (!isBattleStarted)
        {
            if (objectMonster.MonsterReactType == E_MonsterReactType.Hostile)
            {
                StartBattle();
            }
        }
    }
Esempio n. 42
0
        protected void ImplementRelationGetter(String propertyName, MethodInstance m_getMethod_template, MethodInstance m_setMethod, int relationIndex,
                                               PropertyInstance p_valueHolderContainerTemplate, PropertyInstance p_targetCache, PropertyInstance p_relationMembers, FieldInstance f_initialized,
                                               FieldInstance f_objRefs)
        {
            // public String getPropertyName()
            // {
            // if (!PropertyName$initialized)
            // {
            // setPropertyName(RelationsGetterVisitor.valueHolderContainer_getValue(this, $relationMembers, get__IndexOfPropertyName(), $targetCache, $beanContext,
            // propertyName$objRefs));
            // }
            // return super.getPropertyName();
            // }
            Script script_getVHC;

            if (EmbeddedEnhancementHint.HasMemberPath(State.Context))
            {
                PropertyInstance p_rootEntity = EmbeddedTypeVisitor.GetRootEntityProperty(this);
                script_getVHC = delegate(IMethodVisitor mv)
                {
                    mv.CallThisGetter(p_rootEntity);
                };
            }
            else
            {
                script_getVHC = delegate(IMethodVisitor mv)
                {
                    // this
                    mv.LoadThis();
                };
            }

            MethodInstance m_getMethod;
            {
                PropertyInstance p_cacheModification = SetCacheModificationMethodCreator.GetCacheModificationPI(this);
                MethodInstance   m_getMethod_scoped  = new MethodInstance(State.NewType,
                                                                          MethodAttributes.HideBySig | MethodAttributes.Private | MethodAttributes.Final, NewType.VOID_TYPE, propertyName + "$DoInitialize");
                {
                    IMethodVisitor mg = VisitMethod(m_getMethod_scoped);

                    // this => for this.setPropertyName(...)
                    mg.LoadThis();
                    // call template.getValue(..)
                    mg.CallThisGetter(p_valueHolderContainerTemplate);
                    // getVhc()
                    script_getVHC.Invoke(mg);
                    // $relationMembers
                    mg.CallThisGetter(p_relationMembers);
                    // get__IndexOfPropertyName()
                    mg.Push(relationIndex);
                    // $targetCache
                    mg.CallThisGetter(p_targetCache);
                    // propertyName$objRefs
                    mg.GetThisField(f_objRefs);
                    mg.InvokeVirtual(m_template_getValue);
                    mg.CheckCast(m_setMethod.Parameters[0].Type);
                    mg.InvokeVirtual(m_setMethod);
                    mg.ReturnValue();
                    mg.EndMethod();
                }
                {
                    IMethodVisitor mg = base.VisitMethod(m_getMethod_template);
                    m_getMethod = mg.Method;
                    HideFromDebug(m_getMethod);
                    Label l_initialized = mg.NewLabel();
                    mg.GetThisField(f_initialized);
                    mg.PushEnum(ValueHolderState.INIT);
                    mg.IfCmp(typeof(ValueHolderState), CompareOperator.EQ, l_initialized);

                    SetCacheModificationMethodCreator.CacheModificationInternalUpdate(p_cacheModification, mg,
                                                                                      delegate(IMethodVisitor mv2)
                    {
                        mv2.LoadThis();
                        mv2.InvokeOnExactOwner(m_getMethod_scoped);
                    });

                    mg.Mark(l_initialized);
                    mg.LoadThis();
                    mg.InvokeSuperOfCurrentMethod();
                    mg.ReturnValue();
                    mg.EndMethod();
                }
            }

            // public String getPropertyName$NoInit()
            // {
            // return super.getPropertyName();
            // }
            {
                MethodInstance   m_getNoInit = m_getMethod_template.DeriveName(ValueHolderIEC.GetGetterNameOfRelationPropertyWithNoInit(propertyName));
                IMethodVisitor   mg          = base.VisitMethod(m_getNoInit);
                PropertyInstance p_getNoInit = PropertyInstance.FindByTemplate(propertyName + ValueHolderIEC.GetNoInitSuffix(), m_getNoInit.ReturnType, false);
                p_getNoInit.AddAnnotation(c_fireThisOPC, propertyName);
                p_getNoInit.AddAnnotation(c_fireTargetOPC, propertyName);
                mg.LoadThis();
                mg.InvokeSuper(m_getMethod);
                mg.ReturnValue();
                mg.EndMethod();
            }
        }
Esempio n. 43
0
    public override void OnCollision(FieldInstance instance)
    {
        base.OnCollision(instance);

        if (objectProjectile.ExplosionVFX > 0)
        {
            Vector2 offset = Rect.point - instance.Rect.point;
            if (instance.ToLeft)
            {
                offset.x -= instance.Rect.width / 2;
            }
            else
            {
                offset.x += instance.Rect.width / 2;
            }
            offset.y += Rect.height / 2;

            Vector3 offset3d = offset;
            offset3d.z = -0.5f;

            ResourceVFX effect = TableLoader.GetTable<ResourceVFX>().Get(objectProjectile.ExplosionVFX);
            GameObject child = RecycleManager.Instance.Instantiate(effect.Resource);
            instance.AttachChild(child, "BC", offset3d);
        }

        if (objectProjectile.ImpactType == E_ImpactType.Destroy)
        {
            Remove();
        }
        else
        {
            float speedX = Mathf.Abs(Velocity.x);
            float velY = Velocity.y;
            float speedReductionRatio = Random.Range(objectProjectile.MinimumSpeedReduction, objectProjectile.MaximumSpeedReduction);
            float bounceSpeedRatio = Mathf.Max(0, 1 - speedReductionRatio);

            var movement = VectorGenerator.Custom(speedX * bounceSpeedRatio, velY * bounceSpeedRatio, objectProjectile.FallingGravity, !ToLeft);
            if (!instance.IsMovementPaused())
            {
                Vector2 targetVel = instance.Velocity;
                if (targetVel != Vector2.zero)
                {
                    movement.Add(new LinearVelocity(targetVel));
                }
            }
            SetMove(movement);
            ChangeMotion("bounce");
        }
    }
Esempio n. 44
0
        protected void ImplementRelationSetter(String propertyName, MethodInstance m_set_template, FieldInstance f_initialized, FieldInstance f_objRefs)
        {
            // public void setPropertyName(String propertyName)
            // {
            // PropertyName$initialized = true;
            // PropertyName$objRefs = null;
            // super.setPropertyName(propertyName);
            // }
            MethodInstance m_set;
            {
                IMethodVisitor mg = base.VisitMethod(m_set_template);
                m_set = mg.Method;
                mg.PutThisField(f_initialized, delegate(IMethodVisitor mv2)
                {
                    mg.PushEnum(ValueHolderState.INIT);
                });
                mg.PutThisField(f_objRefs, delegate(IMethodVisitor mv2)
                {
                    mv2.PushNull();
                });
                mg.LoadThis();
                mg.LoadArgs();
                mg.InvokeSuperOfCurrentMethod();
                mg.ReturnVoidOrThis();
                mg.EndMethod();
            }

            // public void setPropertyName$NoInit(String propertyName)
            // {
            // super.setPropertyName(propertyName);
            // }
            {
                String         noInitSetMethodName = ValueHolderIEC.GetSetterNameOfRelationPropertyWithNoInit(propertyName);
                IMethodVisitor mv = base.VisitMethod(m_set.Access, noInitSetMethodName, m_set.ReturnType, m_set.Parameters);
                mv.LoadThis();
                mv.LoadArgs();
                mv.InvokeSuper(m_set);
                mv.ReturnVoidOrThis();
                mv.EndMethod();
            }
        }
Esempio n. 45
0
 private object GetSingle(FieldInstance fieldInstance)
 {
     return(GetParsedValue(fieldInstance, fieldInstance.Value));
 }
Esempio n. 46
0
        protected void ImplementConstructors()
        {
            if (metaData.RelationMembers.Length == 0)
            {
                return;
            }
            RelationMember[]       relationMembers = metaData.RelationMembers;
            List <FieldInstance[]> fieldsList      = new List <FieldInstance[]>();

            for (int a = relationMembers.Length; a-- > 0;)
            {
                RelationMember relationMember = relationMembers[a];
                relationMember = (RelationMember)GetApplicableMember(relationMember);
                if (relationMember == null)
                {
                    // member is handled in another type
                    continue;
                }
                String        propertyName = relationMember.Name;
                String        fieldName    = ValueHolderIEC.GetObjRefsFieldName(propertyName);
                FieldInstance field        = State.GetAlreadyImplementedField(fieldName);

                String        fieldName2 = ValueHolderIEC.GetInitializedFieldName(propertyName);
                FieldInstance field2     = State.GetAlreadyImplementedField(fieldName2);

                fieldsList.Add(new FieldInstance[] { field, field2 });
            }
            if (fieldsList.Count == 0)
            {
                return;
            }
            PropertyInstance p_emptyRelations = ImplementAssignedReadonlyProperty("EmptyRelations", ObjRef.EMPTY_ARRAY);

            OverrideConstructors(delegate(IClassVisitor cv, ConstructorInstance superConstructor)
            {
                IMethodVisitor mv = cv.VisitMethod(superConstructor);
                mv.LoadThis();
                mv.LoadArgs();
                mv.InvokeSuperOfCurrentMethod();

                LocalVariableInfo loc_emptyRelations = mv.NewLocal <IObjRef[]>();
                LocalVariableInfo loc_lazyState      = mv.NewLocal <ValueHolderState>();
                mv.CallThisGetter(p_emptyRelations);
                mv.StoreLocal(loc_emptyRelations);
                mv.PushEnum(ValueHolderState.LAZY);
                mv.StoreLocal(loc_lazyState);
                foreach (FieldInstance[] fields in fieldsList)
                {
                    mv.PutThisField(fields[0], delegate(IMethodVisitor mv2)
                    {
                        mv2.LoadLocal(loc_emptyRelations);
                    });
                    mv.PutThisField(fields[1], delegate(IMethodVisitor mv2)
                    {
                        mv2.LoadLocal(loc_lazyState);
                    });
                }
                mv.ReturnValue();
                mv.EndMethod();
            });
        }