private void Start()
{
effect = new WeatherMakerFullScreenEffect
{
CommandBufferName = commandBufferName,
DownsampleRenderBufferTextureName = "_MainTex2",
RenderQueue = OverlayRenderQueue
};
updateShaderPropertiesAction = UpdateShaderProperties;
#if UNITY_EDITOR
if (Application.isPlaying)
{
#endif
// clone during play mode so as to not overwrite profile properties inadvertantly
if (OverlayProfile != null)
{
OverlayProfile = ScriptableObject.Instantiate(OverlayProfile);
}
if (OverlayBlurMaterial != null)
{
OverlayBlurMaterial = new Material(OverlayBlurMaterial);
}
#if UNITY_EDITOR
}
#endif
}
/// <summary>
/// TreeViewControl overrides for our custom logos
/// </summary>
public override void AssignDefaults()
{
base.AssignDefaults();
string tempWwisePath = "Assets/Wwise/Editor/WwiseWindows/TreeViewControl/";
m_textureWwiseAuxBusIcon = GetTexture(tempWwisePath + "auxbus_nor.png");
m_textureWwiseBusIcon = GetTexture(tempWwisePath + "bus_nor.png");
m_textureWwiseEventIcon = GetTexture(tempWwisePath + "event_nor.png");
m_textureWwiseFolderIcon = GetTexture(tempWwisePath + "folder_nor.png");
m_textureWwisePhysicalFolderIcon = GetTexture(tempWwisePath + "physical_folder_nor.png");
m_textureWwiseProjectIcon = GetTexture(tempWwisePath + "wproj.png");
m_textureWwiseSoundbankIcon = GetTexture(tempWwisePath + "soundbank_nor.png");
m_textureWwiseStateIcon = GetTexture(tempWwisePath + "state_nor.png");
m_textureWwiseStateGroupIcon = GetTexture(tempWwisePath + "stategroup_nor.png");
m_textureWwiseSwitchIcon = GetTexture(tempWwisePath + "switch_nor.png");
m_textureWwiseSwitchGroupIcon = GetTexture(tempWwisePath + "switchgroup_nor.png");
m_textureWwiseWorkUnitIcon = GetTexture(tempWwisePath + "workunit_nor.png");
if (m_filterBoxStyle == null)
{
GUISkin InspectorSkin = ScriptableObject.Instantiate(EditorGUIUtility.GetBuiltinSkin(EditorSkin.Inspector)) as GUISkin;
InspectorSkin.hideFlags = HideFlags.HideAndDontSave;
m_filterBoxStyle = InspectorSkin.FindStyle("SearchTextField");
m_filterBoxCancelButtonStyle = InspectorSkin.FindStyle("SearchCancelButton");
}
}
public void Initialize(AIRuntimeController controller)
{
this.owner = controller;
queueActions = new List <BaseAction> ();
updateActions = new List <BaseAction> ();
for (int i = 0; i < actions.Count; i++)
{
actions[i] = (BaseAction)ScriptableObject.Instantiate(actions[i]);
actions[i].owner = owner;
actions[i].OnAwake();
if (actions[i].queue)
{
queueActions.Add(actions[i]);
}
else
{
updateActions.Add(actions[i]);
}
}
for (int k = 0; k < transitions.Count; k++)
{
transitions[k] = (BaseTransition)ScriptableObject.Instantiate(transitions[k]);
for (int i = 0; i < transitions[k].conditions.Count; i++)
{
transitions[k].conditions[i] = (BaseCondition)ScriptableObject.Instantiate(transitions[k].conditions[i]);
transitions[k].conditions[i].owner = owner;
}
transitions[k].owner = owner;
}
this.DoAwake();
}
public EnemyCharacter CreateEnemy(EncountEnemy encountEnemy)
{
//EnemyDataの値を書き換えないようにするためコピーしたものを使います
EnemyData enemyData = ScriptableObject.Instantiate(encountEnemy.enemy);
int pos = encountEnemy.posiiton;
GameObject enemy = Instantiate(enemyEntity);
enemy.transform.position = enemyPos[pos];
//グラフィックの設定
SpriteRenderer sprite = enemy.GetComponent <SpriteRenderer>();
sprite.sprite = enemyData.Graphic;
//ステータスの設定
EnemyCharacter enemyCharacter = enemy.GetComponent <EnemyCharacter>();
enemyCharacter.enemyData = enemyData;
enemyCharacter.Initialize(enemyData.Status);
//名前の設定
enemyCharacter.CharacterName = enemyCharacter.enemyData.CharacterName;
enemyCharacter.gameObject.name = enemyCharacter.CharacterName;
enemyCharacter.gameObject.transform.SetParent(gameObject.transform);
return(enemyCharacter);
}
private Object CreateObj()
{
if (obj is GameObject)
{
GameObject o = (GameObject)UnityEngine.Object.Instantiate((GameObject)obj);
o.transform.SetParent(poolParent);
if (createHandler != null)
{
createHandler(o);
}
return(o);
}
else if (obj is ScriptableObject)
{
ScriptableObject o = ScriptableObject.Instantiate(obj) as ScriptableObject;
if (createHandler != null)
{
createHandler(o);
}
return(o);
}
else
{
lhDebug.LogWarning((object)"obj is dont GameObject ");
return(null);
}
}
private void AddItemByPrototype(ScriptableObject prototype)
{
Assert.IsNotNull(prototype);
var asset = ScriptableObject.Instantiate(prototype);
AddItemInternal(asset);
}
public void OnEnable()
{
if (Inventory != null)
{
Inventory = ScriptableObject.Instantiate <Inventory>(Inventory);
}
}
public void Update()
{
if (state == STATE.LoadComplete)
{
ImgData d = AssetDatabase.LoadAssetAtPath(ASSETS_PATH, typeof(ImgData)) as ImgData;
ImgData newd = ScriptableObject.Instantiate(d) as ImgData;
newd.hideFlags = HideFlags.DontSave;
newd.imgs = items;
newd.hideFlags = 0;
AssetDatabase.CreateAsset(newd, ASSETS_PATH);
AssetDatabase.SaveAssets();
state = STATE.NONE;
if (callback != null)
{
callback(textureBytes);
}
}
if (maxCount != -1)
{
random = UnityEngine.Random.Range(0, maxCount);
maxCount = -1;
}
}
public void Initialize(AbilitySet _as)
{
currentlyTicking = new List <Ability>();
passives = new List <Ability>();
abilitySet = _as;
attack = ScriptableObject.Instantiate(abilitySet.attack);
ability1 = ScriptableObject.Instantiate(abilitySet.ability1);
ability2 = ScriptableObject.Instantiate(abilitySet.ability2);
ability3 = ScriptableObject.Instantiate(abilitySet.ability3);
foreach (Ability a in abilitySet.passiveEffects)
{
if (a.isPassive)
{
passives.Add(ScriptableObject.Instantiate(a));
}
else
{
Debug.Log("Non-passive ability added to passive ability list of " + abilitySet.name);
}
}
attack.Initialize(this);
ability1.Initialize(this);
ability2.Initialize(this);
ability3.Initialize(this);
foreach (Ability a in passives)
{
a.Initialize(this);
currentlyTicking.Add(a);
}
initializedEvent(ability1, ability2, ability3, attack);
}
public static void CombineSelected()
{
var selected = Selection.GetFiltered(typeof(UnityEngine.Object), SelectionMode.Assets);
string directory = Path.GetDirectoryName(AssetDatabase.GetAssetPath(selected[0]));
string parentPath = Path.Combine(directory, "New Parent.asset");
EmptySO emptySoParent = ScriptableObject.CreateInstance <EmptySO>();
AssetDatabase.CreateAsset(emptySoParent, parentPath);
List <Object> objects = new List <Object>();
for (var i = 0; i < selected.Length; i++)
{
objects.Add(ScriptableObject.Instantiate(selected[i]));
AssetDatabase.DeleteAsset(AssetDatabase.GetAssetPath(selected[i]));
}
AssetDatabase.SaveAssets();
var parent = AssetDatabase.LoadAssetAtPath <EmptySO>(parentPath);
for (var i = 0; i < objects.Count; i++)
{
AssetDatabase.AddObjectToAsset(objects[i], parent);
}
// AssetDatabase.AddObjectToAsset(ScriptableObject.CreateInstance<EmptySO>(), parent);
AssetDatabase.SaveAssets();
}
public EnemyStats GenerateEnemyStats(EnemyType type)
{
EnemyStats stats = ScriptableObject.CreateInstance <EnemyStats>();
int weaponCount = 1;
List <WeaponStats> weaponPool;
if (WeaponPoolSet.TryGetWeaponPool(weaponPoolDict, type, out weaponPool))
{
List <WeaponStats> enemyWeaponList = new List <WeaponStats>();
for (int i = 0; i < weaponCount; i++)
{
//copy scriptableobject in dict so the original doesn't change at runtime
enemyWeaponList.Add(ScriptableObject.Instantiate(weaponPool[UnityEngine.Random.Range(0, weaponPool.Count)]));
}
stats.weapons = enemyWeaponList;
switch (type)
{
case EnemyType.Ranged:
stats.MaxHealth = UnityEngine.Random.Range(RangedMinRange, RangedMaxRange);
break;
case EnemyType.Melee:
stats.MaxHealth = UnityEngine.Random.Range(RangedMinRange, RangedMaxRange);
break;
case EnemyType.Sniper:
stats.MaxHealth = UnityEngine.Random.Range(RangedMinRange, RangedMaxRange);
break;
}
}
return(stats);
}
public override bool Use(Player player)
{
StatusEffect temp = ScriptableObject.Instantiate(effect);
temp.OnApplyEffect(player);
return(base.Use(player));
}
public static T[] CopyExecutableNodes <T>(ExecutableNode[] nodes)
{
List <T> mNodes = new List <T> ();
foreach (ExecutableNode node in nodes)
{
ExecutableNode dest = (ExecutableNode)ScriptableObject.Instantiate(node);
dest.hideFlags = HideFlags.HideInHierarchy;
dest.name = node.name;
FieldInfo[] fields = node.GetType().GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
foreach (FieldInfo field in fields)
{
if (field.FieldType.IsSubclassOf(typeof(FsmVariable)) && field.GetValue(node) == null)
{
FsmVariable variable = (FsmVariable)ScriptableObject.CreateInstance(field.FieldType);
field.SetValue(node, variable);
}
object value = field.GetValue(node);
field.SetValue(dest, CopyFields(value));
}
mNodes.Add((T)(object)dest);
}
return(mNodes.ToArray());
}
/// <summary>Find an old State and replace it for a new one at RunTime </summary>
public void State_Replace(State NewState)
{
if (CloneStates)
{
State instance = (State)ScriptableObject.CreateInstance(NewState.GetType());
instance = ScriptableObject.Instantiate(NewState); //Create a clone from the Original Scriptable Objects! IMPORTANT
instance.name = instance.name.Replace("(Clone)", "(C)");
NewState = instance;
}
var oldState = states.Find(s => s.ID == NewState.ID);
if (oldState)
{
var index = states.IndexOf(oldState);
var oldStatePriority = oldState.Priority;
if (CloneStates)
{
Destroy(oldState); //Destroy the Clone
}
oldState = NewState;
oldState.SetAnimal(this);
oldState.Priority = oldStatePriority;
oldState.AwakeState();
oldState.InitializeState();
oldState.ExitState();
states[index] = oldState; //Replace the list Item
UpdateInputSource(); //Need to Update the Sources
}
}
private void TurnLeft()
{
TeteriminoData tmpData = ScriptableObject.Instantiate <TeteriminoData>(data);
tmpData.TurnLeft();
for (int x = 0; x < tmpData.size; ++x)
{
for (int y = 0; y < tmpData.size; ++y)
{
if (!tmpData.actual[x, y])
{
continue;
}
if (matrix.cells[x + xPos, y + Mathf.CeilToInt(offset)].hasBlock)
{
return;
}
if (matrix.cells[x + xPos, y + Mathf.CeilToInt(offset) - 1].hasBlock)
{
return;
}
}
}
data.TurnLeft();
}
public void InitRuntimeEventList()
{
if (eventList.Length == 0)
{
return;
}
if (runtimeEventList != null && runtimeEventList.Count > 0)
{
object[] ges = runtimeEventList.ToArray();
foreach (object ge in ges)
{
GameEvent cge = ge as GameEvent;
ScriptableObject.Destroy(cge);
}
runtimeEventList.Clear();
}
else
{
runtimeEventList = new ArrayList();
}
for (int i = 0; i < eventList.Length; i++)
{
GameEvent newge = (GameEvent)(ScriptableObject.Instantiate(eventList [i]));
newge.setOwner(this);
runtimeEventList.Add(newge);
}
}
public void RestorePreset(GrassTextureDataPreset _preset)
{
GrassTextureDataPreset preset = ScriptableObject.Instantiate(_preset) as GrassTextureDataPreset;
NewSourceTextures();
GrassTextureData.numSlices = preset.numSlices;
GrassTextureData.numSourceBladesPerSlice = preset.numSourceBladesPerSlice;
GrassTextureData.numSourceBladesOnBackground = preset.numSourceBladesOnBackground;
GrassTextureData.sliceHeight = preset.sliceHeight;
GrassTextureData.textureWidth = preset.textureWidth;
GrassTextureData.BackColor = preset.BackColor;
GrassTextureData.randomSeed = preset.randomSeed;
GrassTextureData.fakeSelfShadowStrength = preset.fakeSelfShadowStrength;
GrassTextureData.randomYOffset = preset.randomYOffset;
// source textures and their properties
GrassTextureData.grassBladesMod = GrassTextureData.grassBlades = preset.grassBlades;
GrassTextureData.grassBladesTints = preset.grassBladesTints;
GrassTextureData.grassBladesSaturations = preset.grassBladesSaturations;
GrassTextureData.grassBladesWeights = preset.grassBladesWeights;
Color grey = new Color(0.5f, 0.5f, 0.5f, 1);
for (int i = 0; i < preset.grassBlades.Length; i++)
{
if (GrassTextureData.grassBladesSaturations[i] != 1 || GrassTextureData.grassBladesTints[i] != grey)
{
MakeTextureMod(i, true);
}
}
}
public override bool OnApplyEffect(Entity effected)
{
if (!base.OnApplyEffect(effected))
{
return(false);
}
foreach (Ability ability in abilitiesGranted)
{
Ability temp = ScriptableObject.Instantiate(ability);
abilities.Add(temp);
temp.OnGainTrigger(effected);
}
EffectedEntity.mStats.AddPrimaryBonuses(statBonuses);
EffectedEntity.mStats.AddSecondaryBonuses(secondaryBonuses);
if (effected is Player player)
{
foreach (WeaponAttributeBonus weaponBonus in weaponBonuses)
{
player.AddWeaponBonus(weaponBonus);
}
}
return(true);
}
private void Initialize()
{
if (WeatherMakerScript.Instance == null)
{
return;
}
if (FogProfile == null)
{
FogProfile = WeatherMakerScript.Instance.LoadResource <T>("WeatherMakerFogProfile_Default");
}
#if UNITY_EDITOR
if (Application.isPlaying)
{
#endif
// clone fog material and profile
if (FogMaterial != null)
{
FogMaterial = new Material(FogMaterial);
}
FogProfile = ScriptableObject.Instantiate(FogProfile);
#if UNITY_EDITOR
}
#endif
}
public static T[] CopyExecutableNodes <T> (ExecutableNode[] nodes, StateMachine root)
{
List <T> mNodes = new List <T> ();
foreach (ExecutableNode node in nodes)
{
if (node == null)
{
Debug.LogWarning("Missing Action " + node.name + " in " + root.Name + "! You may need to enable an integration.");
continue;
}
ExecutableNode dest = (ExecutableNode)ScriptableObject.Instantiate(node);
dest.hideFlags = HideFlags.HideInHierarchy;
dest.name = node.name;
FieldInfo[] fields = node.GetType().GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
foreach (FieldInfo field in fields)
{
if (field.FieldType.IsSubclassOf(typeof(FsmVariable)) && field.GetValue(node) == null)
{
FsmVariable variable = (FsmVariable)ScriptableObject.CreateInstance(field.FieldType);
field.SetValue(node, variable);
}
object value = field.GetValue(node);
field.SetValue(dest, CopyFields(value));
}
mNodes.Add((T)(object)dest);
}
return(mNodes.ToArray());
}
public StatusEffect(StatusEffectScriptableObject data, TickTime tickTime, int duration)
{
this.data = ScriptableObject.Instantiate <StatusEffectScriptableObject>(data);
this.tickTime = tickTime;
durationRemaining = duration;
}
public void SetObjectData(Dictionary <string, object> data)
{
List <object> position = data["Position"] as List <object>;
List <object> rotation = data["Rotation"] as List <object>;
if ((string)data["Type"] != "UI")
{
transform.position = new Vector3(System.Convert.ToSingle(position[0]), System.Convert.ToSingle(position[1]), System.Convert.ToSingle(position[2]));
transform.rotation = Quaternion.Euler(new Vector3(System.Convert.ToSingle(rotation[0]), System.Convert.ToSingle(rotation[1]), System.Convert.ToSingle(rotation[2])));
}
Clear();
ItemContainer container = GetComponent <ItemContainer>();
if (data.ContainsKey("Items"))
{
List <object> mItems = data["Items"] as List <object>;
for (int i = 0; i < mItems.Count; i++)
{
Dictionary <string, object> itemData = mItems[i] as Dictionary <string, object>;
if (itemData != null)
{
List <Item> items = new List <Item>(InventoryManager.Database.items);
items.AddRange(InventoryManager.Database.currencies);
Item item = items.Find(x => x.Name == (string)itemData["Name"]);
if (item != null)
{
Item mItem = (Item)ScriptableObject.Instantiate(item);
mItem.SetObjectData(itemData);
Add(mItem);
this.m_Amounts[i] = 0;
this.m_Modifiers[i].modifiers.Clear();
if (itemData.ContainsKey("Slots") && container != null)
{
List <object> slots = itemData["Slots"] as List <object>;
for (int j = 0; j < slots.Count; j++)
{
int slot = System.Convert.ToInt32(slots[j]);
if (container.Slots.Count > slot)
{
mItem.Slots.Add(container.Slots[slot]);
}
}
}
}
}
}
}
CombineCurrencies();
if (container != null)
{
container.Collection = this;
}
}
static public NPCPrototype GetRandomChar()
{
ValidateDatabase();
NPCPrototype cData = charPrototypes[Random.Range(0, charPrototypes.Count)];
return(ScriptableObject.Instantiate(cData) as NPCPrototype);
}
private void MergeItems()
{
List <Item> items = this.m_Source.items.Where(y => !this.m_Destination.items.Any(z => z.Name == y.Name)).ToList();
for (int i = 0; i < items.Count; i++)
{
Item item = ScriptableObject.Instantiate(items[i]);
item.hideFlags = HideFlags.HideInHierarchy;
AssetDatabase.AddObjectToAsset(item, this.m_Destination);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
this.m_Destination.items.Add(item);
/*if (item is UsableItem) {
* List<ItemAction> actions = (item as UsableItem).actions;
* for (int j = 0; j < actions.Count; j++) {
* ItemAction action = ScriptableObject.Instantiate(actions[j]);
* action.hideFlags = HideFlags.HideInHierarchy;
* AssetDatabase.AddObjectToAsset(action, item);
* AssetDatabase.SaveAssets();
* AssetDatabase.Refresh();
* actions[j] = action;
* EditorUtility.SetDirty(item);
* }
*
* }*/
EditorUtility.SetDirty(this.m_Destination);
}
}
public IList <IAction> GetActualActions(int countOfMoment, Controller controller)
{
IList <IAction> actual = new List <IAction>();
for (int i = 0; i < countOfMoment; ++i)
{
// 攻撃がプロットされているとき
if (Plots.IsActionPloted(i))
{
actual.Add(Plots.ActionPloted(i).Action);
}
// 移動がプロットされているとき
else if (Plots.IsMovePloted(i))
{
Move act = ScriptableObject.Instantiate(Resources.Load <Move>("ScriptableObjects/Actions/Move"));
act.Controller = controller;
act.Direction = Plots.MovePloted(i).MoveDirection;
actual.Add(act);
}
// 移動と攻撃の両方がプロットされていないとき
else
{
NoAction act = ScriptableObject.Instantiate(Resources.Load <NoAction>("ScriptableObjects/Actions/NoAction"));
act.Controller = controller;
actual.Add(act);
}
}
return(actual);
}
//出撃可能エリアにユニットを描画
public void DrawUnit()
{
CharaData loaddata = ScriptableObject.Instantiate(Resources.Load(string.Format("BattleChara/{0}", unit.savescobj)) as CharaData);
unit.gobj = MonoBehaviour.Instantiate(loaddata.gobj, new Vector3(), Quaternion.identity);
foreach (int[] pos in CharaSetup.unitsetposlist)
{
//キャラが居なければ生成
if (!BattleVal.id2index.ContainsKey(string.Format("{0},{1}", pos[0], pos[1])))
{
//描画
Mapclass.DrawCharacter(unit.gobj, pos[0], pos[1]);
unit.gobj.layer = 8;
unit.x = pos[0];
unit.y = pos[1];
//unitlistへの登録
BattleVal.unitlist.Add(unit);
//id2indexへの登録
BattleVal.id2index.Add(string.Format("{0},{1}", pos[0], pos[1]), unit);
////mapdataにユニット情報を登録
BattleVal.mapdata[(int)MapdataList.MAPUNIT][unit.y][unit.x] = 99; //ユニット番号はcsvから読み取るときしか使わないため、1から99なら何でもよい
//足元にチーム識別タイルを
GameObject unittile;
unittile = Instantiate(prefabPlayerTile, unit.gobj.transform);
unittile.transform.localScale = new Vector3(unittile.transform.localScale.x / unittile.transform.lossyScale.x,
0.01f,
unittile.transform.localScale.z / unittile.transform.lossyScale.z);
Mapclass.DrawCharacter(unittile, unit.x, unit.y);
break;
}
}
}
public void Init()
{
var origin = Resources.Load <MasterDataSO>("MasterData/MainMasterData");
Data = ScriptableObject.Instantiate <MasterDataSO>(origin);
Data.Init();
}
/// <summary>
/// Same as with gameObjects in SaveLoader, we lookup originals by guid in Storage, and
/// overwrite those.
/// </summary>
/// <param name="data"></param>
/// <param name="storageType"></param>
/// <returns></returns>
public override object CreateInstance(fsData data, Type storageType)
{
if (!data.IsDictionary)
{
UnityEngine.Debug.LogError("SaveSystem: tried to deserialize scriptable, which data layout was not a dictionary.");
return(0);
}
Dictionary <string, fsData> keyValuePairs = data.AsDictionary;
fsData guidData;
keyValuePairs.TryGetValue("_guid", out guidData);
if (guidData == null || !guidData.IsString)
{
UnityEngine.Debug.LogError("SaveSystem: could not scriptable in database using guid.");
return(0);
}
string guid = guidData.AsString;
SavedScriptable so = SaveLoader.System.FindScriptable(guid);
if (so == null)
{
UnityEngine.Debug.LogError("SaveSystem: scriptable object with such guid was not found.");
return(0);
}
return(ScriptableObject.Instantiate(so));
}
private T GetTempAsset <T>() where T : UnityEngine.Object
{
T thisTempAsset = null;
//we only want the last bit after any assembly
var thisTypeName = typeof(T).ToString().Replace(typeof(T).Namespace + ".", "");
//check RuntimeAnimatorController because these get called different things in the editor and in game
if (typeof(T) == typeof(RuntimeAnimatorController))
{
thisTypeName = "RuntimeAnimatorController";
}
T thisPlaceholder = (T)Resources.Load <T>("PlaceholderAssets/" + thisTypeName + "Placeholder") as T;
if (thisPlaceholder != null) //can we assume if an asset was found its a scriptableobject
{
thisTempAsset = ScriptableObject.Instantiate(thisPlaceholder) as T;
}
else
{
if (typeof(ScriptableObject).IsAssignableFrom(typeof(T)))
{
thisTempAsset = ScriptableObject.CreateInstance(typeof(T)) as T;
}
else
{
thisTempAsset = (T)Activator.CreateInstance(typeof(T));
}
}
return(thisTempAsset);
}
public static void AddBehavior(int _casterPlayer, Unit _target, Behavior _behavior)
{
Hero hero = BattleManager.heroes[_casterPlayer];
//如果已经有该行为，且不能叠加，刷新持续时间。否则添加
Behavior behavior = GetUnitBehavior(_target, _behavior);
if (behavior != null && behavior.maxStackCount == 1)
{
Behavior originBehavior = GetBehavior(behavior.name);
if (originBehavior.duration == 0)
{
behavior.duration = hero.power;
}
else if (originBehavior.duration > 0)
{
behavior.duration = originBehavior.duration;
}
}
else
{
behavior = ScriptableObject.Instantiate(_behavior);
behavior.name = _behavior.name;
//设定持续时间，0则取决于英雄法力
if (behavior.duration == 0)
{
behavior.duration = hero.power;
}
_target.behaviors.Add(behavior);
behavior.Init(_target);
behavior.Add();
}
}
