Event Manager

じ☆ve冰风

This is a javascript plugin that will not do anything on it's own, but can be useful for other scripters. This script essentially implements an observer pattern into RPG Maker. Event systems help modularize your code by sending messages between pieces of code that do not directly know about each other. They allow things to respond to a change in a state without constantly monitoring it in an update loop. You can read more about it here:
Observer pattern - Wikipedia



                                        en.wikipedia.org                               




This script hasn't been fully optimized and I'm sure there are some things that may not be fully standardized with RPG Makers coding style. It was made in a couple of hours. On every triple a project I've worked on so far, each engine has had one of these, so I wanted to make my own for my internal project. Hopefully this comes in handy for you!

This was made with RPG Maker MV in mind. I have not tested this with RPG Maker MZ, but I don't see much of a reason why this wouldn't work with MZ as well.

I made a small project with a couple of use-case examples! Nothing mind-blowing, but hopefully will provide you with a few ideas to get some ideas across for how it can be used! You can find that project here.

Terms of Use: Free to use or modify for free or commercial projects. My only request is that you don't republish this (or your edits) and claim it as your own. If you want to give credit (not required), please give to Nathan Pringle and specify it was this script in particular.

                JavaScript:       

1. //=============================================================================
2. // EventManager
3. // by Nathan Pringle
4. // Date: 2021-10-11
5. //=============================================================================
6. /*:
7. * @plugindesc Adds event support for internal scripts.
8. * @author Nathan Pringle
9. *
10. * @help
11. * -----------------------------------------------------------------------------
12. * Event systems help modularize your code by sending messages between pieces of
13. * code that do not directly know about each other. They allow things to respond
14. * to a change in a state without constantly monitoring it in an update loop. This is
15. * generally known as an "Observer pattern". You can read more about it here:
16. * https://en.wikipedia.org/wiki/Observer_pattern
17. *
18. * Usage: Free to use or modify for free or commercial projects. My only request
19. * is that you don't republish this (or your edits) and claim it as your own. If
20. * you want to give credit (not required), please give to Nathan Pringle and
21. * specify it was this script in particular.
22. *
23. * -----------------------------------------------------------------------------
24. * Methods Available:
25. * -----------------------------------------------------------------------------
26. * EventManager.StartListening ( string eventName, string methodName, method callbackMethod )
27. *
28. * string eventName: The event you want to listen to. When this event is invoked, the callbackMethod will be called.
29. * string methodName: The string name of the method. This is simply used for lookup. When you stop listening, you will need to provide this string again.
30. * method methodCallback: The method to call when the event is invoked.
31. *
32. * -----------------------------------------------------------------------------
33. * EventManager.StopListening ( string eventName, string methodName )
34. *
35. * string eventName: The name of the event to stop listening to.
36. * string methodName: The string name of the method. This is the same methodName that you used to start listening.
37. *
38. * -----------------------------------------------------------------------------
39. * EventManager.Invoke ( string eventName )
40. *
41. * string eventName: This will call the event. Will call all methods that are listening for this event.
42. *
43. * -----------------------------------------------------------------------------
44. * EventManager.InvokeWithParameter ( string eventName, var parameter )
45. *
46. * string eventName: This will call the event. Will call all methods that are listening for this event.
47. * var parameter: Will pass a single parameter to all methods being invoked.
48. *
49. * -----------------------------------------------------------------------------
50. * EventManager.InvokeAfterTime ( string eventName, float time )
51. *
52. * string eventName: same as above.
53. * float time: how long it will take to call this event, in seconds
54. *
55. * -----------------------------------------------------------------------------
56. * EventManager.InvokeWhenConditionIsTrue ( string eventName, method condition )
57. *
58. * string eventName: same as above.
59. * method condition: a method that should only return true or false. Will be checked every frame. When the condition returns true, the event will be invoked once.
60. *
61. */
63. NP_EventManager_DataManager_createGameObjects = DataManager.createGameObjects;
64. DataManager.createGameObjects = function() {
65.     NP_EventManager_DataManager_createGameObjects.call(this);
66.     EventManager.setup();
67. };
69. NP_EventManager_Graphics_render = Graphics.render;
70. Graphics.render = function(stage) {
71.     NP_EventManager_Graphics_render.call(this, stage);
72.     EventManager.Tick();
73. }
75. function EventManager() {
76.     throw new Error('This is a static class');
77. }
79. /// Summary: Sets up the EventManager. Should only be called once.
80. /// Returns: N/A
81. EventManager.setup = function() {
82.     if (!this._isSetup) {
83.         this._isSetup = true;
84.         this._eventDictionary = [];
85.         this._eventsToCallAfterTime = [];
86.         this._eventsToCallWhenCondition = [];
87.         this._tickTime = 1.0 / 60.0;
88.     }
89. };
91. /// Summary: This will call the event. Will call all methods that are listening for this event.
92. /// Argument - eventName: The name of the event to invoke.
93. /// Returns: N/A
94. EventManager.Invoke = function(eventName) {
95.     var eventExists = false;
96.     var eventIndex = -1;
97.     for (var i = 0; i < this._eventDictionary.length && !eventExists; ++i) {
98.         var eventEntry = this._eventDictionary[i];
99.         if (eventEntry.eventName == eventName) {
100.             eventExists = true;
101.             eventIndex = i;
102.         }
103.     }
105.   
106.     if (eventExists) {
107.         var eventDetails = this._eventDictionary[eventIndex];
108.         for (var i = 0; i < eventDetails["methods"].length; ++i) {
109.             eventDetails["methods"][i]["methodCallback"].call(this);
110.         }
111.     }
112. }
114. /// Summary: This will call the event, but also pass a single parameter to all methods being invoked. Will call all methods that are listening for this event.
115. /// Argument - eventName: The name of the event to invoke.
116. /// Argument - parameter: The data to pass to the methods.
117. /// Returns: N/A
118. EventManager.InvokeWithParameter = function (eventName, parameter) {
119.     var eventExists = false;
120.     var eventIndex = -1;
121.     for (var i = 0; i < this._eventDictionary.length && !eventExists; ++i) {
122.         var eventEntry = this._eventDictionary[i];
123.         if (eventEntry.eventName == eventName) {
124.             eventExists = true;
125.             eventIndex = i;
126.         }
127.     }
129.     if (eventExists) {
130.         var eventDetails = this._eventDictionary[eventIndex];
131.         for (var i = 0; i < eventDetails["methods"].length; ++i) {
132.             eventDetails["methods"][i]["methodCallback"].call(this, parameter);
133.         }
134.     }
135. }
137. /// Summary: This will call the event as invoke, but will do so after a certain amount of time.
138. /// Argument - eventName: The name of the event to invoke.
139. /// Argument - time: The amount of time in seconds.
140. /// Returns: N/A
141. EventManager.InvokeAfterTime = function (eventName, time) {
142.     var entry = {};
143.     entry["eventName"] = eventName;
144.     entry["time"] = time;
145.     this._eventsToCallAfterTime.push(entry);
146. }
148. /// Summary: This will call the event as invoke, but will do so only when a certain condition is true.
149. /// Argument - eventName: The name of the event to invoke.
150. /// Argument - condition: a method that should return either true or false. It will be checked every frame. When it returns true, the event will be invoked. Will only be invoked once.
151. /// Returns: N/A
152. EventManager.InvokeWhenConditionIsTrue = function (eventName, condition) {
153.     var result = condition.call(this);
155.     var entry = {};
156.     entry["eventName"] = eventName;
157.     entry["condition"] = condition;
158.     this._eventsToCallWhenCondition.push(entry);
159. }
161. /// Summary: A single tick. Should not be called outside of Window.update
162. /// Returns: N/A
163. EventManager.Tick = function() {
164.     for (var i = 0; i < this._eventsToCallAfterTime.length; ++i) {
165.         this._eventsToCallAfterTime[i]["time"] -= this._tickTime;
167.         if (this._eventsToCallAfterTime[i]["time"] <= 0.0) {
168.             EventManager.Invoke(this._eventsToCallAfterTime[i]["eventName"]);
169.             this._eventsToCallAfterTime.splice(i, 1);
170.             --i;
171.         }
172.     }
174.     for (var i = 0; i < this._eventsToCallWhenCondition.length; ++i) {
175.         var result = this._eventsToCallWhenCondition[i]["condition"].call(this);
176.         if (result == true) {
177.             var eventName = this._eventsToCallWhenCondition[i]["eventName"];
178.             this._eventsToCallWhenCondition.splice(i, 1);
179.             --i;
180.             EventManager.Invoke(eventName);
181.         }
182.     }
183. }
185. /// Summary: Starts listening for a specific event. When a piece of code calls the invoke method, this method will be called.
186. /// Argument - eventName: The name of the event to listen to.
187. /// Argument - methodName: The string name of the method. This is simply used for lookup. When you stop listening, you will need to provide this string again.
188. /// Argument - methodCallback: The method to call when the event is invoked.
189. /// Returns: N/A
190. EventManager.StartListening = function(eventName, methodName, methodCallback) {
191.     var eventExists = false;
192.     var eventIndex = -1;
193.     for (var i = 0; i < this._eventDictionary.length && !eventExists; ++i) {
194.         var eventEntry = this._eventDictionary[i];
195.         if (eventEntry.eventName == eventName) {
196.             eventExists = true;
197.             eventIndex = i;
198.         }
199.     }
201.     if (!eventExists) {
202.         eventIndex = this._eventDictionary.length;
203.         var entry = {};
204.         entry["eventName"] = eventName;
205.         entry["methods"] = [];
206.         this._eventDictionary.push(entry);
207.     }
209.     for (var i = 0; i < this._eventDictionary[eventIndex]["methods"].length; ++i) {
210.         if (this._eventDictionary[eventIndex]["methods"][i]["methodName"] == methodName) {
211.             throw new Error('Trying to add a method that already exists.');
212.         }
213.     }
215.     var methodEntry = {};
216.     methodEntry["methodName"] = methodName;
217.     methodEntry["methodCallback"] = methodCallback = methodCallback;
218.     this._eventDictionary[eventIndex]["methods"].push(methodEntry);
219. }
221. /// Summary: Stops listening for a specific event. The method will no longer be called when the event is invoked.
222. /// Argument - eventName: The name of the event to stop listening to.
223. /// Argument - methodName: The string name of the method. This is the same methodName that you used to start listening.
224. /// Returns: N/A
225. EventManager.StopListening = function(eventName, methodName) {
226.     var eventExists = false;
227.     var eventIndex = -1;
228.     for (var i = 0; i < this._eventDictionary.length && !eventExists; ++i) {
229.         var eventEntry = this._eventDictionary[i];
230.         if (eventEntry.eventName == eventName) {
231.             eventExists = true;
232.             eventIndex = i;
233.         }
234.     }
236.     if (!eventExists) {
237.         throw new Error('Trying to remove a method that does not exist.');
238.     }
240.     var methodsArrayLength = this._eventDictionary[eventIndex]["methods"].length;
241.     var methodIndex = -1;
242.     for (var i = 0; i < this._eventDictionary[eventIndex]["methods"].length && methodIndex == -1; ++i) {
243.         if (this._eventDictionary[eventIndex]["methods"][i]["methodName"] == methodName) {
244.             methodIndex = i;
245.         }
246.     }
248.     if (methodIndex == -1) {
249.         throw new Error('Trying to remove a method that does not exist.');
250.     }
252.     if (methodsArrayLength == 1) {
253.         this._eventDictionary.splice(eventIndex, 1);
254.     }
255.     else {
256.         this._eventDictionary[eventIndex]["methods"].splice(methodIndex, 1);
257.     }
258. }

复制代码

本贴来自国际rpgmaker官方论坛作者:nathanlink169处,因国际论坛即将永久关站,为了存档多年珍贵资料,署名转载到本论坛存档,由于官方帖子为英文原帖，需要中文翻译请点击论坛顶部切换语言为中文就可以将帖子翻译成中文浏览,方便大家随时查看,原文地址：https://forums.rpgmakerweb.com/threads/event-manager.141246/