-
Notifications
You must be signed in to change notification settings - Fork 2
/
variable.js
223 lines (198 loc) · 6.05 KB
/
variable.js
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
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
/*
* GDevelop JS Platform
* Copyright 2013-2016 Florian Rival (Florian.Rival@gmail.com). All rights reserved.
* This project is released under the MIT License.
*/
/**
* A Variable is an object storing a value (number or a string) or children variables.
*
* @constructor
* @namespace gdjs
* @class Variable
* @param varData optional object used to initialize the variable.
*/
gdjs.Variable = function(varData)
{
this._value = 0;
this._str = "";
this._numberDirty = false;
this._stringDirty = true;
this._isStructure = false;
this._children = {}; //TODO: Use a hashtable and avoid de/allocations.
this._undefinedInContainer = false;
if ( varData !== undefined ) {
if ( varData.value !== undefined ) { //Variable is a string or a number
var initialValue = varData.value;
//Try to guess the type of the value, as GD has no way ( for now ) to specify
//the type of a variable.
var valueWhenConsideredAsNumber = parseFloat(initialValue, 10);
if(valueWhenConsideredAsNumber === valueWhenConsideredAsNumber && valueWhenConsideredAsNumber.toString() === initialValue) { //"Since NaN is the only JavaScript value that is treated as unequal to itself, you can always test if a value is NaN by checking it for equality to itself"
this._value = parseFloat(initialValue, 10);
}
else { //We have a string (Maybe empty).
if ( initialValue.length === 0 )
this._value = 0;
else {
this._str = initialValue;
this._numberDirty = true;
this._stringDirty = false;
}
}
} else { //Variable is a structure
this._isStructure = true;
if (varData.children !== undefined) {
for(var i = 0, len = varData.children.length;i<len;++i) {
var childData = varData.children[i];
this._children[childData.name] = new gdjs.Variable(childData);
}
}
}
}
};
/**
* Used ( usually by VariablesContainer ) to set that the variable must be
* considered as not existing in the container.
* @method setUndefinedInContainer
*/
gdjs.Variable.prototype.setUndefinedInContainer = function() {
this._undefinedInContainer = true;
};
/**
* Check if the variable must be considered as not existing in its container
* ( Usually a VariablesContainer ).
* @method isUndefinedInContainer
* @return true if the container must consider that the variable does not exist.
*/
gdjs.Variable.prototype.isUndefinedInContainer = function() {
return this._undefinedInContainer;
};
/**
* Get the child with the specified name.
*
* If the variable has not the specified child, an empty variable with the specified name
* is added as child.
* @method getChild
*/
gdjs.Variable.prototype.getChild = function(childName) {
if ( this._children.hasOwnProperty(childName) && this._children[childName] !== undefined )
return this._children[childName];
this._isStructure = true;
this._children[childName] = new gdjs.Variable();
return this._children[childName];
};
/**
* Return the child in a variable.
*
* Check if the variable has the specified children
* @method hasChild
* @return true if variable has the children with the specified name
*/
gdjs.Variable.prototype.hasChild = function(childName) {
return (this._isStructure && this._children.hasOwnProperty(childName) );
};
/**
* Remove the child with the specified name.
*
* If the variable has not the specified child, nothing is done.
* @method removeChild
* @param childName The name of the child to be removed
*/
gdjs.Variable.prototype.removeChild = function(childName) {
if ( !this._isStructure ) return;
delete this._children[childName];
}
/**
* Remove all the children.
*
* If the variable is not a structure, nothing is done.
* @method clearChildren
*/
gdjs.Variable.prototype.clearChildren = function() {
if ( !this._isStructure ) return;
for ( var child in this._children ) {
if ( this._children.hasOwnProperty(child) ){
delete this._children[child];
}
}
}
/**
* Get the value of the variable, considered as a number
* @method getAsNumber
* @return {Number} The number stored
*/
gdjs.Variable.prototype.getAsNumber = function() {
if ( this._numberDirty ) {
this._value = parseFloat(this._str, 10);
if ( this._value !== this._value ) this._value = 0; //Ensure NaN is not returned as a value.
this._numberDirty = false;
}
return this._value;
};
/**
* Change the value of the variable, considered as a number
* @method setNumber
* @param newValue {Number} The new value to be set
*/
gdjs.Variable.prototype.setNumber = function(newValue) {
this._value = newValue;
this._stringDirty = true;
this._numberDirty = false;
};
/**
* Get the value of the variable, considered as a string
* @method getAsString
* @return {String} The number stored
*/
gdjs.Variable.prototype.getAsString = function() {
if ( this._stringDirty ) {
this._str = this._value.toString();
this._stringDirty = false;
}
return this._str;
};
/**
* Change the value of the variable, considered as a string
* @method setString
* @param newValue {String} The new string to be set
*/
gdjs.Variable.prototype.setString = function(newValue) {
this._str = newValue;
this._numberDirty = true;
this._stringDirty = false;
};
/**
* Return true if the variable is a structure.
* @method isStructure
*/
gdjs.Variable.prototype.isStructure = function() {
return this._isStructure;
};
/**
* Return true if the variable is a number.
* @method isNumber
*/
gdjs.Variable.prototype.isNumber = function() {
return !this._isStructure && !this._numberDirty;
};
/**
* Return the object containing all the children of the variable
* @method getAllChildren
*/
gdjs.Variable.prototype.getAllChildren = function() {
return this._children;
}
gdjs.Variable.prototype.add = function(val) {
this.setNumber(this.getAsNumber()+val);
};
gdjs.Variable.prototype.sub = function(val) {
this.setNumber(this.getAsNumber()-val);
};
gdjs.Variable.prototype.mul = function(val) {
this.setNumber(this.getAsNumber()*val);
};
gdjs.Variable.prototype.div = function(val) {
this.setNumber(this.getAsNumber()/val);
};
gdjs.Variable.prototype.concatenate = function(str) {
this.setString(this.getAsString()+str);
};