1 : import { Logger } from '../core/Logger.js';
2 : import { FuzzyRule } from './FuzzyRule.js';
3 : import { FuzzyVariable } from './FuzzyVariable.js';
4 : 
5 : /**
6 : * Class for representing a fuzzy module. Instances of this class are used by
7 : * game entities for fuzzy inference. A fuzzy module is a collection of fuzzy variables
8 : * and the rules that operate on them.
9 : *
10 : * @author {@link https://github.com/Mugen87|Mugen87}
11 : */
12 : class FuzzyModule {
13 : 
14 : 	/**
15 : 	* Constructs a new fuzzy module.
16 : 	*/
17 : 	constructor() {
18 : 
19 : 		/**
20 : 		* An array of the fuzzy rules.
21 : 		* @type {Array<FuzzyRule>}
22 : 		* @readonly
23 : 		*/
24 : 		this.rules = new Array();
25 : 
26 : 		/**
27 : 		* A map of FLVs.
28 : 		* @type {Map<String,FuzzyVariable>}
29 : 		* @readonly
30 : 		*/
31 : 		this.flvs = new Map();
32 : 
33 : 	}
34 : 
35 : 	/**
36 : 	* Adds the given FLV under the given name to this fuzzy module.
37 : 	*
38 : 	* @param {String} name - The name of the FLV.
39 : 	* @param {FuzzyVariable} flv - The FLV to add.
40 : 	* @return {FuzzyModule} A reference to this fuzzy module.
41 : 	*/
42 : 	addFLV( name, flv ) {
43 : 
44 : 		this.flvs.set( name, flv );
45 : 
46 : 		return this;
47 : 
48 : 	}
49 : 
50 : 	/**
51 : 	* Remove the FLV under the given name from this fuzzy module.
52 : 	*
53 : 	* @param {String} name - The name of the FLV to remove.
54 : 	* @return {FuzzyModule} A reference to this fuzzy module.
55 : 	*/
56 : 	removeFLV( name ) {
57 : 
58 : 		this.flvs.delete( name );
59 : 
60 : 		return this;
61 : 
62 : 	}
63 : 
64 : 	/**
65 : 	* Adds the given fuzzy rule to this fuzzy module.
66 : 	*
67 : 	* @param {FuzzyRule} rule - The fuzzy rule to add.
68 : 	* @return {FuzzyModule} A reference to this fuzzy module.
69 : 	*/
70 : 	addRule( rule ) {
71 : 
72 : 		this.rules.push( rule );
73 : 
74 : 		return this;
75 : 
76 : 	}
77 : 
78 : 	/**
79 : 	* Removes the given fuzzy rule from this fuzzy module.
80 : 	*
81 : 	* @param {FuzzyRule} rule - The fuzzy rule to remove.
82 : 	* @return {FuzzyModule} A reference to this fuzzy module.
83 : 	*/
84 : 	removeRule( rule ) {
85 : 
86 : 		const rules = this.rules;
87 : 
88 : 		const index = rules.indexOf( rule );
89 : 		rules.splice( index, 1 );
90 : 
91 : 		return this;
92 : 
93 : 	}
94 : 
95 : 	/**
96 : 	* Calls the fuzzify method of the defined FLV with the given value.
97 : 	*
98 : 	* @param {String} name - The name of the FLV
99 : 	* @param {Number} value - The crips value to fuzzify.
100 : 	* @return {FuzzyModule} A reference to this fuzzy module.
101 : 	*/
102 : 	fuzzify( name, value ) {
103 : 
104 : 		const flv = this.flvs.get( name );
105 : 
106 : 		flv.fuzzify( value );
107 : 
108 : 		return this;
109 : 
110 : 	}
111 : 
112 : 	/**
113 : 	* Given a fuzzy variable and a defuzzification method this returns a crisp value.
114 : 	*
115 : 	* @param {String} name - The name of the FLV
116 : 	* @param {String} type - The type of defuzzification.
117 : 	* @return {Number} The defuzzified, crips value.
118 : 	*/
119 : 	defuzzify( name, type = FuzzyModule.DEFUZ_TYPE.MAXAV ) {
120 : 
121 : 		const flvs = this.flvs;
122 : 		const rules = this.rules;
123 : 
124 : 		this._initConsequences();
125 : 
126 : 		for ( let i = 0, l = rules.length; i < l; i ++ ) {
127 : 
128 : 			const rule = rules[ i ];
129 : 
130 : 			rule.evaluate();
131 : 
132 : 		}
133 : 
134 : 		const flv = flvs.get( name );
135 : 
136 : 		let value;
137 : 
138 : 		switch ( type ) {
139 : 
140 : 			case FuzzyModule.DEFUZ_TYPE.MAXAV:
141 : 				value = flv.defuzzifyMaxAv();
142 : 				break;
143 : 
144 : 			case FuzzyModule.DEFUZ_TYPE.CENTROID:
145 : 				value = flv.defuzzifyCentroid();
146 : 				break;
147 : 
148 : 			default:
149 : 				Logger.warn( 'YUKA.FuzzyModule: Unknown defuzzification method:', type );
150 : 				value = flv.defuzzifyMaxAv(); // use MaxAv as fallback
151 : 
152 : 		}
153 : 
154 : 		return value;
155 : 
156 : 	}
157 : 
158 : 	_initConsequences() {
159 : 
160 : 		const rules = this.rules;
161 : 
162 : 		// initializes the consequences of all rules.
163 : 
164 : 		for ( let i = 0, l = rules.length; i < l; i ++ ) {
165 : 
166 : 			const rule = rules[ i ];
167 : 
168 : 			rule.initConsequence();
169 : 
170 : 		}
171 : 
172 : 		return this;
173 : 
174 : 	}
175 : 
176 : 	/**
177 : 	* Transforms this instance into a JSON object.
178 : 	*
179 : 	* @return {Object} The JSON object.
180 : 	*/
181 : 	toJSON() {
182 : 
183 : 		const json = {
184 : 			rules: new Array(),
185 : 			flvs: new Array()
186 : 		};
187 : 
188 : 		// rules
189 : 
190 : 		const rules = this.rules;
191 : 
192 : 		for ( let i = 0, l = rules.length; i < l; i ++ ) {
193 : 
194 : 			json.rules.push( rules[ i ].toJSON() );
195 : 
196 : 		}
197 : 
198 : 		// flvs
199 : 
200 : 		const flvs = this.flvs;
201 : 
202 : 		for ( let [ name, flv ] of flvs ) {
203 : 
204 : 			json.flvs.push( { name: name, flv: flv.toJSON() } );
205 : 
206 : 		}
207 : 
208 : 		return json;
209 : 
210 : 	}
211 : 
212 : 	/**
213 : 	* Restores this instance from the given JSON object.
214 : 	*
215 : 	* @param {Object} json - The JSON object.
216 : 	* @return {FuzzyModule} A reference to this fuzzy module.
217 : 	*/
218 : 	fromJSON( json ) {
219 : 
220 : 		const fuzzySets = new Map(); // used for rules
221 : 
222 : 		// flvs
223 : 
224 : 		const flvsJSON = json.flvs;
225 : 
226 : 		for ( let i = 0, l = flvsJSON.length; i < l; i ++ ) {
227 : 
228 : 			const flvJSON = flvsJSON[ i ];
229 : 			const name = flvJSON.name;
230 : 			const flv = new FuzzyVariable().fromJSON( flvJSON.flv );
231 : 
232 : 			this.addFLV( name, flv );
233 : 
234 : 			for ( let fuzzySet of flv.fuzzySets ) {
235 : 
236 : 				fuzzySets.set( fuzzySet.uuid, fuzzySet );
237 : 
238 : 			}
239 : 
240 : 		}
241 : 
242 : 		// rules
243 : 
244 : 		const rulesJSON = json.rules;
245 : 
246 : 		for ( let i = 0, l = rulesJSON.length; i < l; i ++ ) {
247 : 
248 : 			const ruleJSON = rulesJSON[ i ];
249 : 			const rule = new FuzzyRule().fromJSON( ruleJSON, fuzzySets );
250 : 
251 : 			this.addRule( rule );
252 : 
253 : 		}
254 : 
255 : 		return this;
256 : 
257 : 	}
258 : 
259 : }
260 : 
261 : FuzzyModule.DEFUZ_TYPE = Object.freeze( {
262 : 	MAXAV: 0,
263 : 	CENTROID: 1
264 : } );
265 : 
266 : export { FuzzyModule };