├── .gitignore
├── CHANGELOG.md
├── LICENSE.md
├── README.md
├── buildpackage.bat
├── haxelib.json
└── ice
    ├── entity
        ├── Component.hx
        ├── Entity.hx
        ├── EntityManager.hx
        └── IceUtil.hx
    ├── fsm
        └── FSM.hx
    ├── group
        └── EntityGroup.hx
    ├── parser
        ├── IceInterp.hx
        ├── Script.hx
        ├── ScriptHandler.hx
        └── ScriptHolder.hx
    └── wrappers
        ├── FlxCameraFollowStyleWrap.hx
        ├── FlxColorWrap.hx
        └── FlxKeyWrap.hx


/.gitignore:
--------------------------------------------------------------------------------
 1 | *
 2 | !.gitignore
 3 | !ice/
 4 | !ice/*
 5 | !ice/entity/*
 6 | !ice/parser/*
 7 | !ice/fsm/*
 8 | !ice/wrappers/*
 9 | !ice/group/*
10 | !haxelib.json
11 | !CHANGELOG.md
12 | !LICENSE.md
13 | !README.md
14 | !buildpackage.bat


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
  1 | 1.3.0
  2 | ------------------------------
  3 | * many, many bugfixes and safety checks
  4 | * `switchState()` added
  5 | * `<load>` element added
  6 | * `FlxKeyWrap` Added
  7 | * `FlxColorWrap` Added
  8 | * `newObject()` Added for scripts
  9 | * create instances of template from code instead of XML
 10 | * fix freezing on wrong asset path
 11 | * `EntityGroup` added (just `FlxTypedGroup<Entity>`)
 12 | * fix depth ordering for XML files
 13 | * `prefab` element added
 14 | 
 15 | 1.2.0
 16 | ------------------------------
 17 | * added an api for accesing variables on scripts, while retaining type-safety
 18 | 
 19 | 1.1.1
 20 | ------------------------------
 21 | * fixed multiple destroy() functions, so state switching, etc. work properly
 22 | 
 23 | 1.1.0
 24 | ------------------------------
 25 | * allow use of % in entity declarations, referring to game width or height
 26 | 
 27 | 1.0.2
 28 | ------------------------------
 29 | * allow animation addition using entity.loadAnimation() (lets you use fancy frame declarations)
 30 | 
 31 | 1.0.1
 32 | ------------------------------
 33 | * allow adding scripts to an entity via entity.scripts.ParseScript(path)
 34 | * fix new entities in groups not being drawn
 35 | * allow type declarations in callable functions
 36 | 
 37 | 1.0.0
 38 | ------------------------------
 39 | * rewrite scripting system, allow for real haxe files
 40 | * remove map property on EntityManager
 41 | * add instance and template creation for entity xml files
 42 | 
 43 | 0.10.1
 44 | ------------------------------
 45 | * extend interp to allow property access on objects
 46 | 
 47 | 0.10.0
 48 | ------------------------------
 49 | * add syntax for exposing and requesting classes inside of scripts
 50 | 
 51 | 0.9.0
 52 | ------------------------------
 53 | * add simple fsm system
 54 | 
 55 | 0.8.2
 56 | ------------------------------
 57 | * fix parsing mistake causing scripts to only load if the entity had an art element
 58 | 
 59 | 0.8.1
 60 | ------------------------------
 61 | * make sure to check that entities aren't null
 62 | 
 63 | 0.8.0
 64 | ------------------------------
 65 | * add noreload option
 66 | * make scripts delete if they only have init logic (unless noclean is specified)
 67 | 
 68 | 0.7.0
 69 | ------------------------------
 70 | * allow access to instance via a property
 71 | 
 72 | 0.6.3
 73 | ------------------------------
 74 | * fix backward conditionals that broke string loading
 75 | 
 76 | 0.6.2
 77 | ------------------------------
 78 | * only call @reload if script changed
 79 | 
 80 | 0.6.1
 81 | ------------------------------
 82 | * add option for true live-reloading
 83 | 
 84 | 0.6.0
 85 | ------------------------------
 86 | * integrate live-reloading of external scripts
 87 | * add @reload function for scripts
 88 | * change Owner to GID
 89 | 
 90 | 0.5.6
 91 | ------------------------------
 92 | * fix spelling of receive
 93 | 
 94 | 0.5.5
 95 | ------------------------------
 96 | * check destroyScript for null
 97 | 
 98 | 0.5.4
 99 | ------------------------------
100 | * fix underlying mistake that caused the need for the if(!init) check
101 | 
102 | 0.5.3
103 | ------------------------------
104 | * hard-code the if(!init) check
105 | 
106 | 0.5.2
107 | ------------------------------
108 | * fix parsing of entity scripts
109 | 
110 | 0.5.1
111 | ------------------------------
112 | * fix for new handling of flxgroups
113 | * add init variable to (sort of) fix recurring init
114 | 
115 | 0.5.0
116 | ------------------------------
117 | * added hscript integration
118 | 
119 | 0.4.0
120 | ------------------------------
121 | * changed group storage and behaviour
122 | * split AddEntity() into separate methods 
123 | 
124 | 0.3.1
125 | ------------------------------
126 | * added ability to use hyphens in animation parsing
127 | 
128 | 0.3.0
129 | ------------------------------
130 | * added entity xml parser
131 | 
132 | 0.2.1
133 | ------------------------------
134 | * added destruction of entities
135 | * removed template
136 | * added haxelib setup
137 | 
138 | 0.2.0
139 | ------------------------------
140 | * marked version numbers (not coded anywhere in project, just for reference)
141 | * all classes have replaced the word "gameobject" with entity, I know its annoying, but in the end its shorter to type...
142 | * added a simple message broadcasting system
143 | * added distance measuring between entities
144 | * added IsAgainst() for determining if an entity is directly touching something in a given direction
145 | 
146 | 0.1.1
147 | ------------------------------
148 | * packages have been renamed to: ice.entity.[class].
149 | * code has been surrounded in a template haxeflixel project, with EntityManager already added.
150 | 
151 | 0.1.0
152 | ------------------------------
153 | * code ported from IceEntity
154 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 Nico May
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | IceEntity
  2 | =========
  3 | 
  4 | ![IceEntity Demo](http://i.imgur.com/9tQt9rh.png)
  5 | 
  6 | A simple framework for managing entities and components in HaxeFlixel
  7 | 
  8 | **[ATTENTION ANY/ALL USERS]** Please move to the development branch (relies on dev flixel), as I can no longer guarantee updates to anything else, sorry.
  9 | 
 10 | **[NEW] [sample project here](https://github.com/NicoM1/IceEntity-Sample) [NEW]**
 11 | 
 12 | (The above may be a much simpler way to learn much of what is included in this readme, as well as some smaller, but still useful features)
 13 | 
 14 | **Changes:**
 15 | ----------
 16 | 
 17 |   **[NEW v1.2.0]**
 18 |   
 19 |   Added an api for accesing variables on scripts, while retaining type-safety (`Entity.getVar()`)
 20 | 
 21 |   **[NEW v1.1.0]**
 22 | 
 23 |   Allow use of % in entity declarations, referring to game width or height
 24 | 
 25 |   **[NEW v1.0.0]**
 26 |   
 27 |   Rewrote entire scripting system, allowing proper Haxe classes to be parsed as scripts
 28 | 
 29 |   Added templates and instance creation to XML parser
 30 |   
 31 |   **[v0.10.0]**
 32 |   
 33 |   Added syntax for exposing and requesting classes inside of scripts
 34 | 
 35 |   **[v0.9.0]**
 36 |   
 37 |   Added simple FSM system (sorry no write-up yet)
 38 | 
 39 |   **[v0.8.0]**
 40 |   
 41 |   Added "noreload" option for script elements
 42 |   
 43 |   Made scripts remove after calling init, unless they have update or destroy logic
 44 | 
 45 |   **[v0.7.0]**
 46 |   Allow access to instance via a property
 47 | 
 48 |   **[v0.6.1]**
 49 |   Made live-reloading fully automatic
 50 | 
 51 |   **[v0.6.0]**
 52 |   Added live-reloading of scripts
 53 | 
 54 |   **[v0.5.0]**
 55 |   Added hscript integration
 56 | 
 57 |   **Earlier:**
 58 |   
 59 |   [See Changelog](https://github.com/NicoM1/IceEntity/blob/dev/CHANGELOG.md)
 60 |   
 61 | **Installation**
 62 | ----------
 63 | 
 64 |   **[1]** Run ```haxelib git iceentity https://github.com/NicoM1/IceEntity dev``` in a terminal with access to git
 65 |   
 66 |   **[2]** Add ```<haxelib name="iceentity"/>``` to your ```Project.xml``` file, directly under ```<haxelib name="flixel"/>```
 67 |   
 68 |   **[3]** MAKE COOL THINGS:D
 69 | 
 70 | 
 71 | **Usage:**
 72 | ----------
 73 | 
 74 |   Call ```add(EntityManager.instance);``` in the create function of your playstate.
 75 |   
 76 |   Use ```EntityManager.instance.AddEntity();``` to add objects or groups to the manager.
 77 |   
 78 |   Use ```AddComponent();``` on a class extending entity to add a new component.
 79 |   
 80 |   ```init()``` will run on the first update cycle, useful for getting and stashing references to other entities.
 81 |   
 82 |  **Entity Parser:**
 83 | ----------
 84 | IceEntity includes an xml parser, which can build entities from simple xml files. In order to use this system, you must:
 85 | 
 86 | **[1]** Create an xml file with this structure:
 87 | 
 88 |     <?xml version="1.0" encoding="utf-8" ?>
 89 |     <data>
 90 | 	    <entity tag="myTag" x="50%" y="100"> //"%" is new as of V1.1.0, it allows you to specify a percentage of game width or height, instead of an exact value
 91 | 		    <art width="32" height="32" path="assets/images/myimage.png">
 92 | 			    <animation name="idle" frames="0,1,2,3-6,6-0" framerate="10" looped="true" autorun="true"/>
 93 | 				//ANIMATIONS: all parameters must be supplied, except "autorun" which mearly starts the animation as soon as it is loaded
 94 | 				//FRAMES: as of v0.3.1, "frames" can now use hyphens, allowing you to do things such as: "0-10", or "10-0", note that commas are still allowed, and this is valid: "0-10,10-0,0,1,2,3,4,5,6,7,8,9,10"
 95 | 		    </art>
 96 | 		    <component type="com.me.MyComponent">
 97 | 			    <param name="speed" type="int" value="10"/>
 98 | 		    </component>
 99 | 			//CHECK NEXT SECTION FOR SCRIPTING INFORMATION (yes, you can write code here!!)
100 | 	    </entity>
101 | 
102 | 		<entity tag="templateTest" template="test" x="0" y="0"/> [NEW as of 1.0.0]
103 | 		/*This is a "template" it can be used to create many instances of a premade entity, 
104 | 		simply declare the entity as usual, and add an identifier: template="identifier".
105 | 		Note that by default, entities with a template attribute are not built at startup,
106 | 		however you can do so by adding instance="true" to the declaration.
107 | 		Note this is a single line for clarity, but this "template" would in practice look
108 | 		the same as the above entity declaration, with art and all*/
109 | 
110 | 		<instance template="test" tag="overwrittenTag" x="10" y="15"/>
111 | 		/*This is an "instance", you can instantiate a template as many times as you wish, 
112 | 		while altering tag and position.*/
113 | 
114 |     </data>
115 | 	
116 | **Important information:** 
117 | 
118 | Parameters for components **must** be in the same order as specified in their constructor, **passing the entity's GID is not required**, it will be auto set. 
119 | 
120 | Param "name" attributes are not required, but are strongly recommended for organization.
121 | 
122 | Allowed types for parameters are: **"int" "float" and "bool" anything else will be treated as a plain string, including a lack of the "type" attribute**. Capitalization on param types does not matter. 
123 | 
124 | **MOST IMPORTANTLY: any component you wish to add in a xml file MUST be referenced somewhere in your basecode, even adding an ```import com.me.MyComponent;``` to your playstate will work. xml parsing will not work without this, as the component will not be compiled.**
125 | 
126 | **[2]** Call ```EntityManager.instance.BuildFromXML("assets/data/MyEntities.xml");``` in your playstates create function (or wherever really).
127 | 
128 | **HScript Integration:**
129 | ----------
130 | 
131 | As of v1.0.0, IceEntity's scripting system has been completely rewritten, with work from both me and @Ohmnivore, making the act of scripting at runtime much more user friendly. Note this is a new feature, relatively untested, and may not be as efficient as standard components. If you find an issue, or are confused, tweet to me at: [@nico_m__](https://twitter.com/nico_m__), or email me: nico(dot)may99(at)gmail(dot)com. **These features allow you, the developer, to program your game in standard Haxe code, without recompiling, at runtime.** I'll let you think of the possibilities:). It also means, that with little or no work, modding can be integrated into your game! Here are the steps to getting this to work in you game:
132 | 
133 | **[1]** In you entity xml file (described above), there are two places you can put scripts. One being inside of an entity declaration, like so:
134 | 
135 |     <?xml version="1.0" encoding="utf-8" ?>
136 |     <data>
137 | 	    <entity tag="myTag" x="0" y="0">
138 | 		    <script/>
139 | 	    </entity>
140 |     </data>
141 | 	
142 | The other is outside of an entity declaration, like so:
143 | 	
144 | 	<?xml version="1.0" encoding="utf-8" ?>
145 |     <data>
146 | 		<script/>
147 |     </data>
148 | 	
149 | Before I describe how to actually write a script, let me make sure you know the difference between the two places. A script placed inside an entity declaration has two features that orphan (outside) scripts do not. First: a "owner" variable is automatically created, allowing you to access the entity that the script resides in, and second: they scripts "destroy" function will automatically be called in the event of its parent entity's destruction.
150 | 
151 | **[2]** In order to write your script, this is the format you must use:
152 | 
153 | 	<script path="" id="-1"> 
154 | 	<!--if a path is specified, that is loaded instead of the <text> node-->
155 | 	<!--id can be left at -1, to auto-assign, but I recommend setting it to any int greater than 0, to allow referencing this script-->
156 | 		<expose name="FlxG" path="flixel.FlxG"/> <!--Gets a static class-->
157 | 		<request name="Player"/>	<!--requests a class instance from a global pool-->
158 | 		<text>
159 | 			import flixel.FlxG; //these can be used instead of the above xml tags
160 | 			request Player;
161 | 			
162 | 			var test:Entity = new Entity("test");
163 | 
164 | 			function init
165 | 			{
166 | 				var i = 10; //variables declared in init are accessible from other functions
167 | 				trace(test.Tag);
168 | 			}
169 | 			function reload
170 | 			{
171 | 				<!--described in next section-->
172 | 			}
173 | 			function update
174 | 			{
175 | 				trace(Player.x); 
176 | 				trace(owner.x); <!--if this script was inside an entity declaration, you can reference that entity with "owner"-->
177 | 				trace(FlxG.camera.x);
178 | 				trace(i);
179 | 			}
180 | 			function destroy
181 | 			{
182 | 				Player = null;
183 | 			}
184 | 		</text>
185 | 	</script>
186 | 	
187 | As you can see, the "expose" tag allows the script to gain access to a static class, and reference it as whatever is in the "name" attribute. The "request" tag allows the script to get access to a class instance (or, truthfully, a static class will also work), from the ```ScriptHandler```s global pool. You can add to the pool in your code with ```ScriptHandler.AddModule(name, value);``` Note that this must be done BEFORE you parse the entity file, or you will get a nasty error message.
188 | 
189 | **[3]** You may be (rightly) thinking: **"Hey, you said we were using real Haxe, that doesn't look like real Haxe to me?"** The reason for this: IceEntity's parser has been written to be flexible with how you want to write your scripts, if all you need is a few lines doing something really simple, the above is easier to type, **however**, if you wish to get full IDE support **(auto-completion)**, you can program your scripts like this (or pretty much anywhere in-between the two styles):
190 | 
191 |     package ;
192 |     
193 |     import flixel.FlxG;
194 |     import ice.entity.Entity;
195 |     
196 |     class Test
197 |     {
198 |     	//#
199 |     	var owner:Entity;
200 | 				/*
201 | 				This is a special syntax used in scripts.
202 | 				It allows you to create variables that are not compiled when the script is parsed.
203 | 				Why?
204 | 				This way, if you have used a request tag, or wish to have completion for the scripts owner, 
205 | 				you can create a variable of the proper type, 
206 | 				allowing full completion, without fearing issues in your scripts
207 | 				You may only use one of these blocks per script, simply open with "//#" and repeat to close.
208 | 				*/
209 |     	//#
210 |     	public static var testEntity = new Entity("myTag"); /*
211 | 															These variable are live-reloaded only if they
212 | 															did not previously exist, changing a value will not
213 | 															reload the variable, however if you add a new
214 | 															variable, it will be detected.
215 | 															*/
216 |     	
217 |     	public function init() 
218 |     	{
219 |     		var p:Entity = new Entity();
220 |     	}
221 |     
222 |     	public function update()
223 |     	{
224 |     		test("hello world");
225 |     	}
226 |     
227 |     	public function reload()
228 |     	{
229 |     
230 |     	}
231 | 
232 | 		//@
233 | 		function test(t)
234 | 		{
235 | 			trace(t);
236 | 		}
237 | 			/*
238 | 			This is another special syntax, any function placed inside of this block (one per script),
239 | 			acts how you would expect a standard haxe function to act, and is live-reloaded.
240 | 			*/
241 | 		//@
242 |     }
243 | 
244 | **[4]** The scripting system relies on hscript, which is basically interpreted Haxe. Unfortunately, I do not know enough about hscript yet to explain everything you can and can't do, but an important item to note is to not use properties in scripts, you must instead just use methods (as far as I can tell...). If you are more experienced in hscript, please submit a pull request with a fuller description:)
245 | 
246 | **[5]** As a developer, you may not want scripts, specificity mods, to have access to sensitive areas of your game. There are two ways to achieve this. The broad stroke way is to completely disallow access to the expose tag, ensuring scripts have no access to anything unless you specificity add it to the ```ScriptHandler```s modules list. This can be done with: ```ScriptHandler.allowExpose = false;```. The second, more specific way is to "blacklist" classes with ```ScriptHandler.Blacklist("path.to.Class");```, this will warn the user they can not access this package.
247 | 
248 | **Note: this section has been converted for the changes in IceEntity's scripting system, however, it is possible some items are incorrect, if something isn't working how it says, or how you feel it should, please let me know [@nico_m__](https://twitter.com/nico_m__) ,thanks:D**
249 | 
250 | **Live Scripting**
251 | ----------
252 | 
253 | ![Live-Scripting Demo](http://i.imgur.com/CkyiKeF.gif)
254 | IceEntity allows you, with minimal effort, to literally code your game **while it is running**. This currently only works for CPP and Neko builds, and only for external script files (ie scripts created inside of your entities.xml file will not be editable at runtime). Here is what you need to do to make use of this new feature:
255 | 
256 | **[1]** Any scripts you want to be able to edit at runtime must be taken out of your xml file, placed in their own file, and then declared in your script element's "path" attribute.
257 | 
258 | **[2]** You can now import and request classes inside your scripts, similar to how imports are handled in regular haxe:
259 | 
260 |     import flixel.FlxG; //this is identical to the expose tag in xml, except you do not control the name of the class, the last section is used, in this case: "FlxG".
261 | 	request MyClass; //this is identical using a request tag in your xml
262 | 	
263 | 	function init
264 | 	{
265 | 	
266 | 	}
267 | 
268 | This also means the live-reloader will update your imports, so you can add things as you need them. This, however, may slow the reloader, if you find that to be the case, you can add:
269 | 
270 |     <haxedef name="ICE_NO_RELOAD_IMPORTS"/>
271 | 
272 | to your project.xml file.
273 | 
274 | **[3]** To help with testing, a new scripting function has been added:
275 | 
276 |     function reload
277 | 	{
278 | 		//This runs every time the script is updated, you can use it to edit variables for testing.
279 | 		//Note that it is ONLY for testing, you should not use this for any real game code, just for playing with values for speed and so on. THIS NEVER RUNS IN A FINAL BUILD
280 | 	}
281 | 	
282 | **[4]** The files you edit while making use of live reloading **are not your main files**. The files you want to edit are in: yourProject\export\windows\ (neko or cpp)\bin\assets\data. **If you wish to use the logic you've created, copy these files back into your main folder when you are done**.
283 | 
284 | **[5]** Reloading can be costly; you may not wish to reload every script when you only want to tweak a couple. To stop certain scripts from reloading, a "noreload" attribute has been added for script elements:
285 | 
286 |     <script noreload="true">
287 | 	
288 | Also, you may wish to do setup on an entity after the game begins, but not run any actual update logic. This means a script object is created, and updated every frame for no reason. To combat this, automatic script "cleaning" has been added, meaning that if only an "init" function is specified, the script will be deleted after running said "init" function. It is possible that during live-scripting, this behaviour may be annoying, if you wish to add other functions while running. In that case, you can specify:
289 | 
290 |     <script noclean="true">
291 | 	
292 | Note that cleaning **only happens** if the script only had an "init" function at startup, the noclean option is only meant to be used if you really have a need for it, in normal use you should **never** specify this option.
293 | 
294 | **[6]** All you need to do to use this system is to add:
295 | ```<haxedef name="ICE_LIVE_RELOAD"/>``` to your project.xml file. Thats it!!!!
296 | If you want control over the exact time between reloads, you can add a ```reloaddelay``` attribute to the root element of your entities.xml file.
297 | 
298 | **[6] Important Notes**: 
299 | 
300 | **This doesn't work for scripts specified in the "text" elements of your xml file**
301 | 
302 | **Make sure to remove ```<haxedef name="ICE_LIVE_RELOAD"/>``` before releasing your game, it is a performance waster, and has no use in a final build.**
303 | 
304 | For more responsive use I recommend adding ```<haxedef name="FLX_NO_FOCUS_LOST_SCREEN"/>``` to your project.xml, and setting ```FlxG.autoPause``` to ```false```. This way, you do not need to give the game focus to see your changes in action.
305 | 
306 | As a rule of thumb, any script that you wish to use the "update" function in should be contained in its own file, not in your xml file. This does two things: keeps your xml file readable, and combats the annoyance of live-reloading not working for internal scripts.
307 |   
308 | **Message System:**
309 | ----------
310 | 
311 | IceEntity now includes a simple message broadcasting system. It is a useful way of quickly sending information or data between objects, without needing to store a reference. Simply call ```SendMessage()``` on an entity, with any info you need to send (explained in the method details). To receive messages, simply override the ```ReceiveMessage()``` function on an entity, and use that as a simple way to do whatever you want with the messages data, no need to manage a complicated event listener setup:)
312 |   
313 |   **Contact/Extra Info:**
314 |   ----------
315 |   
316 |   It should be fairly self explanatory, but if not, you can get in touch with me on twitter: [@nico_m__](https://twitter.com/nico_m__).
317 | 


--------------------------------------------------------------------------------
/buildpackage.bat:
--------------------------------------------------------------------------------
 1 | rmdir packagetemp /s /q
 2 | mkdir packagetemp
 3 | 
 4 | xcopy ice packagetemp\ice /S /I /Y 
 5 | xcopy haxelib.json packagetemp /Y
 6 | xcopy README.md packagetemp /Y
 7 | xcopy LICENSE.md packagetemp /Y
 8 | xcopy CHANGELOG.md packagetemp /Y
 9 | 
10 | cd packagetemp
11 | 7za a -tzip iceentity.zip 
12 | 
13 | haxelib submit iceentity.zip
14 | 


--------------------------------------------------------------------------------
/haxelib.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "iceentity",
 3 |   "url" : "https://github.com/NicoM1/IceEntity",
 4 |   "license": "MIT",
 5 |   "tags": ["game", "openfl", "flixel", "haxeflixel", "flash", "neko", "cpp", "android", "ios", "cross"],
 6 |   "description": "Simple entity and component management for haxeflixel",
 7 |   "version": "1.3.0",
 8 |   "releasenote": "api for accessing script variables with type-safety",
 9 |   "contributors": ["NicoM1"],
10 |   "dependencies": { "lime": "", "openfl": "", "flixel": "", "hscript": ""}
11 | }
12 | 


--------------------------------------------------------------------------------
/ice/entity/Component.hx:
--------------------------------------------------------------------------------
 1 | package ice.entity;
 2 | 
 3 | class Component
 4 | {
 5 | 	 ///GID of owner
 6 | 	public var GID : Int;
 7 | 	 ///Actual owner entity, null until init()
 8 | 	public var owner : Entity;
 9 | 	
10 | 	private var initialized = false;
11 | 	
12 | 	public var type : String;
13 | 	
14 | 	public function new(Owner : Int) 
15 | 	{
16 | 		this.GID = Owner;
17 | 	}
18 | 	
19 | 	public function GetOwner() : Entity
20 | 	{
21 | 		return EntityManager.getInstance().GetEntity(GID);
22 | 	}
23 | 	
24 | 	public function GetComponentOnOwner<T:Component>(type:Class<T>):T
25 | 	{
26 | 		return GetOwner().GetComponent(type);
27 | 	}
28 | 	
29 | 	public function Update()
30 | 	{
31 | 		if (!initialized)
32 | 		{
33 | 			init();
34 | 			initialized = true;
35 | 		}
36 | 	}	
37 | 			
38 | 	private function init()
39 | 	{
40 | 		owner = GetOwner();
41 | 	}
42 | 	
43 | 	public function destroy()
44 | 	{
45 | 		owner = null;
46 | 	}
47 | }


--------------------------------------------------------------------------------
/ice/entity/Entity.hx:
--------------------------------------------------------------------------------
  1 | package ice.entity;
  2 | 
  3 | import flash.geom.Point;
  4 | import flixel.FlxBasic;
  5 | import flixel.FlxSprite;
  6 | import flixel.FlxObject;
  7 | import ice.parser.ScriptHolder;
  8 | import ice.fsm.FSM;
  9 | 
 10 | class Entity extends FlxSprite
 11 | {
 12 | 	
 13 | 	///A specific identifier, unique to this object, Ex: "01" GID = entity ID, only named that so it does not interfere with flixel
 14 | 	public var GID(default, null):Int;
 15 | 	
 16 | 	///A general identifier, for grouping objects, Ex: "Enemy"
 17 | 	public var Tag:String;
 18 | 	
 19 | 	public var scripts(default,null):ScriptHolder;
 20 | 	
 21 | 	public var Parent(default, null):Int;
 22 | 	
 23 | 	//used internally, changing this has no effect
 24 | 	public var depth:Int = 1;
 25 | 	
 26 | 	public var FSMs:Array<FSM>;
 27 | 	public var FSM(get, null):FSM;
 28 | 	
 29 | 	inline function get_FSM():FSM
 30 | 	{
 31 | 		if (FSMs[0] == null)
 32 | 		{
 33 | 			FSMs[0] = new FSM();
 34 | 		}
 35 | 		return FSMs[0];
 36 | 	}
 37 | 	
 38 | 	///The key is a unique identifer, used to acces individual components
 39 | 	private var components:Array<Component>; //used to be a map, but individual access is not needed, and this saves on garbage. Just don't try to add multiples of a type of component
 40 | 	
 41 | 	private var children:Array<Int>;
 42 | 	
 43 | 	private var initialized = false;
 44 | 	
 45 | 	///GID Can't Be 0, 0 will switch to -1, if left -1, GID will be auto asigned
 46 | 	public function new(?Tag:String, ?Positon:Point, ?GID:Int = -1, ?Parent:Int = -1) 
 47 | 	{
 48 | 		if (Positon == null)
 49 | 		{
 50 | 			Positon = new Point();
 51 | 		}
 52 | 		
 53 | 		super(Positon.x, Positon.y);
 54 | 		
 55 | 		if (GID == -1 || GID == 0)
 56 | 		{
 57 | 			this.GID = (EntityManager.getInstance().highestGID++);
 58 | 		}
 59 | 		else
 60 | 		{
 61 | 			this.GID = GID;
 62 | 		}
 63 | 		
 64 | 		this.Tag = Tag;
 65 | 		
 66 | 		this.Parent = Parent;
 67 | 		
 68 | 		components = new Array<Component>();
 69 | 		children = new Array<Int>();	
 70 | 		scripts = new ScriptHolder(this);
 71 | 		FSMs = new Array<FSM>();
 72 | 	}
 73 | 	
 74 | 	public function AddChild(childGID:Int)
 75 | 	{
 76 | 		for (c in children)
 77 | 		{
 78 | 			if (c == childGID)
 79 | 			{
 80 | 				return;
 81 | 			}
 82 | 		}
 83 | 		children.push(childGID);
 84 | 	}
 85 | 	
 86 | 	public function GetChildren() : Array<Entity>
 87 | 	{
 88 | 		var childG : Array<Entity> = new Array<Entity>();
 89 | 		for (c in children)
 90 | 		{
 91 | 			childG.push(EntityManager.getInstance().GetEntity(c));
 92 | 		}
 93 | 		return childG;
 94 | 	}
 95 | 	
 96 | 	public function GetChildrenWithTag(tag:String) : Array<Entity>
 97 | 	{
 98 | 		var childG : Array<Entity> = new Array<Entity>();
 99 | 		var child : Entity;
100 | 		for (c in children)
101 | 		{
102 | 			child = EntityManager.getInstance().GetEntity(c);
103 | 			if (child.Tag == tag)
104 | 			{
105 | 				childG.push(child);
106 | 			}
107 | 		}
108 | 		return childG;
109 | 	}	
110 | 		
111 | 	public function GetChildWithTag(tag:String) : Entity
112 | 	{
113 | 		var child : Entity;
114 | 		for (c in children)
115 | 		{
116 | 			child = EntityManager.getInstance().GetEntity(c);
117 | 			if (child.Tag == tag)
118 | 			{
119 | 				return child;
120 | 			}
121 | 		}
122 | 		
123 | 		return null;
124 | 	}
125 | 	
126 | 	//gets a component on this entity, this call is fairly heavy, you should cash the result
127 | 	public function GetComponent<T:Component>(type:Class<T>):T
128 | 	{
129 | 		var name = Type.getClassName(type);
130 | 		
131 | 		for (c in components)
132 | 		{
133 | 			if (c.type == name)
134 | 			{
135 | 				return cast c;
136 | 			}
137 | 		}
138 | 		return null;
139 | 	}
140 | 	
141 | 	//adds a component to this entity
142 | 	public function AddComponent<T:Component>(component:T)
143 | 	{
144 | 		var type = Type.getClass(component);
145 | 		var name = Type.getClassName(type);
146 | 		component.type = name;
147 | 		components.push(component);
148 | 	}
149 | 	
150 | 	public function GetParent() : Entity
151 | 	{
152 | 		return EntityManager.getInstance().GetEntity(Parent);
153 | 	}
154 | 	
155 | 	override public function update(elapsed:Float):Void 
156 | 	{
157 | 		if (!initialized)
158 | 		{
159 | 			init();
160 | 			initialized = true;
161 | 		}
162 | 
163 | 		for (c in components)
164 | 		{
165 | 			c.Update();
166 | 		}
167 | 		
168 | 		scripts.Update();
169 | 		
170 | 		if (FSMs == null)
171 | 		{
172 | 			//SAFETY CHECK IN CASE OF DESTRUCTION DURING UPDATE
173 | 			return;
174 | 		}
175 | 		
176 | 		for (fsm in FSMs)
177 | 		{
178 | 			fsm.Update();
179 | 			if (FSMs == null)
180 | 			{
181 | 				return;
182 | 			}
183 | 		}
184 | 		
185 | 		super.update(elapsed);
186 | 	}
187 | 	
188 | 	public function loadAnimation(name:String, frames:String, frameRate:Int = 10, looped:Bool = false)
189 | 	{	
190 | 		var framesSA:Array<String>;
191 | 		framesSA = frames.split(",");
192 | 		
193 | 		var framesIA:Array<Int>;
194 | 		framesIA = new Array<Int>();
195 | 		
196 | 		for (frame in framesSA)
197 | 		{
198 | 			var frameList:Array<String> = frame.split("-");
199 | 			if (frameList.length == 2)
200 | 			{
201 | 				var start:Int = Std.parseInt(frameList[0]);
202 | 				var end:Int = Std.parseInt(frameList[1]);
203 | 				var index:Int;
204 | 				
205 | 				if (start < end)
206 | 				{
207 | 					index = start;
208 | 					while (index <= end)
209 | 					{
210 | 						framesIA.push(index++);
211 | 					}
212 | 				}
213 | 				else if (start > end)
214 | 				{
215 | 					index = start;
216 | 					while (index >= end)
217 | 					{
218 | 						framesIA.push(index--);
219 | 					}
220 | 				}
221 | 			}
222 | 			else
223 | 			{
224 | 				framesIA.push(Std.parseInt(frame));
225 | 			}
226 | 		}
227 | 		
228 | 		animation.add(name, framesIA, frameRate, looped);
229 | 	}
230 | 	
231 | 	public function IsAgainst(surface:FlxBasic, direction:Int) : Bool
232 | 	{
233 | 		switch (direction)
234 | 		{
235 | 			case FlxObject.LEFT:
236 | 				{
237 | 					return overlapsAt(x - 1, y, surface);
238 | 				}
239 | 			case FlxObject.RIGHT:
240 | 				{
241 | 					return overlapsAt(x + 1, y, surface);
242 | 				}
243 | 			case FlxObject.UP:
244 | 				{
245 | 					return overlapsAt(x, y - 1, surface);
246 | 				}
247 | 			case FlxObject.DOWN:
248 | 				{
249 | 					return overlapsAt(x, y + 1, surface);
250 | 				}
251 | 			case FlxObject.WALL:
252 | 				{
253 | 					return overlapsAt(x + 1, y, surface) || overlapsAt(x - 1, y, surface);
254 | 				}
255 | 			case FlxObject.ANY:
256 | 				{
257 | 					return overlapsAt(x + 1, y, surface) || overlapsAt(x - 1, y, surface) || overlapsAt(x, y - 1, surface) || overlapsAt(x, y + 1, surface);
258 | 				}
259 | 		}
260 | 		
261 | 		return false;
262 | 	}
263 | 	
264 | 	/**
265 | 	 * Gets the distance between two FlxObjects
266 | 	 * @param	a	First object
267 | 	 * @param	?b	Second object, defaults to this entity
268 | 	 * @return
269 | 	 */
270 | 	public function GetDistance(a:FlxObject, ?b:FlxObject = null):Float
271 | 	{
272 | 		if (b == null)
273 | 		{
274 | 			b = this;
275 | 		}
276 | 		var XX = b.getMidpoint().x - a.getMidpoint().x;
277 | 		var YY = b.getMidpoint().y - a.getMidpoint().y;
278 | 		return Math.sqrt(XX * XX + YY * YY);
279 | 	}
280 | 	
281 | 	/**
282 | 	 * Simple function for sending messages between entities
283 | 	 * @param	messageCode		An int ID, for determining message type
284 | 	 * @param	target			An optional specific GID for this message to be sent to
285 | 	 * @param	?value			An optional value, for sending larger or more specific data
286 | 	 * @param	?receiveOwn		Whether to allow this object to receive its own sent messages
287 | 	 */
288 | 	public function SendMessage(messageCode:Int, ?target:Int, ?value:Dynamic, ?receiveOwn:Bool = false) 
289 | 	{
290 | 		EntityManager.getInstance().SendMessage(GID, messageCode, target, value, receiveOwn);
291 | 	}
292 | 	
293 | 	/**
294 | 	 * Override this to handle messages, [no need to call super(etc.)]
295 | 	 * @param	sender			Entity that originally sent the message
296 | 	 * @param	messageCode		An int ID, for determining message type
297 | 	 * @param	?value			An optional value, possibly carrying larger or more specific data
298 | 	 */
299 | 	public function ReceiveMessage(sender:Int, messageCode:Int, ?value:Dynamic)
300 | 	{
301 | 		
302 | 	}
303 | 			
304 | 	private function init()
305 | 	{
306 | 		
307 | 	}
308 | 	
309 | 	override public function destroy()
310 | 	{
311 | 		if (components != null)
312 | 		{
313 | 			for (c in components)
314 | 			{
315 | 				c.destroy();
316 | 			}
317 | 		}	
318 | 		if (scripts != null)
319 | 		{
320 | 			scripts.Destroy();
321 | 			scripts = null;
322 | 		}
323 | 		components = null;
324 | 		children = null;
325 | 		if (FSMs != null)
326 | 		{
327 | 			for (f in FSMs)
328 | 			{
329 | 				f.destroy();
330 | 			}
331 | 		}
332 | 		FSMs = null;
333 | 
334 | 		super.destroy();
335 | 	}
336 | 	
337 | 	/**
338 | 	 * Get a variable or function from a script on this object as a dynamic variable
339 | 	 * @param	varName		name of the variable or function
340 | 	 * @param	script		id of script variable is specified in
341 | 	 * @return
342 | 	 */
343 | 	public inline function getVarAsDynamic(varName:String, script:Int = 0):Dynamic
344 | 	{
345 | 		return scripts.scripts[script].getVarAsDynamic(varName);
346 | 	}
347 | 	
348 | 	/**
349 | 	 * Get a variable (not a function) from a script on this object as a typed variable
350 | 	 * @param	varName		name of the variable
351 | 	 * @param	script		id of script variable is specified in
352 | 	 * @return
353 | 	 */
354 | 	public function getVar<T>(varName:String, type:Class<T>, script:Int = 0):T
355 | 	{
356 | 		return scripts.scripts[script].getVar(varName, type);
357 | 	}
358 | 	
359 | 	public inline function setVar(varName:String, value:Dynamic, script:Int = 0)
360 | 	{
361 | 		scripts.scripts[script].setVar(varName, value);
362 | 	}
363 | }
364 | 


--------------------------------------------------------------------------------
/ice/entity/EntityManager.hx:
--------------------------------------------------------------------------------
  1 | package ice.entity;
  2 | 
  3 | import flash.geom.Point;
  4 | import flixel.FlxBasic;
  5 | import flixel.FlxG;
  6 | import flixel.FlxObject;
  7 | import flixel.FlxSprite;
  8 | import flixel.group.FlxGroup;
  9 | import flixel.tile.FlxTilemap;
 10 | import haxe.zip.Entry.ExtraField;
 11 | import hscript.Expr;
 12 | import ice.parser.Script;
 13 | import ice.parser.ScriptHandler;
 14 | import openfl.Assets;
 15 | import openfl.events.Event;
 16 | 
 17 | class EntityManager extends FlxGroup
 18 | {
 19 | 	///a singleton instance of this class
 20 | 	public static var instance(get, null):EntityManager;
 21 | 	private static var _instance:EntityManager;
 22 | 	
 23 | 	///Int corresponds to GID of entity, for faster access
 24 | 	public var entities(default, null):Array<Entity>;
 25 | 	private var groups:Map<String, FlxTypedGroup<Entity>>;
 26 | 	
 27 | 	private var templates:Map<String,Xml>;
 28 | 	private var prefabs:Map<String,Xml>;
 29 | 	
 30 | 	///highest current GID of any entity, used for autoasigning GIDs
 31 | 	public var highestGID(default, default):Int = 0;
 32 | 	
 33 | 	public var bg(default, null):FlxGroup;
 34 | 	public var mg(default, null):FlxGroup;
 35 | 	public var fg(default, null):FlxGroup;
 36 | 	
 37 | 	var sceneSwitch:Bool = false;
 38 | 	
 39 | 	//{ Constructor and Instance
 40 | 	private function new()
 41 | 	{
 42 | 		super();
 43 | 		entities = new Array<Entity>();
 44 | 		groups = new Map<String, FlxTypedGroup<Entity>>();
 45 | 		templates = new Map<String, Xml>();
 46 | 		prefabs = new Map<String, Xml>();
 47 | 		highestGID = 0;		
 48 | 		
 49 | 		bg = new FlxGroup();
 50 | 		add(bg);
 51 | 		mg = new FlxGroup();
 52 | 		add(mg);
 53 | 		fg = new FlxGroup();
 54 | 		add(fg);
 55 | 	} 
 56 | 	
 57 | 		
 58 | 	private function reset()
 59 | 	{
 60 | 		members = [];
 61 | 		entities = new Array<Entity>();
 62 | 		groups = new Map<String, FlxTypedGroup<Entity>>();
 63 | 		templates = new Map<String, Xml>();
 64 | 		prefabs = new Map<String, Xml>();
 65 | 		highestGID = 0;			
 66 | 				
 67 | 		bg = new FlxGroup();
 68 | 		add(bg);
 69 | 		mg = new FlxGroup();
 70 | 		add(mg);
 71 | 		fg = new FlxGroup();
 72 | 		add(fg);
 73 | 	}
 74 | 	
 75 | 	///gets the static instance of the manager
 76 | 	public static function getInstance() : EntityManager
 77 | 	{
 78 | 		if (_instance == null)
 79 | 		{
 80 | 			_instance = new EntityManager();
 81 | 		}
 82 | 		
 83 | 		return _instance;
 84 | 	}
 85 | 	public static inline function get_instance() : EntityManager
 86 | 	{
 87 | 		return getInstance();
 88 | 	}
 89 | 	//}
 90 | 
 91 | 	//{ Entity Parser
 92 | 	/**
 93 | 	 * Empties the manager and then loads one or more xml scene files
 94 | 	 * @param	XMLs	array of paths to xml scenes
 95 | 	 */
 96 | 	public static function switchScene(XMLs:Array<String>)
 97 | 	{
 98 | 		EntityManager.empty();
 99 | 
100 | 		for (s in XMLs)
101 | 		{
102 | 			EntityManager.instance.BuildFromXML(s, true);
103 | 		}
104 | 		EntityManager.instance.sceneSwitch = true;
105 | 	}
106 | 	
107 | 	/**
108 | 	 * Builds entities from an xml file Important: any components needed MUST be imported somewhere in your code
109 | 	 * @param	path		path to the xml
110 | 	 * @param	useAssets	whether to use openfl.assets, required for flash
111 | 	 */
112 | 	public function BuildFromXML(path:String, ?useAssets:Bool = true)
113 | 	{
114 | 		var Root:Xml;
115 | 		Root = Xml.parse(IceUtil.LoadString(path, useAssets));
116 | 		Root = Root.firstElement();
117 | 		
118 | 		if (Root.exists("reloaddelay"))
119 | 		{
120 | 			ScriptHandler.SetReloadDelay(Std.parseFloat(Root.get("reloaddelay")));
121 | 		}
122 | 		
123 | 		for (e in Root.elements())
124 | 		{
125 | 			switch(e.nodeName)
126 | 			{
127 | 				case "entity":
128 | 					var ent = ParseEntity(e);
129 | 					if (ent != null)
130 | 					{
131 | 						AddEntity(ent,ent.depth);
132 | 					}
133 | 					
134 | 				case "instance":
135 | 					ParseInstance(e);
136 | 					
137 | 				case "script":
138 | 					ParseScript(e, null);
139 | 					
140 | 				case "load":
141 | 					BuildFromXML(e.get("path"));
142 | 				case "prefab":
143 | 					prefabs.set(e.get("name"), e);
144 | 				default:
145 | 					throw "unrecognized element: " + e.nodeName;
146 | 			}
147 | 		}
148 | 	}
149 | 	
150 | 	private function ParseInstance(instance:Xml):Entity
151 | 	{
152 | 		if (!instance.exists("template") && !instance.exists("prefab"))
153 | 		{
154 | 			throw "template or prefab not specified";
155 | 		}
156 | 		
157 | 		var template:String = instance.get("template");
158 | 		var prefab:String = null;
159 | 		
160 | 		if (template == null)
161 | 		{
162 | 			prefab = instance.get("prefab");
163 | 		}
164 | 		
165 | 		var newTag:String = null;
166 | 		var newX:String = null;
167 | 		var newY:String = null;
168 | 		
169 | 		if (instance.exists("tag"))
170 | 		{
171 | 			newTag = instance.get("tag");
172 | 		}
173 | 		if (instance.exists("x"))
174 | 		{
175 | 			newX = instance.get("x");
176 | 		}
177 | 		if (instance.exists("y"))
178 | 		{
179 | 			newY = instance.get("y");
180 | 		}
181 | 		var e:Entity;
182 | 		if (template != null)
183 | 		{
184 | 			e = instantiate(template, newTag, newX, newY);
185 | 		}
186 | 		else
187 | 		{
188 | 			instantiatePrefab(prefab, newX, newY);
189 | 			return null;
190 | 		}
191 | 		AddEntity(e, e.depth);
192 | 		return e;
193 | 	}
194 | 	
195 | 	/**
196 | 	 * Creates an instance of a "prefab" as specified by a <prefab> declaration and adds it to the manager
197 | 	 * @param	name	name of prefab to instantiate	
198 | 	 * @param	offsetX x-offset to add to any entities contained in prefab (string to allow %'s of width/height: 90%)
199 | 	 * @param	offsetY y-offset to add to any entities contained in prefab (string to allow %'s of width/height: 90%)
200 | 	 */
201 | 	public function instantiatePrefab(name:String, offsetX:String, offsetY:String)
202 | 	{
203 | 		if (!prefabs.exists(name))
204 | 		{
205 | 			throw "specified prefab not found: " + name;
206 | 		}
207 | 		for (e in prefabs.get(name).elements())
208 | 		{
209 | 			switch(e.nodeName)
210 | 			{
211 | 				case "entity":
212 | 					var ent = ParseEntity(e);
213 | 					if (ent != null)
214 | 					{
215 | 						ent.x += getPixel(offsetX, true);
216 | 						ent.y += getPixel(offsetY, false);
217 | 						AddEntity(ent);
218 | 					}
219 | 					
220 | 				case "instance":
221 | 					var ent = ParseInstance(e);
222 | 					if (ent != null)
223 | 					{
224 | 						ent.x += getPixel(offsetX, true);
225 | 						ent.y += getPixel(offsetY, false);
226 | 					}
227 | 					
228 | 				case "script":
229 | 					ParseScript(e, null);
230 | 					
231 | 				case "load":
232 | 					throw "load element is not allowed in prefab declarations";
233 | 				case "prefab":
234 | 					throw "prefab element is not allowed in prefab declarations";
235 | 				default:
236 | 					throw "unrecognized element: " + e.nodeName;
237 | 			}
238 | 		}
239 | 	}
240 | 	
241 | 	/**
242 | 	 * Create an instance of a "template" as specified by a <template> declaration, NOT AUTOMATICALLY ADDED TO MANAGER
243 | 	 * @param	template	name of template to instantiate
244 | 	 * @param	newTag		tag to override original with
245 | 	 * @param	newX		x-position to override original with (string to allow %'s of width/height: 90%)
246 | 	 * @param	newY		y-position to override original with (string to allow %'s of width/height: 90%)
247 | 	 * @return				use EntityManager.instance.AddEntity(result) to add this entity to the scene
248 | 	 */
249 | 	public function instantiate(template:String, ?newTag:String, ?newX:String, ?newY:String):Entity
250 | 	{
251 | 		if (!templates.exists(template))
252 | 		{
253 | 			throw "specified template not found: " + template;
254 | 		}
255 | 		
256 | 		var entityXML:Xml = templates.get(template);
257 | 		
258 | 		var entity:Entity = ParseEntity(entityXML);
259 | 		
260 | 		if (newTag != null)
261 | 		{
262 | 			entity.Tag = newTag;
263 | 		}
264 | 		if (newX != null)
265 | 		{
266 | 			entity.x = getPixel(newX, true);
267 | 		}
268 | 		if (newY != null)
269 | 		{
270 | 			entity.y = getPixel(newY, false);
271 | 		}
272 | 		
273 | 		return entity;
274 | 	}
275 | 	
276 | 	private function ParseEntity(entity:Xml):Entity
277 | 	{
278 | 		//Get entity's tag
279 | 		var tag:String = entity.get("tag");
280 | 
281 | 		//Get entity's position
282 | 		var pos:Point = new Point();
283 | 		pos.x = getPixel(entity.get("x"), true);
284 | 		pos.y = getPixel(entity.get("y"), false);
285 | 		
286 | 		//build entity
287 | 		var ent:Entity = new Entity(tag, pos);
288 | 		
289 | 		if (entity.exists("template"))
290 | 		{
291 | 			if (!templates.exists(entity.get("template")))
292 | 			{
293 | 				templates.set(entity.get("template"), entity);
294 | 				
295 | 				if (entity.get("instance") != "true" && entity.get("instance") != "True")
296 | 				{
297 | 					return null;
298 | 				}
299 | 			}
300 | 		}
301 | 		
302 | 		if (entity.exists("depth"))
303 | 		{
304 | 			switch(entity.get("depth"))
305 | 			{
306 | 				case "bg":
307 | 					ent.depth = 0;
308 | 				case "mg":
309 | 					ent.depth = 1;
310 | 				case "fg":
311 | 					ent.depth = 2;
312 | 			}
313 | 		}
314 | 		
315 | 		//load in art/animation
316 | 		for (art in entity.elementsNamed("art"))
317 | 		{
318 | 			var width:Int; 
319 | 			width = Std.parseInt(art.get("width"));
320 | 			
321 | 			var height:Int;
322 | 			height = Std.parseInt(art.get("height"));
323 | 			
324 | 			var path:String;
325 | 			path = art.get("path");
326 | 			
327 | 			ent.loadGraphic(path, true, width, height);
328 | 			
329 | 			if (art.firstChild() != null)
330 | 			{
331 | 				for (animation in art.elementsNamed("animation"))
332 | 				{
333 | 					var name:String;
334 | 					name = animation.get("name");
335 | 					
336 | 					var framerate:Int;
337 | 					framerate = Std.parseInt(animation.get("framerate"));
338 | 					
339 | 					var looped:Bool;
340 | 					if (animation.get("looped") == "true")
341 | 					{
342 | 						looped = true;
343 | 					}
344 | 					else
345 | 					{
346 | 						looped = false;
347 | 					}
348 | 					
349 | 					var framesS:String;
350 | 					framesS = animation.get("frames");
351 | 					
352 | 					ent.loadAnimation(name, framesS, framerate, looped);
353 | 					
354 | 					if (animation.exists("autorun"))
355 | 					{
356 | 						if (animation.get("autorun") == "true" || animation.get("autorun") == "True")
357 | 						{
358 | 							ent.animation.play(animation.get("name"));
359 | 						}
360 | 					}
361 | 				}
362 | 			}
363 | 		}
364 | 		
365 | 		for (component in entity.elementsNamed("component"))
366 | 		{		
367 | 			var params:Array<Dynamic>;
368 | 			params = new Array<Dynamic>();
369 | 			params.push(ent.GID);
370 | 			
371 | 			if (component.firstChild() != null)
372 | 			{
373 | 				for (param in component.elementsNamed("param"))
374 | 				{
375 | 					var type:String;
376 | 					type = param.get("type").toLowerCase();
377 | 					
378 | 					var value:String;
379 | 					value = param.get("value");
380 | 					
381 | 					switch(type)
382 | 					{
383 | 						case ("int"):
384 | 						{
385 | 							params.push(Std.parseInt(value));
386 | 						}
387 | 						case ("float"):
388 | 						{
389 | 							params.push(Std.parseFloat(value));
390 | 						}
391 | 						case ("bool"):
392 | 						{
393 | 							if (value == "true" || value == "True")
394 | 							{
395 | 								params.push(true);
396 | 							}
397 | 							else
398 | 							{
399 | 								params.push(false);
400 | 							}
401 | 						}
402 | 						default:
403 | 						{
404 | 							params.push(value);
405 | 						}
406 | 					}
407 | 				}
408 | 			}
409 | 			
410 | 			try 
411 | 			{
412 | 				var classType = Type.resolveClass(component.get("type"));
413 | 				var newComponent = Type.createInstance(classType, params);
414 | 				ent.AddComponent(newComponent);
415 | 			}
416 | 			catch (msg:Dynamic)
417 | 			{
418 | 				throw ("Unable to resolve class from xml: " + msg);
419 | 			}
420 | 		}
421 | 		
422 | 		for (script in entity.elementsNamed("script"))
423 | 		{
424 | 			ParseScript(script, ent);
425 | 		}
426 | 		
427 | 		return ent;
428 | 	}
429 | 	
430 | 	public function ParseScript(?script:Xml, ?owner:Entity, ?scriptPath:String)
431 | 	{
432 | 		var file:String = "";
433 | 		
434 | 		var path:String = "";
435 | 		
436 | 		if (script != null)
437 | 		{
438 | 			path = script.get("path");
439 | 			if (path == null)
440 | 			{
441 | 				path = "";
442 | 			}
443 | 		}
444 | 		else
445 | 		{
446 | 			path = scriptPath;
447 | 		}
448 | 		
449 | 		if (path != "")
450 | 		{
451 | 			#if !ICE_LIVE_RELOAD
452 | 			file = IceUtil.LoadString(path, true);
453 | 			#else
454 | 			file = IceUtil.LoadString(path, false);
455 | 			#end
456 | 		}
457 | 		else if (script != null)
458 | 		{
459 | 			for (text in script.elementsNamed("text"))
460 | 			{
461 | 				file = text.firstChild().nodeValue;
462 | 			}
463 | 		}
464 | 		
465 | 		var ParsedScript:Script = new Script(file, path);
466 | 		
467 | 		if (script != null)
468 | 		{
469 | 			for (request in script.elementsNamed("request"))
470 | 			{
471 | 				var module = ScriptHandler.GetModule(request.get("name"));
472 | 				
473 | 				ParsedScript.interp.variables.set(request.get("name"), module);
474 | 			}
475 | 			
476 | 			for (expose in script.elementsNamed("expose"))
477 | 			{
478 | 				var path = expose.get("path");
479 | 
480 | 				var module = ScriptHandler.GetClass(path);
481 | 
482 | 				ParsedScript.interp.variables.set(expose.get("name"), module);
483 | 			}
484 | 			
485 | 			if (script.exists("noreload"))
486 | 			{
487 | 				if (script.get("noreload") == "true")
488 | 				{
489 | 					ParsedScript.noReload = true;
490 | 				}
491 | 			}
492 | 			
493 | 			if (script.exists("noclean"))
494 | 			{
495 | 				if (script.get("noclean") == "true")
496 | 				{
497 | 					ParsedScript.noClean = true;
498 | 				}
499 | 			}
500 | 		}
501 | 		
502 | 		if (owner != null)
503 | 		{
504 | 			ParsedScript.interp.variables.set("owner", owner);
505 | 			if (script != null)
506 | 			{
507 | 				owner.scripts.Add(ParsedScript, Std.parseInt(script.get("id")));
508 | 			}
509 | 			else
510 | 			{
511 | 				owner.scripts.Add(ParsedScript);
512 | 			}
513 | 		}
514 | 		else
515 | 		{
516 | 			if (script != null)
517 | 			{
518 | 				ScriptHandler.scripts.Add(ParsedScript, Std.parseInt(script.get("id")));
519 | 			}
520 | 			else
521 | 			{
522 | 				ScriptHandler.scripts.Add(ParsedScript);
523 | 			}
524 | 		}
525 | 	}
526 | 	
527 | 	private function getPixel(input:String, x:Bool):Int
528 | 	{
529 | 		if (input == null)
530 | 		{
531 | 			return 0;
532 | 		}
533 | 		
534 | 		var percent:Int = input.indexOf("%");
535 | 		if (percent < 0)
536 | 		{
537 | 			return Std.parseInt(input);
538 | 		}
539 | 		
540 | 		input = input.substring(0, percent);
541 | 		
542 | 		var of:Int = x? FlxG.width : FlxG.height;
543 | 		
544 | 		return Std.int(Std.parseInt(input) / 100 * of);
545 | 	}
546 | 	//}
547 | 	
548 | 	//{ Add Items
549 | 	/**
550 | 	 * Adds an entity to the manager
551 | 	 * @param	entity		entity to be added.
552 | 	 * @param	depth		0:bg,1:mg,2:fg. Defaults to just adding to main group (above fg).
553 | 	 */
554 | 	public function AddEntity(entity : Entity, depth:Int=-1)
555 | 	{ 
556 | 		entities[entity.GID] = entity;
557 | 		switch(depth)
558 | 		{
559 | 			case 0: bg.add(entity);
560 | 			case 1: mg.add(entity);
561 | 			case 2:	fg.add(entity);
562 | 			default: add(entity);
563 | 		}
564 | 	}
565 | 	
566 | 	/**
567 | 	 * Adds a flixel object to the scene, just for easy rendering, no fancy referencing
568 | 	 * @param	basic	whatever type of flixel object you want to add
569 | 	 * @param	depth		0:bg,1:mg,2:fg. Defaults to just adding to main group (above fg).
570 | 	 */
571 | 	public function AddFlxBasic(basic:FlxBasic, depth:Int=-1)
572 | 	{
573 | 		switch(depth)
574 | 		{
575 | 			case 0: bg.add(basic);
576 | 			case 1: mg.add(basic);
577 | 			case 2:	fg.add(basic);
578 | 			default: add(basic);
579 | 		}
580 | 	}
581 | 	
582 | 	/**
583 | 	 * Adds a group to the manager
584 | 	 * @param	group	group of entities to add
585 | 	 * @param	name	name to reference this group
586 | 	 * @param	depth		0:bg,1:mg,2:fg. Defaults to just adding to main group (above fg).
587 | 	 */
588 | 	public function AddGroup(group:FlxTypedGroup<Entity>, name:String, depth:Int=-1):Void 
589 | 	{
590 | 		switch(depth)
591 | 		{
592 | 			case 0: bg.add(group);
593 | 			case 1: mg.add(group);
594 | 			case 2:	fg.add(group);
595 | 			default: add(group);
596 | 		}
597 | 		groups.set(name, group);
598 | 	}
599 | 	//}
600 | 	
601 | 	//{ Removal and Destruction
602 | 	
603 | 	/**
604 | 	 * removes a entity from the manager
605 | 	 * @param 	?entity 	a specific entity to remove
606 | 	 * @param	?GID		the identifier of the object to be removed
607 | 	 */
608 | 	public function RemoveEntity(?entity:Entity, ?GID:Int)
609 | 	{
610 | 		if (GID != 0)
611 | 		{
612 | 			GetEntity(GID).destroy();
613 | 			remove(GetEntity(GID), true);
614 | 			entities[GID] = null;
615 | 		}
616 | 		else
617 | 		{
618 | 			entity.destroy();
619 | 			remove(entity, true);
620 | 			entities[entity.GID] = null;
621 | 		}
622 | 	}
623 | 	
624 | 	/**
625 | 	 * Removes an entity that was in a group, THIS REMOVES ENTITY COMPLETELY, if you wish to keep the entity in the manager, just use GetGroup().remove()
626 | 	 * @param	?entity		a specific entity to remove
627 | 	 * @param	?GID		the identifier of the object to be removed
628 | 	 * @param	group		the group the entity belonged to
629 | 	 */
630 | 	public function RemoveFromGroup(?entity:Entity, ?GID:Int = 0, group:String)
631 | 	{
632 | 		if (entity == null)
633 | 		{
634 | 			if (GID == 0)
635 | 			{
636 | 				throw "either a specific entity or a valid GID must be specified";
637 | 			}
638 | 			entity = GetEntity(GID);
639 | 		}
640 | 		GetGroup(group).remove(entity, true);
641 | 		RemoveEntity(entity);
642 | 	}
643 | 	
644 | 	///clears the entire manager, really just calls getInstance().destroy();
645 | 	public static function empty()
646 | 	{
647 | 		getInstance().destroy();
648 | 	}
649 | 	
650 | 	override public function destroy():Void 
651 | 	{
652 | 		//super.destroy();
653 | 		
654 | 		if (members != null)
655 | 		{
656 | 			var i:Int = 0;
657 | 			var basic:FlxBasic = null;
658 | 			
659 | 			while (i < length)
660 | 			{
661 | 				basic = members[i++];
662 | 				
663 | 				if (basic != null)
664 | 				{
665 | 					basic.destroy();
666 | 					members.remove(basic);
667 | 				}	
668 | 			}
669 | 		}
670 | 		
671 | 		ScriptHandler.scripts.Destroy();
672 | 		for (e in entities)
673 | 		{
674 | 			if (e != null)
675 | 			{
676 | 				e.destroy();
677 | 			}
678 | 		}
679 | 		
680 | 		entities = null;
681 | 		members = null;
682 | 		for (g in groups)
683 | 		{
684 | 			g.destroy();
685 | 		}
686 | 		groups = null;
687 | 		templates = null;
688 | 		bg = null;
689 | 		mg = null;
690 | 		fg = null;
691 | 		//_instance = null;
692 | 		reset();
693 | 	}
694 | 	//}
695 | 	
696 | 	//{ Get Items
697 | 	///Returns the entity with the specified GID
698 |     public function GetEntity(GID : Int) : Entity
699 | 	{
700 | 		return entities[GID];
701 | 	}
702 | 	
703 | 	///Returns all entities with a specific tag
704 | 	public function GetEntitiesWithTag(tag : String) : Array<Entity>
705 | 	{
706 | 		var gObjects = new Array<Entity>();
707 | 		
708 | 		for (g in entities)
709 | 		{
710 | 			if (g.Tag == tag)
711 | 			{
712 | 				gObjects.push(g);
713 | 			}
714 | 		}
715 | 		
716 | 		return gObjects;
717 | 	}
718 | 	
719 | 	///Returns the first entity found with a specific tag
720 | 	public function GetEntityByTag(tag : String) : Entity
721 | 	{		
722 | 		for (g in entities)
723 | 		{
724 | 			if (g != null)
725 | 			{
726 | 				if (g.Tag == tag)
727 | 				{
728 | 					return g;
729 | 				}
730 | 			}
731 | 		}
732 | 		
733 | 		return null;
734 | 	}
735 | 	
736 | 	/**
737 | 	 * Gets a group by its identifier
738 | 	 * @param	name	idenifier to access group
739 | 	 * 
740 | 	 */
741 | 	public function GetGroup(name : String) : FlxTypedGroup<Entity>
742 | 	{
743 | 		return groups.get(name);
744 | 	}
745 | 	//}
746 | 	
747 | 	//{ Messages
748 | 	public function SendMessage(sender:Int, messageCode:Int, ?target:Int, ?value:Dynamic, ?receiveOwn:Bool = false)
749 | 	{
750 | 		if (target == null)
751 | 		{
752 | 			for (e in entities)
753 | 			{
754 | 				if (receiveOwn || e.GID != sender)
755 | 				{
756 | 					e.ReceiveMessage(sender, messageCode, value);
757 | 				}
758 | 			}
759 | 		}
760 | 		else
761 | 		{
762 | 			entities[target].ReceiveMessage(sender, messageCode, value);
763 | 		}
764 | 	}
765 | 	//}
766 | 	
767 | 	//{ Update
768 | 	override public function update(elapsed:Float):Void 
769 | 	{
770 | 		do {
771 | 			if (sceneSwitch)
772 | 			{
773 | 				sceneSwitch = false;
774 | 			}
775 | 			
776 | 			ScriptHandler.Update();
777 | 
778 | 			if (sceneSwitch)
779 | 			{
780 | 				continue;
781 | 			}
782 | 			
783 | 			var i:Int = 0;
784 | 			var basic:FlxBasic = null;
785 | 			
786 | 			while (i < length)
787 | 			{
788 | 				basic = members[i++];
789 | 				
790 | 				if (basic != null && basic.exists && basic.active)
791 | 				{
792 | 					basic.update(elapsed);
793 | 				}
794 | 				
795 | 				if (sceneSwitch)
796 | 				{
797 | 					break;
798 | 				}
799 | 			}
800 | 		}while (sceneSwitch);
801 | 	}
802 | 	//}
803 | }
804 | 


--------------------------------------------------------------------------------
/ice/entity/IceUtil.hx:
--------------------------------------------------------------------------------
 1 | package ice.entity;
 2 | 
 3 | import haxe.io.Eof;
 4 | import openfl.Assets;
 5 | #if !flash 
 6 | #if !js
 7 | import sys.io.File;
 8 | import sys.io.FileInput;
 9 | #end
10 | #end
11 | 
12 | /**
13 |  * ...
14 |  * @author 
15 |  */
16 | class IceUtil
17 | {
18 | 	/**
19 | 	 * Loads a text file from disk
20 | 	 * @param	path		relative path to the text file
21 | 	 * @param	useAssets	whether to use Openfl.Assets (required on flash)
22 | 	 */
23 | 	static public function LoadString(path:String, useAssets:Bool):String
24 | 	{
25 | 		var string:String = "";
26 | 		#if (flash || js)
27 | 		if (!useAssets)
28 | 		{
29 | 			throw "run time file loading is not supported on web";
30 | 		}
31 | 		#end
32 | 		if (useAssets)
33 | 		{
34 | 			var ret = Assets.getText(path);
35 | 			if (ret != null)
36 | 			{
37 | 				return ret;
38 | 			}
39 | 			else 
40 | 			{
41 | 				throw "unable to load: " + path;
42 | 			}
43 | 		}
44 | 		else
45 | 		{
46 | 			#if !(flash || js)
47 | 			try
48 | 			{
49 | 				var fileIn = File.read(path, false);
50 | 				while (true)
51 | 				{
52 | 					string += fileIn.readLine() + "\n";
53 | 				}
54 | 				fileIn.close();
55 | 			}
56 | 			catch (ex:Eof)
57 | 			{
58 | 				return string;
59 | 			}
60 | 			catch (e:Dynamic)
61 | 			{
62 | 				throw "unable to load file from: " + path;
63 | 			}
64 | 			#end
65 | 		}
66 | 
67 | 		return string;
68 | 	}
69 | }


--------------------------------------------------------------------------------
/ice/fsm/FSM.hx:
--------------------------------------------------------------------------------
 1 | package ice.fsm;
 2 | 
 3 | class FSM
 4 | {
 5 | 	private var stack:Array<Void->Void>;
 6 | 	
 7 | 	public var info(get, null):Dynamic;
 8 | 	private var infos:Array<Dynamic>;
 9 | 	
10 | 	public inline function get_info():Dynamic
11 | 	{
12 | 		return infos[infos.length -1];
13 | 	}
14 | 	
15 | 	public function new() 
16 | 	{
17 | 		stack = new Array < Void->Void > ();
18 | 		infos = new Array<Dynamic>();
19 | 	}
20 | 	
21 | 	/**
22 | 	 * Updates the current state
23 | 	 */
24 | 	public function Update()
25 | 	{
26 | 		if (stack != null)
27 | 		{
28 | 			stack[stack.length - 1]();
29 | 		}
30 | 	}
31 | 	
32 | 	/**
33 | 	 * Adds a state to the top of the stack
34 | 	 * @param	state	The state to be added
35 | 	 */
36 | 	public function PushState(state:Void->Void, ?info:Dynamic)
37 | 	{
38 | 		stack[stack.length] = state;
39 | 		infos.push(info);
40 | 	}
41 | 	
42 | 	/**
43 | 	 * Removes and returns the current state
44 | 	 */
45 | 	public function PopState():Void->Void
46 | 	{
47 | 		infos.pop();
48 | 		return stack.pop();
49 | 	}
50 | 	
51 | 	/**
52 | 	 * Replaces the current state, and returns it
53 | 	 * @param	state	the new state to be added
54 | 	 */
55 | 	public function ReplaceState(state:Void->Void, ?info:Dynamic):Void->Void
56 | 	{
57 | 		var returnState = PopState();
58 | 		PushState(state,info);
59 | 		return returnState;
60 | 	}
61 | 	
62 | 	public function destroy()
63 | 	{
64 | 		stack = null;
65 | 	}
66 | }


--------------------------------------------------------------------------------
/ice/group/EntityGroup.hx:
--------------------------------------------------------------------------------
 1 | package ice.group;
 2 | 
 3 | import flixel.group.FlxGroup;
 4 | import ice.entity.Entity;
 5 | 
 6 | class EntityGroup extends FlxTypedGroup<Entity>
 7 | {
 8 | 
 9 | 	public function new(MaxSize:Int) 
10 | 	{
11 | 		super(MaxSize);
12 | 	}
13 | 	
14 | }


--------------------------------------------------------------------------------
/ice/parser/IceInterp.hx:
--------------------------------------------------------------------------------
 1 | package ice.parser;
 2 | 
 3 | import hscript.Expr;
 4 | import hscript.Interp;
 5 | 
 6 | class IceInterp extends Interp
 7 | {	
 8 |     override function get( o : Dynamic, f : String ) : Dynamic {
 9 |         if ( o == null ) throw hscript.Expr.Error.EInvalidAccess(f);
10 |         return Reflect.getProperty(o,f);
11 |     }
12 | 
13 |     override function set( o : Dynamic, f : String, v : Dynamic ) : Dynamic {
14 |         if( o == null ) throw hscript.Expr.Error.EInvalidAccess(f);
15 |         Reflect.setProperty(o,f,v);
16 |         return v;
17 |     }
18 | }


--------------------------------------------------------------------------------
/ice/parser/Script.hx:
--------------------------------------------------------------------------------
  1 | package ice.parser;
  2 | 
  3 | import hscript.Expr;
  4 | import hscript.Interp;
  5 | import ice.entity.IceUtil;
  6 | import openfl.Assets;
  7 | 
  8 | class Script
  9 | {
 10 | 	public var interp:IceInterp;
 11 | 	var updateScript:Expr;
 12 | 	var destroyScript:Expr;
 13 | 	var script:String;
 14 | 	var newScript:String;
 15 | 	var init:Bool = false;
 16 | 	var path:String = "";
 17 | 	public var noReload = false;
 18 | 	public var doClean(default,null):Bool = false;
 19 | 	public var noClean:Bool = false;
 20 | 	
 21 | 	public function new(script:String, ?path:String = "") 
 22 | 	{		
 23 | 		this.script = script;
 24 | 		this.path = path;
 25 | 		
 26 | 		interp = new IceInterp();
 27 | 		interp.variables.set("newObject", function():Dynamic{ 
 28 | 			return {}; 
 29 | 		}); 
 30 | 		
 31 | 		ScriptHandler.ParseImports(script, interp);
 32 | 		updateScript = ScriptHandler.Parse("update", script);
 33 | 		destroyScript = ScriptHandler.Parse("destroy", script);
 34 | 	}
 35 | 	
 36 | 	function Init() 
 37 | 	{		
 38 | 		var initS = ScriptHandler.Parse("init", script);
 39 | 		if (initS != null)
 40 | 		{
 41 | 			interp.execute(initS);
 42 | 		}
 43 | 		
 44 | 		if (!noClean && updateScript == null && destroyScript == null)
 45 | 		{
 46 | 			doClean = true;
 47 | 		}
 48 | 	}
 49 | 	
 50 | 	public function Update() 
 51 | 	{	
 52 | 		if (!init)
 53 | 		{
 54 | 			Init();
 55 | 			init = true;
 56 | 		}
 57 | 		
 58 | 		if (updateScript != null)
 59 | 		{
 60 | 			interp.execute(updateScript);
 61 | 		}
 62 | 	}
 63 | 	
 64 | 	public function Destroy() 
 65 | 	{
 66 | 		if (destroyScript != null)
 67 | 		{
 68 | 			interp.execute(destroyScript);
 69 | 			interp = null;
 70 | 			updateScript = null;
 71 | 			destroyScript = null;
 72 | 		}
 73 | 	}
 74 | 	
 75 | 	public function ReloadScript()
 76 | 	{
 77 | 		if (!noReload && path != "")
 78 | 		{
 79 | 			#if ICE_LIVE_RELOAD
 80 | 			newScript = IceUtil.LoadString(path, false);
 81 | 			if (newScript == null)
 82 | 			{
 83 | 				return;
 84 | 			}
 85 | 			if (newScript == script)
 86 | 			{
 87 | 				return;
 88 | 			}
 89 | 			script = newScript;
 90 | 			#end
 91 | 			
 92 | 			#if !ICE_NO_RELOAD_IMPORTS
 93 | 			ScriptHandler.ParseImports(script, interp);
 94 | 			#end
 95 | 			
 96 | 			updateScript = ScriptHandler.Parse("update", script);
 97 | 			destroyScript = ScriptHandler.Parse("destroy", script);
 98 | 			var reloadS = ScriptHandler.Parse("reload", script, interp);
 99 | 			if (reloadS != null)
100 | 			{
101 | 				interp.execute(reloadS);
102 | 			}
103 | 		}
104 | 	}
105 | 	
106 | 	public inline function getVarAsDynamic(varName:String):Dynamic
107 | 	{
108 | 		return interp.variables.get(varName);
109 | 	}
110 | 	
111 | 	public function getVar<T>(varName:String, type:Class<T>):T
112 | 	{
113 | 		return cast getVarAsDynamic(varName);
114 | 	}
115 | 	
116 | 	public inline function setVar(varName:String, value:Dynamic)
117 | 	{
118 | 		interp.variables.set(varName, value);
119 | 	}
120 | }


--------------------------------------------------------------------------------
/ice/parser/ScriptHandler.hx:
--------------------------------------------------------------------------------
  1 | package ice.parser;
  2 | import flixel.FlxBasic;
  3 | import flixel.FlxG;
  4 | import hscript.Expr;
  5 | import hscript.Parser;
  6 | import hscript.Interp;
  7 | import ice.entity.EntityManager;
  8 | import openfl.Assets;
  9 | import openfl.events.Event;
 10 | 
 11 | using StringTools;
 12 | 
 13 | class ScriptHandler extends FlxBasic
 14 | {
 15 | 	static var parser:Parser;
 16 | 	
 17 | 	static var modules:Map<String,Dynamic>;
 18 | 	
 19 | 	static public var scripts:ScriptHolder;
 20 | 	
 21 | 	static private var init:Bool = false;
 22 | 		
 23 | 	#if ICE_LIVE_RELOAD
 24 | 	static private var timer:Float = 0;
 25 | 	static private var reloadDelay:Float = 1;
 26 | 	#end
 27 | 	
 28 | 	///If scripts can use <expose> elements to get access to game code
 29 | 	public static var allowExpose:Bool = true;
 30 | 	public static var blacklist(get, null):Map<String,Bool>;
 31 | 	
 32 | 	static function get_blacklist()
 33 | 	{
 34 | 		return blacklist;
 35 | 	}
 36 | 	
 37 | 	static public function __init__()
 38 | 	{
 39 | 		parser = new Parser();
 40 | 		modules = new Map<String,Dynamic>();
 41 | 		scripts = new ScriptHolder();
 42 | 		blacklist = new Map<String,Bool>();
 43 | 		blacklist.set("ice.parser.ScriptHandler", true);
 44 | 	}
 45 | 	
 46 | 	static public function SetReloadDelay(delay:Float)
 47 | 	{
 48 | 		#if ICE_LIVE_RELOAD
 49 | 		reloadDelay = delay;
 50 | 		#end
 51 | 	}
 52 | 	
 53 | 	static public function ReloadAll()
 54 | 	{
 55 | 		for (e in EntityManager.getInstance().entities)
 56 | 		{
 57 | 			if (e != null)
 58 | 			{
 59 | 				e.scripts.ReloadScripts();
 60 | 			}
 61 | 		}
 62 | 		scripts.ReloadScripts();
 63 | 	}
 64 | 	
 65 | 	/**
 66 | 	 * Adds a static class, or class instance to the global pool, so <request> tags can get them
 67 | 	 * @param	name		how you wish to reference this class in your script
 68 | 	 * @param	module		the class to add to the pool
 69 | 	 */	
 70 | 	static public function AddModule(name:String, module:Dynamic)
 71 | 	{
 72 | 		modules.set(name, module);
 73 | 	}
 74 | 	
 75 | 	/**
 76 | 	 * Gets a class from the global pool
 77 | 	 * @param	name
 78 | 	 * @return
 79 | 	 */
 80 | 	static public function GetModule(name:String):Dynamic
 81 | 	{
 82 | 		if (modules.exists(name))
 83 | 		{
 84 | 			return modules.get(name);
 85 | 		}
 86 | 		else
 87 | 		{
 88 | 			throw "Could not find the module specified";
 89 | 		}
 90 | 	}
 91 | 	
 92 | 	/**
 93 | 	 * Gets or creates an instance of a class
 94 | 	 * @param	path
 95 | 	 * @return
 96 | 	 */
 97 | 	static public function GetClass(path:String):Dynamic
 98 | 	{
 99 | 		if (ScriptHandler.blacklist.exists(path))
100 | 		{
101 | 			throw "access to this class is blacklisted: " + path;
102 | 		}
103 | 		
104 | 		if (modules.exists(path))
105 | 		{
106 | 			return modules.get(path);
107 | 		}
108 | 		else if (ScriptHandler.allowExpose)
109 | 		{
110 | 			var myClass:Dynamic = Type.resolveClass(path);
111 | 			if (myClass != null)
112 | 			{
113 | 				modules.set(path, myClass);
114 | 				return(modules.get(path));
115 | 			}
116 | 			else
117 | 			{
118 | 				throw "expose attempt failed: " + path;
119 | 			}
120 | 		}
121 | 		else
122 | 		{
123 | 			throw "access to expose is restricted";
124 | 		}
125 | 	}
126 | 	
127 | 	/**
128 | 	 * Disallows access to a specific class in scripts
129 | 	 * @param	path	path to disallowed class. example: "flixel.FlxG"
130 | 	 */
131 | 	static public function Blacklist(path:String)
132 | 	{
133 | 		blacklist.set(path, false);
134 | 	}
135 | 	
136 | 	static public function Parse(func:String, script:String, ?interp:Interp):Expr
137 | 	{		
138 | 		var returnScript = ParseString(func, script, interp);
139 | 		if (returnScript != null)
140 | 		{
141 | 			return parser.parseString(returnScript);
142 | 		}
143 | 		return null;
144 | 	}
145 | 	
146 | 	static private function GetFunctionLine(offset:Int, func:String, script:String):Int
147 | 	{
148 | 		while (true)
149 | 		{
150 | 			var startLine:Int = script.indexOf("function", offset);
151 | 			if (startLine < 0)
152 | 			{
153 | 				return -1;
154 | 			}
155 | 			var endLine:Int = script.indexOf("\n", startLine);
156 | 			if (endLine < 0)
157 | 			{
158 | 				endLine = script.indexOf("\r");
159 | 			}
160 | 			
161 | 			var line:String = script.substring(startLine, endLine);
162 | 			
163 | 			if (line.indexOf(func) >= 0)
164 | 			{
165 | 				return endLine;
166 | 			}
167 | 			offset = endLine;
168 | 		}
169 | 		return -1;
170 | 	}
171 | 	
172 | 	static public function ParseString(func:String, script:String, ?interp:Interp):String
173 | 	{
174 | 		var startIndex = GetFunctionLine(0, func, script);
175 | 		
176 | 		if (startIndex == -1)
177 | 		{
178 | 			return null;
179 | 		}
180 | 		
181 | 		var braces:Int = 0;
182 | 		var startCheck:Bool = false;
183 | 		var charIndex:Int = startIndex;
184 | 		
185 | 		while ((charIndex < script.length) && !(startCheck && (braces == 0)))
186 | 		{
187 | 			var char:String = script.charAt(charIndex);
188 | 			
189 | 			if (char == "{")
190 | 			{
191 | 				if (!startCheck)
192 | 				{
193 | 					startIndex = charIndex;
194 | 					startCheck = true;
195 | 				}
196 | 				
197 | 				braces++;
198 | 			}
199 | 			
200 | 			if (char == "}")
201 | 			{			
202 | 				braces--;
203 | 			}
204 | 			
205 | 			charIndex++;
206 | 		}
207 | 		
208 | 		var ret:String = script.substring(startIndex, charIndex);
209 | 		
210 | 		var types:EReg = ~/: *[a-z0-9_<>]+/ig; //remove types from declarations
211 | 		ret = types.replace(ret, "");
212 | 		
213 | 		//add variable declarations into init
214 | 		if (func == "init")
215 | 		{
216 | 			ret = ParseVars(script) + ret;
217 | 		}
218 | 		else if (func == "reload")
219 | 		{
220 | 			ret = ParseVars(script, interp) + ret;
221 | 		}
222 | 		
223 | 		ret = ~/var /g.replace(ret, "");
224 | 		
225 | 		return ret;
226 | 	}
227 | 	
228 | 	static public function ParseImports(script:String, interp:Interp)
229 | 	{
230 | 		var imports:String;
231 | 		var endIndex = script.indexOf("function");
232 | 		
233 | 		imports = script.substring(0, endIndex);
234 | 		
235 | 		var lines:Array<String> = imports.split(";");
236 | 		
237 | 		for (l in lines)
238 | 		{
239 | 			l = l.trim();
240 | 			
241 | 			if (l == "")
242 | 			{
243 | 				continue;
244 | 			}
245 | 			
246 | 			var sections:Array<String> = ~/ +/.split(l);
247 | 			
248 | 			if (sections[0] == "import")
249 | 			{
250 | 				var className:String = sections[1];
251 | 				var name = className.split(".").pop();
252 | 				var c:Dynamic = GetClass(className);
253 | 				interp.variables.set(name, c);
254 | 			}
255 | 			else if (sections[0] == "request")
256 | 			{
257 | 				l = sections[1];
258 | 				interp.variables.set(l, GetModule(l));
259 | 			}
260 | 		}
261 | 	}
262 | 	
263 | 	static private function ParseVars(script:String, ?interp:Interp):String
264 | 	{
265 | 		var startIndex:Int = script.indexOf("class ");
266 | 		
267 | 		if (startIndex < 0)
268 | 		{
269 | 			startIndex = script.lastIndexOf("import ");
270 | 			startIndex = script.indexOf("\n", startIndex);
271 | 		}
272 | 		else
273 | 		{
274 | 			startIndex = script.indexOf("{", startIndex) + 1;
275 | 		}
276 | 		
277 | 		var endIndex = script.indexOf("function ", startIndex);
278 | 		
279 | 		var vars:String = script.substring(startIndex, endIndex);		
280 | 		vars = vars.substring(0, vars.lastIndexOf("\n")); //cut vars to end of last line
281 | 		
282 | 		var startNonCompile:Int = vars.indexOf("//#");
283 | 		var endNonCompile:Int = vars.indexOf("//#", startNonCompile + 3);
284 | 		vars = vars.substring(0, startNonCompile) + vars.substring(endNonCompile); //remove the non-compile section
285 | 		
286 | 		var redundant:EReg = ~/[a-z]* *[a-z]* *var +[a-z0-9_<>]+ *: *[a-z0-9_<>]+ *; *(\n)?/ig; //remove declarations that do not assign a value
287 | 		vars = redundant.replace(vars, "");
288 | 		
289 | 		if (interp != null)
290 | 		{
291 | 			var reloadVars:String = "";
292 | 			
293 | 			var varDecl:EReg = ~/var +([a-z0-9_]+)/ig; //find variable names
294 | 			while (varDecl.match(vars))
295 | 			{
296 | 				if (!interp.variables.exists(varDecl.matched(1)))
297 | 				{
298 | 					reloadVars += vars.substring(varDecl.matchedPos().pos, vars.indexOf(";",varDecl.matchedPos().pos) + 1);
299 | 				}
300 | 				vars = varDecl.matchedRight();
301 | 			}
302 | 			vars = reloadVars;
303 | 		}
304 | 		
305 | 		var helperStart:Int = script.indexOf("//@");
306 | 		var helperEnd:Int = script.indexOf("//@", helperStart + 3);
307 | 		if (helperStart >= 0)
308 | 		{
309 | 			vars += script.substring(helperStart, helperEnd);
310 | 		}
311 | 		
312 | 		var types:EReg = ~/: *[a-z0-9_<>]+/ig; //remove types from variable declarations
313 | 		vars = types.replace(vars, "");
314 | 		
315 | 		var modifiers:EReg = ~/(static)? *(private|public) *(static)?/g; //remove modifiers from variable declarations
316 | 		vars = modifiers.replace(vars, "");
317 | 		
318 | 		return vars;
319 | 	}
320 | 	
321 | 	static public function Update()
322 | 	{
323 | 		#if ICE_LIVE_RELOAD
324 | 		timer += FlxG.elapsed;
325 | 		if (timer > reloadDelay)
326 | 		{
327 | 			ReloadAll();
328 | 			timer = 0;
329 | 		}
330 | 		#end
331 | 		scripts.Update();
332 | 	}
333 | }


--------------------------------------------------------------------------------
/ice/parser/ScriptHolder.hx:
--------------------------------------------------------------------------------
 1 | package ice.parser;
 2 | import ice.entity.Entity;
 3 | import ice.entity.EntityManager;
 4 | 
 5 | class ScriptHolder
 6 | {
 7 | 	public var scripts(default,null):Array<Script>;
 8 | 	private var owner:Entity;
 9 | 	
10 | 	public function new(?owner:Entity) 
11 | 	{
12 | 		scripts = new Array<Script>();
13 | 		this.owner = owner;
14 | 	}
15 | 	
16 | 	/**
17 | 	 * Adds a script to this holder
18 | 	 * @param	script	the script to add
19 | 	 * @param	id		an identifier for this script, if left -1, it will be pushed to the top
20 | 	 */
21 | 	public function Add(script:Script, ?id:Int = -1)
22 | 	{
23 | 		if (id != -1)
24 | 		{
25 | 			scripts.insert(id, script);
26 | 		}
27 | 		else
28 | 		{
29 | 			scripts.insert(scripts.length, script);
30 | 		}
31 | 	}
32 | 	
33 | 	public function ParseScript(path:String)
34 | 	{
35 | 		EntityManager.instance.ParseScript(null, owner, path);
36 | 	}
37 | 	
38 | 	/**
39 | 	 * Removes a script by id
40 | 	 * @param	id
41 | 	 */
42 | 	public function Remove(id:Int)
43 | 	{
44 | 		scripts[id].Destroy();
45 | 		scripts.remove(scripts[id]);
46 | 	}
47 | 	
48 | 	public function Update()
49 | 	{
50 | 		for (s in scripts)
51 | 		{
52 | 			if (s.doClean)
53 | 			{
54 | 				scripts.remove(s);
55 | 			}
56 | 			else if (s != null)
57 | 			{
58 | 				s.Update();
59 | 			}
60 | 		}
61 | 	}
62 | 	
63 | 	public function Destroy()
64 | 	{
65 | 		for (s in scripts)
66 | 		{
67 | 			s.Destroy();
68 | 		}
69 | 		scripts = new Array<Script>();
70 | 	}
71 | 	
72 | 	public function ReloadScripts()
73 | 	{
74 | 		for (s in scripts)
75 | 		{
76 | 			if (s != null)
77 | 			{
78 | 				s.ReloadScript();
79 | 			}
80 | 		}
81 | 	}
82 | }


--------------------------------------------------------------------------------
/ice/wrappers/FlxCameraFollowStyleWrap.hx:
--------------------------------------------------------------------------------
 1 | package ice.wrappers;
 2 | 
 3 | import flixel.FlxCamera.FlxCameraFollowStyle;
 4 | 
 5 | /**
 6 |  * ...
 7 |  * @author 
 8 |  */
 9 | class FlxCameraFollowStyleWrap
10 | {
11 | 	/**
12 | 	 * Camera has no deadzone, just tracks the focus object directly.
13 | 	 */
14 | 	static var LOCKON:FlxCameraFollowStyle = FlxCameraFollowStyle.LOCKON;
15 | 	/**
16 | 	 * Camera's deadzone is narrow but tall.
17 | 	 */
18 | 	static var PLATFORMER:FlxCameraFollowStyle = FlxCameraFollowStyle.PLATFORMER;
19 | 	/**
20 | 	 * Camera's deadzone is a medium-size square around the focus object.
21 | 	 */
22 | 	static var TOPDOWN:FlxCameraFollowStyle = FlxCameraFollowStyle.TOPDOWN;
23 | 	/**
24 | 	 * Camera's deadzone is a small square around the focus object.
25 | 	 */
26 | 	static var TOPDOWN_TIGHT:FlxCameraFollowStyle = FlxCameraFollowStyle.TOPDOWN_TIGHT;
27 | 	/**
28 | 	 * Camera will move screenwise.
29 | 	 */
30 | 	static var SCREEN_BY_SCREEN:FlxCameraFollowStyle = FlxCameraFollowStyle.SCREEN_BY_SCREEN;
31 | 	/**
32 | 	 * Camera has no deadzone, just tracks the focus object directly and centers it.
33 | 	 */
34 | 	static var NO_DEAD_ZONE:FlxCameraFollowStyle = FlxCameraFollowStyle.NO_DEAD_ZONE;
35 | }


--------------------------------------------------------------------------------
/ice/wrappers/FlxColorWrap.hx:
--------------------------------------------------------------------------------
 1 | package ice.wrappers;
 2 | 
 3 | import flixel.util.FlxColor;
 4 | 
 5 | class FlxColorWrap
 6 | {
 7 | 	public static var TRANSPARENT:FlxColor =   0x00000000;
 8 | 	public static var WHITE:FlxColor =         0xFFFFFFFF;
 9 | 	public static var GRAY:FlxColor =          0xFF808080;
10 | 	public static var BLACK:FlxColor =         0xFF000000;
11 | 	
12 | 	public static var GREEN:FlxColor =         0xFF008000;
13 | 	public static var LIME:FlxColor =          0xFF00FF00;
14 | 	public static var YELLOW:FlxColor =        0xFFFFFF00;
15 | 	public static var ORANGE:FlxColor =        0xFFFFA500;
16 | 	public static var RED:FlxColor =           0xFFFF0000;
17 | 	public static var PURPLE:FlxColor =        0xFF800080;
18 | 	public static var BLUE:FlxColor =          0xFF0000FF;
19 | 	public static var BROWN:FlxColor =         0xFF8B4513;
20 | 	public static var PINK:FlxColor =          0xFFFFC0CB;
21 | 	public static var MAGENTA:FlxColor =       0xFFFF00FF;
22 | 	public static var CYAN:FlxColor =          0xFF00FFFF;	
23 | }


--------------------------------------------------------------------------------
/ice/wrappers/FlxKeyWrap.hx:
--------------------------------------------------------------------------------
  1 | package ice.wrappers;
  2 | 
  3 | import flixel.input.keyboard.FlxKey;
  4 | 
  5 | class FlxKeyWrap
  6 | {
  7 | 	
  8 | 	/*public static var LEFT(get,null):FlxKey;
  9 | 	
 10 | 	private static inline function get_LEFT():FlxKey
 11 | 	{
 12 | 		return FlxKey.LEFT;
 13 | 	}*/
 14 | 	
 15 | 	public static var ANY           (default, never)  = -2;
 16 | 	public static var NONE          (default, never)  = -1;
 17 | 	public static var A             (default, never)  = 65;
 18 | 	public static var B             (default, never)  = 66;
 19 | 	public static var C             (default, never)  = 67;
 20 | 	public static var D             (default, never)  = 68;
 21 | 	public static var E             (default, never)  = 69;
 22 | 	public static var F             (default, never)  = 70;
 23 | 	public static var G             (default, never)  = 71;
 24 | 	public static var H             (default, never)  = 72;
 25 | 	public static var I             (default, never)  = 73;
 26 | 	public static var J             (default, never)  = 74;
 27 | 	public static var K             (default, never)  = 75;
 28 | 	public static var L             (default, never)  = 76;
 29 | 	public static var M             (default, never)  = 77;
 30 | 	public static var N             (default, never)  = 78;
 31 | 	public static var O             (default, never)  = 79;
 32 | 	public static var P             (default, never)  = 80;
 33 | 	public static var Q             (default, never)  = 81;
 34 | 	public static var R             (default, never)  = 82;
 35 | 	public static var S             (default, never)  = 83;
 36 | 	public static var T             (default, never)  = 84;
 37 | 	public static var U             (default, never)  = 85;
 38 | 	public static var V             (default, never)  = 86;
 39 | 	public static var W             (default, never)  = 87;
 40 | 	public static var X             (default, never)  = 88;
 41 | 	public static var Y             (default, never)  = 89;
 42 | 	public static var Z             (default, never)  = 90;
 43 | 	public static var ZERO          (default, never)  = 48;
 44 | 	public static var ONE           (default, never)  = 49;
 45 | 	public static var TWO           (default, never)  = 50;
 46 | 	public static var THREE         (default, never)  = 51;
 47 | 	public static var FOUR          (default, never)  = 52;
 48 | 	public static var FIVE          (default, never)  = 53;
 49 | 	public static var SIX           (default, never)  = 54;
 50 | 	public static var SEVEN         (default, never)  = 55;
 51 | 	public static var EIGHT         (default, never)  = 56;
 52 | 	public static var NINE          (default, never)  = 57;
 53 | 	public static var PAGEUP        (default, never)  = 33;
 54 | 	public static var PAGEDOWN      (default, never)  = 34;
 55 | 	public static var HOME          (default, never)  = 36;
 56 | 	public static var END           (default, never)  = 35;
 57 | 	public static var INSERT        (default, never)  = 45;
 58 | 	public static var ESCAPE        (default, never)  = 27;
 59 | 	public static var MINUS         (default, never)  = 189;
 60 | 	public static var PLUS          (default, never)  = 187;
 61 | 	public static var DELETE        (default, never)  = 46;
 62 | 	public static var BACKSPACE     (default, never)  = 8;
 63 | 	public static var LBRACKET      (default, never)  = 219;
 64 | 	public static var RBRACKET      (default, never)  = 221;
 65 | 	public static var BACKSLASH     (default, never)  = 220;
 66 | 	public static var CAPSLOCK      (default, never)  = 20;
 67 | 	public static var SEMICOLON     (default, never)  = 186;
 68 | 	public static var QUOTE         (default, never)  = 222;
 69 | 	public static var ENTER         (default, never)  = 13;
 70 | 	public static var SHIFT         (default, never)  = 16;
 71 | 	public static var COMMA         (default, never)  = 188;
 72 | 	public static var PERIOD        (default, never)  = 190;
 73 | 	public static var SLASH         (default, never)  = 191;
 74 | 	public static var NUMPADSLASH   (default, never)  = 191;
 75 | 	public static var GRAVEACCENT   (default, never)  = 192;
 76 | 	public static var CONTROL       (default, never)  = 17;
 77 | 	public static var ALT           (default, never)  = 18;
 78 | 	public static var SPACE         (default, never)  = 32;
 79 | 	public static var UP            (default, never)  = 38;
 80 | 	public static var DOWN          (default, never)  = 40;
 81 | 	public static var LEFT          (default, never)  = 37;
 82 | 	public static var RIGHT         (default, never)  = 39;
 83 | 	public static var TAB           (default, never)  = 9;
 84 | 	public static var PRINTSCREEN   (default, never)  = 301;
 85 | 	public static var F1            (default, never)  = 112;
 86 | 	public static var F2            (default, never)  = 113;
 87 | 	public static var F3            (default, never)  = 114;
 88 | 	public static var F4            (default, never)  = 115;
 89 | 	public static var F5            (default, never)  = 116;
 90 | 	public static var F6            (default, never)  = 117;
 91 | 	public static var F7            (default, never)  = 118;
 92 | 	public static var F8            (default, never)  = 119;
 93 | 	public static var F9            (default, never)  = 120;
 94 | 	public static var F10           (default, never)  = 121;
 95 | 	public static var F11           (default, never)  = 122;
 96 | 	public static var F12           (default, never)  = 123;
 97 | 	public static var NUMPADZERO    (default, never)  = 96;
 98 | 	public static var NUMPADONE     (default, never)  = 97;
 99 | 	public static var NUMPADTWO     (default, never)  = 98;
100 | 	public static var NUMPADTHREE   (default, never)  = 99;
101 | 	public static var NUMPADFOUR    (default, never)  = 100;
102 | 	public static var NUMPADFIVE    (default, never)  = 101;
103 | 	public static var NUMPADSIX     (default, never)  = 102;
104 | 	public static var NUMPADSEVEN   (default, never)  = 103;
105 | 	public static var NUMPADEIGHT   (default, never)  = 104;
106 | 	public static var NUMPADNINE    (default, never)  = 105;
107 | 	public static var NUMPADMINUS   (default, never)  = 109;
108 | 	public static var NUMPADPLUS    (default, never)  = 107;
109 | 	public static var NUMPADPERIOD  (default, never)  = 110;
110 | 	public static var NUMPADMULTIPLY(default, never)  = 106;
111 | }


--------------------------------------------------------------------------------