/// <summary> /// Run once per frame in order to manage the actor /// </summary> protected virtual void Update() { // Process each of the reactors effects for (int i = 0; i < _Reactors.Count; i++) { ReactorAction lReactor = _Reactors[i]; if (lReactor._IsEnabled && lReactor._IsActive) { lReactor.Update(); } } // Process each of the active effects for (int i = 0; i < _Effects.Count; i++) { ActorCoreEffect lEffect = _Effects[i]; bool lIsActive = lEffect.Update(); // If the effect is no longer active, remove it if (!lIsActive) { _Effects.RemoveAt(i); i--; lEffect.Release(); } } }
/// <summary> /// Adds a reactor to the list /// </summary> /// <param name="rReactor">ReactorAction to add</param> public virtual void AddReactor(ReactorAction rReactor) { _Reactors.Add(rReactor); _ReactorDefinitions.Add(rReactor.Serialize()); rReactor.Owner = this.gameObject; rReactor.Awake(); }
/// <summary> /// Allows us to draw each item in the list /// </summary> /// <param name="rRect"></param> /// <param name="rIndex"></param> /// <param name="rIsActive"></param> /// <param name="rIsFocused"></param> private void DrawReactorListItem(Rect rRect, int rIndex, bool rIsActive, bool rIsFocused) { if (rIndex < mTarget._Reactors.Count) { ReactorAction lItem = mTarget._Reactors[rIndex]; if (lItem == null) { EditorGUI.LabelField(rRect, "NULL"); return; } rRect.y += 2; bool lIsDirty = false; float lHSpace = 5f; float lFlexVSpace = rRect.width - lHSpace - lHSpace - 40f - lHSpace - 16f; string lType = BaseNameAttribute.GetName(lItem.GetType()); EditorGUILayout.BeginHorizontal(); Rect lTypeRect = new Rect(rRect.x, rRect.y, lFlexVSpace / 2f, EditorGUIUtility.singleLineHeight); EditorGUI.LabelField(lTypeRect, lType); Rect lNameRect = new Rect(lTypeRect.x + lTypeRect.width + lHSpace, lTypeRect.y, lFlexVSpace / 2f, EditorGUIUtility.singleLineHeight); string lNewName = EditorGUI.TextField(lNameRect, lItem.Name); if (lNewName != lItem.Name) { lIsDirty = true; lItem.Name = lNewName; } Rect lPriorityRect = new Rect(lNameRect.x + lNameRect.width + lHSpace, lNameRect.y, 40f, EditorGUIUtility.singleLineHeight); float lNewPriority = EditorGUI.FloatField(lPriorityRect, lItem.Priority); if (lNewPriority != lItem.Priority) { lIsDirty = true; lItem.Priority = lNewPriority; } Rect lIsEnabledRect = new Rect(lPriorityRect.x + lPriorityRect.width + lHSpace, lPriorityRect.y, 16f, 16f); bool lNewIsEnabled = EditorGUI.Toggle(lIsEnabledRect, lItem.IsEnabled); if (lNewIsEnabled != lItem.IsEnabled) { lIsDirty = true; lItem.IsEnabled = lNewIsEnabled; } EditorGUILayout.EndHorizontal(); // Update the item if there's a change if (lIsDirty) { mIsDirty = true; mTarget._ReactorDefinitions[rIndex] = lItem.Serialize(); } } }
/// <summary> /// Processes the reactor definitions and update the reactors to match the definitions. /// </summary> public void InstantiateReactors() { int lDefCount = _ReactorDefinitions.Count; // First, remove any extra items that may exist for (int i = _Reactors.Count - 1; i >= lDefCount; i--) { _Reactors.RemoveAt(i); } // We need to match the definitions to the item for (int i = 0; i < lDefCount; i++) { string lDefinition = _ReactorDefinitions[i]; Type lType = JSONSerializer.GetType(lDefinition); if (lType == null) { continue; } ReactorAction lReactor = null; // If we don't have an item matching the type, we need to create one if (_Reactors.Count <= i || !lType.Equals(_Reactors[i].GetType())) { lReactor = Activator.CreateInstance(lType) as ReactorAction; lReactor.Owner = this.gameObject; if (_Reactors.Count <= i) { _Reactors.Add(lReactor); } else { _Reactors[i] = lReactor; } } // Grab the matching item else { lReactor = _Reactors[i]; } // Fill the item with data from the definition if (lReactor != null) { lReactor.Deserialize(lDefinition); } } // Allow each item to initialize now that it has been deserialized for (int i = 0; i < _Reactors.Count; i++) { _Reactors[i].Owner = this.gameObject; _Reactors[i].Awake(); } }
// Callbacks public void register_callback(ReactorAction callback, double waketime = NOW) { if (callback == null) { throw new ArgumentNullException(nameof(callback)); } new ReactorCallback(this, callback, waketime); }
/// <summary> /// Occurs after the character has been killed /// </summary> /// <param name="rAction"></param> public void OnKilled(ReactorAction rAction) { if (rAction.Message is CombatMessage) { if (((CombatMessage)rAction.Message).Defender == gameObject) { mActorCore.SetStateValue("State", KILLED); } } }
public void register_async_callback(ReactorAction callback) { _async_queue.Enqueue(callback); try { //os.write(this._pipe_fds[1], "."); } catch { } }
public ReactorTimer register_timer(ReactorAction callback, double waketime = NEVER) { var handler = new ReactorTimer(callback, waketime); lock (_timers) { _timers.Add(handler); _note_time(handler); } return(handler); }
/// <summary> /// Removes the specified reactor from the list /// </summary> /// <param name="rReactor">ReactorAction to remove</param> public virtual void RemoveReactor(ReactorAction rReactor) { for (int i = 0; i < _Reactors.Count; i++) { if (_Reactors[i] == rReactor) { _Reactors.RemoveAt(i); _ReactorDefinitions.RemoveAt(i); return; } } }
/// <summary> /// Renders the currently selected step /// </summary> /// <param name="rStep"></param> private bool DrawReactorDetailItem(ReactorAction rItem) { bool lIsDirty = false; if (rItem == null) { EditorGUILayout.LabelField("NULL"); return(false); } if (rItem.Name.Length > 0) { EditorHelper.DrawSmallTitle(rItem.Name.Length > 0 ? rItem.Name : "Actor Core Reactor"); } else { string lName = BaseNameAttribute.GetName(rItem.GetType()); EditorHelper.DrawSmallTitle(lName.Length > 0 ? lName : "Actor Core Reactor"); } string lDescription = BaseDescriptionAttribute.GetDescription(rItem.GetType()); if (lDescription.Length > 0) { EditorHelper.DrawInspectorDescription(lDescription, MessageType.None); } if (EditorHelper.TextField("Name", "Friendly name of the reactor", rItem.Name, mTarget)) { lIsDirty = true; rItem.Name = EditorHelper.FieldStringValue; } // Render out the Reactor specific inspectors bool lIsReactorDirty = rItem.OnInspectorGUI(mTargetSO, mTarget); if (lIsReactorDirty) { lIsDirty = true; } if (lIsDirty) { mTarget._ReactorDefinitions[mReactorList.index] = rItem.Serialize(); } return(lIsDirty); }
/// <summary> /// Allows us to choose the attack style we'll attack with /// </summary> /// <param name="rAction"></param> public void SelectAttackStyle(ReactorAction rAction) { if (rAction == null || rAction.Message == null) { return; } CombatMessage lCombatMessage = rAction.Message as CombatMessage; if (lCombatMessage == null) { return; } //lCombatMessage.StyleIndex = 2; }
/// <summary> /// Allows us to choose the attack style we'll attack with /// </summary> /// <param name="rAction"></param> public void OnPostAttack(ReactorAction rAction) { mActorCore.SetStateValue("State", IDLE); if (rAction == null || rAction.Message == null) { return; } #if USE_ARCHERY_MP || OOTII_AYMP // Decrease the arrows CombatMessage lCombatMessage = rAction.Message as CombatMessage; if (lCombatMessage.CombatMotion is BasicRangedAttack) { ArrowCount--; } #endif }
/// <summary> /// Allows us to add to a list /// </summary> /// <param name="rList"></param> private void OnReactorListItemAdd(ReorderableList rList) { if (mReactorIndex >= mReactorTypes.Count) { return; } ReactorAction lItem = Activator.CreateInstance(mReactorTypes[mReactorIndex]) as ReactorAction; lItem.Owner = mTarget.gameObject; mTarget._Reactors.Add(lItem); mTarget._ReactorDefinitions.Add(lItem.Serialize()); mReactorList.index = mTarget._Reactors.Count - 1; OnReactorListItemSelect(rList); mIsDirty = true; }
// CDL 08/13/2018 - added this method to streamline the process of setting up reactors via script /// <summary> /// Gets a reactor with a name and type that match and creates a new reactor if no /// match is found /// </summary> /// <typeparam name="T"></typeparam> /// <param name="rName"></param> /// <returns></returns> public virtual T GetOrAddReactor <T>(string rName = null) where T : ReactorAction { ReactorAction lReactor = GetReactor <T>(rName); if (lReactor == null) { lReactor = Activator.CreateInstance(typeof(T)) as ReactorAction; if (lReactor != null) { if (!string.IsNullOrEmpty(rName)) { lReactor.Name = rName; } AddReactor(lReactor); } } return((T)lReactor); }
/// <summary> /// Allows us to choose the attack style we'll attack with /// </summary> /// <param name="rAction"></param> public void OnPreAttack(ReactorAction rAction) { mActorCore.SetStateValue("State", ATTACKING); if (rAction == null || rAction.Message == null) { return; } #if USE_SWORD_SHIELD_MP || OOTII_SSMP // Choose the attack style CombatMessage lCombatMessage = rAction.Message as CombatMessage; if (lCombatMessage == null) { return; } if (lCombatMessage.CombatMotion is BasicMeleeAttack) { //lCombatMessage.StyleIndex = 2; } #endif }
public ReactorCallback(SelectReactor reactor, ReactorAction callback, double waketime) { this.reactor = reactor; this.timer = reactor.register_timer(this.invoke, waketime); this.callback = callback; }
public ReactorTimer(ReactorAction callback, double waketime) { this.callback = callback; this.waketime = waketime; }
/// <summary> /// Processes the reactor definitions and update the reactors to match the definitions. /// </summary> public void InstantiateReactors() { int lDefCount = _ReactorDefinitions.Count; // First, remove any extra items that may exist for (int i = _Reactors.Count - 1; i >= lDefCount; i--) { _Reactors.RemoveAt(i); } // CDL 07/27/2018 - keep track of any invalid reactor definitions List <int> lInvalidDefinitions = new List <int>(); // We need to match the definitions to the item for (int i = 0; i < lDefCount; i++) { string lDefinition = _ReactorDefinitions[i]; JSONNode lDefinitionNode = JSONNode.Parse(lDefinition); if (lDefinitionNode == null) { continue; } string lTypeString = lDefinitionNode["__Type"].Value; // CDL 07/27/2018 - Use AssemblyHelper.ResolveType() intead so that the Type can still // be obtained if the reactor was serialized as belonging to a different assembly bool lUpdateType; Type lType = AssemblyHelper.ResolveType(lTypeString, out lUpdateType); if (lType == null) { // CDL 07/27/2018 - save this definition for removal afterwards, as we can't resolve the Type from any assembly. lInvalidDefinitions.Add(i); continue; } ReactorAction lReactor = null; // If we don't have an item matching the type, we need to create one if (_Reactors.Count <= i || !lType.Equals(_Reactors[i].GetType())) { lReactor = Activator.CreateInstance(lType) as ReactorAction; lReactor.Owner = this.gameObject; if (_Reactors.Count <= i) { _Reactors.Add(lReactor); } else { _Reactors[i] = lReactor; } } // Grab the matching item else { lReactor = _Reactors[i]; } // Fill the item with data from the definition if (lReactor != null) { lReactor.Deserialize(lDefinition); // CDL 07/27/2018 - update the serialized Type if necessary if (lUpdateType) { _ReactorDefinitions[i] = lReactor.Serialize(); } } } // CDL 07/27.2018 - Clean up any invalid Motion Definitions // this is causing an error, but maybe not needed, as I don't think there are // many people who have been using custom reactors //if (lInvalidDefinitions.Count > 0) //{ // for (int i = 0; i < lInvalidDefinitions.Count; i++) // { // int lIndex = lInvalidDefinitions[i]; // _ReactorDefinitions.RemoveAt(lIndex); // } //} // Allow each item to initialize now that it has been deserialized for (int i = 0; i < _Reactors.Count; i++) { _Reactors[i].Owner = this.gameObject; _Reactors[i].Awake(); } }
/// <summary> /// Occurs after the character has been damaged /// </summary> /// <param name="rAction"></param> public void OnDamaged(ReactorAction rAction) { // This is primarily done to clear any block that is up mActorCore.SetStateValue("State", IDLE); }
/// <summary> /// Reports when the weapon style is equipped /// </summary> /// <param name="rAction"></param> public void OnWeaponSetEquipped(ReactorAction rAction) { mActorCore.SetStateValue("State", IDLE); }