1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
|
class FelFlame
class Systems
# How early this System should be executed in a list of Systems
attr_accessor :priority
# The Constant name assigned to this System
attr_accessor :const_name
# How many frames need to pass before this System is executed when controlled by {FelFlame::Stage}
attr_accessor :frame
attr_writer :addition_triggers
def addition_triggers
@addition_triggers ||= []
end
attr_writer :removal_triggers
def removal_triggers
@removal_triggers ||= []
end
attr_writer :attr_triggers
def attr_triggers
@attr_triggers ||= {}
end
class <<self
include Enumerable
# Iterate over all Systems, sorted by their priority. You also call other enumerable methods instead of each, such as +each_with_index+ or +select+
# @return [Enumerator]
def each(&block)
constants.map { |sym| const_get(sym) }.sort_by(&:priority).reverse.each(&block)
end
end
# Creates a new System which can be accessed as a constant under the namespace {FelFlame::Systems}.
# The name given is what constant the system is assigned to
#
# @example
# FelFlame::Systems.new('PassiveHeal', priority: -2) do
# FelFlame::Components::Health.each do |component|
# component.hp += 5
# end
# end
# # Only heal all characters with health every other frame.
# # Give it a low priority so other systems such as a
# # Poison system would kill the player first
#
# @param name [String] The name this system will use. Needs to to be in the Ruby Constant format.
# @param priority [Integer] Which priority order this system should be executed in relative to other systems. Higher means executed earlier.
# @param block [Proc] The code you wish to be executed when the system is triggered. Can be defined by using a +do end+ block or using +{ }+ braces.
def initialize(name, priority: 0, &block)
FelFlame::Systems.const_set(name, self)
@const_name = name
@priority = priority
@block = block
end
# Manually execute the system a single time
def call
@block.call
end
# Attempt to execute the system following the frame parameter set on this system.
# @return [Boolean] +true+ if the frame of the {FelFlame::Stage} is a multiple of this System's frame setting and this system has executed, +false+ otherwise where the system has not executed.
# For example if a System has its frame set to 3, it will only execute once every third frame that is called in FelFlame::Stage
#
def step; end
# Redefine what code is executed by this System when it is called upon.
# @param block [Proc] The code you wish to be executed when the system is triggered. Can be defined by using a +do end+ block or using +{ }+ braces.
def redefine(&block)
@block = block
end
# Removes triggers from this system. This function is fairly flexible so it can accept a few different inputs
# For addition and removal triggers, you can optionally pass in a component, or a manager to clear specifically
# the relevant triggers for that one component or manager. If you do not pass a component or manager then it will
# clear triggers for all components and managers.
# For attr_triggers
# @example
# # To clear all triggers that execute this system when a component is added:
# FelFlame::Systems::ExampleSystem.clear_triggers :addition_triggers
# # Same as above but for when a component is removed instead
# FelFlame::Systems::ExampleSystem.clear_triggers :removal_triggers
# # Same as above but for when a component has a certain attribute changed
# FelFlame::Systems::ExampleSystem.clear_triggers :attr_triggers
#
# # Clear a trigger from a specific component
# FelFlame::Systems::ExampleSystem.clear_triggers :addition_triggers, FelFlame::Component::ExampleComponent[0]
# # Clear a trigger from a specific component manager
# FelFlame::Systems::ExampleSystem.clear_triggers :addition_triggers, FelFlame::Component::ExampleComponent
#
# # Clear the trigger that executes a system when the ':example_attr' is changes
# FelFlame::Systems::ExampleSystem.clear_triggers :attr_triggers, :example_attr
# @param trigger_types [:Symbols] One or more of the following trigger types: +:addition_triggers+, +:removal_triggers+, or +:attr_triggers+. If attr_triggers is used then you may pass attributes you wish to be cleared as symbols in this parameter as well
# @param component_or_manager [Component or ComponentManager] The object to clear triggers from. Use Nil to clear triggers from all components associated with this system.
# @return [Boolean] true
def clear_triggers(*trigger_types, component_or_manager: nil)
trigger_types = [:addition_triggers, :removal_triggers, :attr_triggers] if trigger_types.empty?
if trigger_types.include? :attr_triggers
if (trigger_types - [:addition_triggers,
:removal_triggers,
:attr_triggers]).empty?
if component_or_manager.nil?
#remove all attrs
self.attr_triggers.each do |cmp_or_mgr, attrs|
attrs.each do |attr|
next if cmp_or_mgr.attr_triggers[attr].nil?
cmp_or_mgr.attr_triggers[attr].delete self
end
self.attr_triggers = {}
end
else
#remove attrs relevant to comp_or_man
unless self.attr_triggers[component_or_manager].nil?
self.attr_triggers[component_or_manager].each do |attr|
component_or_manager.attr_triggers[attr].delete self
end
self.attr_triggers[component_or_manager] = []
end
end
else
if component_or_manager.nil?
(trigger_types - [:addition_triggers, :removal_triggers, :attr_triggers]).each do |attr|
#remove attr
self.attr_triggers.each do |cmp_or_mgr, attrs|
cmp_or_mgr.attr_triggers[attr].delete self
end
end
self.attr_triggers.delete (trigger_types - [:addition_triggers,
:removal_triggers,
:attr_triggers])
else
#remove attr from component_or_manager
(trigger_types - [:addition_triggers, :removal_triggers, :attr_triggers]).each do |attr|
next if component_or_manager.attr_triggers[attr].nil?
component_or_manager.attr_triggers[attr].delete self
#self.attr_triggers[component_or_manager].each do |attr|
# component_or_manager.attr_triggers[attr].delete self
#end
end
self.attr_triggers[component_or_manager] -= trigger_types unless self.attr_triggers[component_or_manager].nil?
end
end
end
(trigger_types & [:removal_triggers, :addition_triggers] - [:attr_triggers]).each do |trigger_type|
if component_or_manager.nil?
#remove all removal triggers
self.send(trigger_type).each do |trigger|
trigger.send(trigger_type).delete self
end
self.send("#{trigger_type.to_s}=", [])
else
#remove removal trigger relevant to comp/man
self.send(trigger_type).delete component_or_manager
component_or_manager.send(trigger_type).delete self
end
end
end
# Add a component or component manager so that it triggers this system when the component or a component from the component manager is added to an entity
# @param component_or_manager [Component or ComponentManager] The component or component manager to trigger this system when added
# @return [Boolean] true
def trigger_when_added(component_or_manager)
self.addition_triggers |= [component_or_manager]
component_or_manager.addition_triggers |= [self]
true
end
# Add a component or component manager so that it triggers this system when the component or a component from the component manager is removed from an entity
# @param component_or_manager [Component or ComponentManager] The component or component manager to trigger this system when removed
# @return [Boolean] true
def trigger_when_removed(component_or_manager)
self.removal_triggers |= [component_or_manager]
component_or_manager.removal_triggers |= [self]
true
end
# Add a component or component manager so that it triggers this system when a component's attribute is changed.
def trigger_when_is_changed(component_or_manager, attr)
if component_or_manager.attr_triggers[attr].nil?
component_or_manager.attr_triggers[attr] = [self]
else
component_or_manager.attr_triggers[attr] |= [self]
end
if self.attr_triggers[component_or_manager].nil?
self.attr_triggers[component_or_manager] = [attr]
else
self.attr_triggers[component_or_manager] |= [attr]
end
end
end
end
|
