Example #1
0
        private List <IAbilityExecutor> ParseAbilityEvent(DataDrivenAbility ability)
        {
            List <IAbilityExecutor> executors = new List <IAbilityExecutor>();

            if (ability.OnTime != null)
            {
                foreach (var command in ability.OnTime)
                {
                    executors.Add(new AbilityTimer(ParseCommands(command), command.startTime));
                }
            }

            if (ability.OnSpellStart != null)
            {
                foreach (var command in ability.OnSpellStart)
                {
                    executors.Add(new AbilityTirgger(ParseCommands(command), AbilityEventTrigger.OnSpellStart));
                }
            }

            if (ability.OnProjectileHitUnit != null)
            {
                foreach (var command in ability.OnProjectileHitUnit)
                {
                    executors.Add(new AbilityTirgger(ParseCommands(command), AbilityEventTrigger.OnProjectileHitUnit));
                }
            }

            return(executors);
        }
    void OnGUI()
    {
        DataDrivenAbility ability = Selection.activeObject as DataDrivenAbility;

        if (ability == null)
        {
            return;
        }

        scrollPos = EditorGUILayout.BeginScrollView(scrollPos);
        GUILayout.Label("Name", EditorStyles.boldLabel);
        ability.abilityData.Name = EditorGUILayout.TextField(ability.abilityData.Name);

        GUILayout.Label("Description", EditorStyles.boldLabel);
        ability.abilityData.Description = EditorGUILayout.TextArea(ability.abilityData.Description, GUILayout.Height(60));

        DrawAttributes(ability);

        DrawEventList(ability.events);

        if (GUILayout.Button("Save"))
        {
            // rename based on the ability's name
            var oldPath  = AssetDatabase.GetAssetPath(ability);
            var fileName = Path.GetFileName(oldPath);
            var newPath  = oldPath.Replace(fileName, ability.abilityData.Name + ".asset");
            AssetDatabase.MoveAsset(oldPath, newPath);
            EditorUtility.SetDirty(ability);
            AssetDatabase.SaveAssets();
            AssetDatabase.Refresh();
        }
        EditorGUILayout.EndScrollView();
    }
Example #3
0
        public AbilityCondition ParseCondition(DataDrivenAbility ability)
        {
            var condition = new AbilityCondition()
            {
                castRange = ability.castRange,
                manaCost  = ability.manaCost
            };

            return(condition);
        }
Example #4
0
    void LoadAbilityData()
    {
        var abilities = Resources.LoadAll <DataDrivenAbility>("Abilities") as DataDrivenAbility[];

        // Debug.Log(abilities.Length);
        for (int i = 0; i < abilities.Length; i++)
        {
            DataDrivenAbility rawAbility = abilities[i];
            // Debug.Log(rawAbility.abilityData.Name);
            Ability ability = DataDrivenAbility.Parse(rawAbility);
            Database[ability.abilityData.Name] = ability;
        }
    }
Example #5
0
        public AbilityRoot Parse(DataDrivenAbility data)
        {
            AbilityRoot root = new AbilityRoot(data.keepTime);

            foreach (var abilityEvent in ParseAbilityEvent(data))
            {
                root.AddAbilityEvent(abilityEvent);
            }

            if (data.modifiers != null)
            {
                foreach (var modifier in data.modifiers)
                {
                    root.modifiers.Add(modifier.name, ParseAbilityModifier(modifier));
                }
            }

            return(root);
        }
Example #6
0
    public static Ability Parse(DataDrivenAbility rawAbility)
    {
        Ability ability = new Ability(rawAbility.abilityData);

        foreach (var abilityEvent in rawAbility.events)
        {
            foreach (var action in abilityEvent.Actions)
            {
                // get the type of action class
                var actionType = System.Type.GetType(action.Type.ToString());
                var actionObj  = (BaseAction)System.Activator.CreateInstance(actionType, action);

                // register the corresponding event callback in ability class
                ability.EventRegister[abilityEvent.Type.ToString()].Add(actionObj);
            }
        }

        return(ability);
    }
    private void DrawAttributes(DataDrivenAbility ability)
    {
        GUILayout.Label("Attributres", EditorStyles.boldLabel);

        ability.abilityData.Icon          = EditorGUILayout.ObjectField("Icon", ability.abilityData.Icon, typeof(Sprite), false) as Sprite;
        ability.abilityData.Price         = EditorGUILayout.IntField("Price", ability.abilityData.Price);
        ability.abilityData.BehaviorFlags = (DataDrivenAbility.BehaviorFlag)EditorGUILayout.EnumFlagsField("Behavior Flags", ability.abilityData.BehaviorFlags);
        ability.abilityData.TargetFlags   = (DataDrivenAbility.TargetFlag)EditorGUILayout.EnumFlagsField("Can Target", ability.abilityData.TargetFlags);
        ability.abilityData.Cooldown      = EditorGUILayout.FloatField("Cooldown", ability.abilityData.Cooldown);
        ability.abilityData.Animation     = EditorGUILayout.TextField("Animation", ability.abilityData.Animation);
        ability.abilityData.AnimCastPoint = EditorGUILayout.FloatField("AnimCastPoint", ability.abilityData.AnimCastPoint);

        if ((ability.abilityData.BehaviorFlags & DataDrivenAbility.BehaviorFlag.CHANNELLED) != 0)
        {
            ability.abilityData.Duration = EditorGUILayout.FloatField("Duration", ability.abilityData.Duration);
        }

        DrawAoeAttributes(ability.abilityData);
    }