├── .gitignore ├── .gitmodules ├── Client ├── .haxelib │ ├── actuate │ │ ├── .current │ │ └── 1,8,7 │ │ │ ├── .gitignore │ │ │ ├── .travis.yml │ │ │ ├── LICENSE.md │ │ │ ├── README.md │ │ │ ├── documentation │ │ │ ├── ImportAll.hx │ │ │ └── build.hxml │ │ │ ├── haxedoc.xml │ │ │ ├── haxelib.json │ │ │ └── motion │ │ │ ├── Actuate.hx │ │ │ ├── MotionPath.hx │ │ │ ├── actuators │ │ │ ├── FilterActuator.hx │ │ │ ├── GenericActuator.hx │ │ │ ├── IGenericActuator.hx │ │ │ ├── MethodActuator.hx │ │ │ ├── MotionPathActuator.hx │ │ │ ├── PropertyDetails.hx │ │ │ ├── SimpleActuator.hx │ │ │ └── TransformActuator.hx │ │ │ └── easing │ │ │ ├── Back.hx │ │ │ ├── Bounce.hx │ │ │ ├── Cubic.hx │ │ │ ├── Elastic.hx │ │ │ ├── Expo.hx │ │ │ ├── IEasing.hx │ │ │ ├── Linear.hx │ │ │ ├── Quad.hx │ │ │ ├── Quart.hx │ │ │ ├── Quint.hx │ │ │ └── Sine.hx │ ├── haxeui-code-editor │ │ └── .current │ ├── haxeui-core │ │ └── .current │ ├── haxeui-html5 │ │ └── .current │ ├── hscript │ │ ├── .current │ │ └── 2,1,1 │ │ │ ├── README.md │ │ │ ├── extraParams.hxml │ │ │ ├── haxedoc.xml │ │ │ ├── haxelib.json │ │ │ ├── hscript │ │ │ ├── Bytes.hx │ │ │ ├── Expr.hx │ │ │ ├── Interp.hx │ │ │ ├── Macro.hx │ │ │ ├── Parser.hx │ │ │ ├── Printer.hx │ │ │ └── Tools.hx │ │ │ ├── run.n │ │ │ └── script │ │ │ ├── RunScript.hx │ │ │ └── build.hxml │ ├── monaco-editor │ │ └── .current │ ├── tink_await │ │ ├── .current │ │ └── 0,3,0 │ │ │ ├── README.md │ │ │ ├── extraParams.hxml │ │ │ ├── haxelib.json │ │ │ └── src │ │ │ └── tink │ │ │ └── await │ │ │ ├── AsyncField.hx │ │ │ ├── Await.hx │ │ │ ├── Error.hx │ │ │ ├── LoopIterator.hx │ │ │ ├── MacroTools.hx │ │ │ ├── OutcomeTools.hx │ │ │ └── Thunk.hx │ ├── tink_core │ │ ├── .current │ │ └── 1,15,3 │ │ │ ├── README.md │ │ │ ├── haxelib.json │ │ │ └── src │ │ │ └── tink │ │ │ ├── CoreApi.hx │ │ │ └── core │ │ │ ├── Annex.hx │ │ │ ├── Any.hx │ │ │ ├── Callback.hx │ │ │ ├── Either.hx │ │ │ ├── Error.hx │ │ │ ├── Future.hx │ │ │ ├── Lazy.hx │ │ │ ├── Named.hx │ │ │ ├── Noise.hx │ │ │ ├── Option.hx │ │ │ ├── Outcome.hx │ │ │ ├── Pair.hx │ │ │ ├── Promise.hx │ │ │ ├── Ref.hx │ │ │ └── Signal.hx │ ├── tink_macro │ │ ├── .current │ │ └── 0,15,4 │ │ │ ├── README.md │ │ │ ├── haxelib.json │ │ │ └── src │ │ │ └── tink │ │ │ ├── MacroApi.hx │ │ │ └── macro │ │ │ ├── Bouncer.hx │ │ │ ├── BuildCache.hx │ │ │ ├── ClassBuilder.hx │ │ │ ├── Constructor.hx │ │ │ ├── DirectType.hx │ │ │ ├── Exprs.hx │ │ │ ├── Functions.hx │ │ │ ├── Member.hx │ │ │ ├── Metadatas.hx │ │ │ ├── Ops.hx │ │ │ ├── Positions.hx │ │ │ ├── Sisyphus.hx │ │ │ ├── TypeMap.hx │ │ │ └── Types.hx │ ├── tink_priority │ │ ├── .current │ │ └── 0,1,3 │ │ │ ├── README.md │ │ │ ├── haxelib.json │ │ │ └── src │ │ │ └── tink │ │ │ └── priority │ │ │ ├── ID.hx │ │ │ ├── Item.hx │ │ │ ├── Queue.hx │ │ │ └── Selector.hx │ └── tink_syntaxhub │ │ ├── .current │ │ └── 0,3,6 │ │ ├── README.md │ │ ├── extraParams.hxml │ │ ├── haxelib.json │ │ └── src │ │ └── tink │ │ ├── SyntaxHub.hx │ │ └── syntaxhub │ │ ├── ExprLevelSyntax.hx │ │ ├── FrontendContext.hx │ │ └── FrontendPlugin.hx ├── Client.hxproj ├── assets │ ├── css │ │ ├── buttons.css │ │ ├── dialogs.css │ │ ├── listviews.css │ │ ├── main.css │ │ ├── menus.css │ │ ├── progressbars.css │ │ ├── scrolls.css │ │ ├── tabs.css │ │ ├── textinputs.css │ │ └── trees.css │ ├── fonts │ │ ├── LICENSE.txt │ │ └── Roboto-Black.ttf │ ├── icons │ │ ├── audio-file.png │ │ ├── blank.png │ │ ├── close.png │ │ ├── control-000-small.png │ │ ├── control-270-small.png │ │ ├── dialogs │ │ │ └── info.png │ │ ├── document.png │ │ ├── download.png │ │ ├── example.png │ │ ├── file.png │ │ ├── folder.png │ │ ├── help.png │ │ ├── map.png │ │ ├── picture.png │ │ ├── plus.png │ │ ├── puzzle.png │ │ ├── refresh.png │ │ ├── save-all.png │ │ ├── save.png │ │ ├── settings.png │ │ ├── sound.png │ │ └── upload.png │ ├── img │ │ ├── parrot.png │ │ └── parrot_small.png │ ├── templates │ │ ├── shaders │ │ │ ├── Basic.frag.glsl.template │ │ │ ├── Basic.vert.glsl.template │ │ │ ├── Empty.frag.glsl.template │ │ │ └── Empty.vert.glsl.template │ │ └── sources │ │ │ ├── Abstract.template │ │ │ ├── Class.template │ │ │ ├── Enum.template │ │ │ ├── Interface.template │ │ │ └── TypeDef.template │ └── ui │ │ ├── dialogs │ │ ├── about.xml │ │ ├── add-resource.xml │ │ ├── example-item.xml │ │ ├── examples.xml │ │ ├── import-progress.xml │ │ └── import.xml │ │ ├── editors │ │ ├── image-editor.xml │ │ ├── shader-editor.xml │ │ └── source-editor.xml │ │ ├── main.xml │ │ └── panels │ │ ├── khanvas.xml │ │ ├── log-manager.xml │ │ ├── project-manager.xml │ │ └── tab-manager.xml ├── build │ └── html5 │ │ ├── client.js │ │ ├── index.html │ │ ├── kha.js │ │ ├── monaco-editor-0.17.0 │ │ └── min │ │ │ └── vs │ │ │ ├── base │ │ │ └── worker │ │ │ │ └── workerMain.js │ │ │ ├── basic-languages │ │ │ ├── apex │ │ │ │ └── apex.js │ │ │ ├── azcli │ │ │ │ └── azcli.js │ │ │ ├── bat │ │ │ │ └── bat.js │ │ │ ├── clojure │ │ │ │ └── clojure.js │ │ │ ├── coffee │ │ │ │ └── coffee.js │ │ │ ├── cpp │ │ │ │ └── cpp.js │ │ │ ├── csharp │ │ │ │ └── csharp.js │ │ │ ├── csp │ │ │ │ └── csp.js │ │ │ ├── css │ │ │ │ └── css.js │ │ │ ├── dockerfile │ │ │ │ └── dockerfile.js │ │ │ ├── fsharp │ │ │ │ └── fsharp.js │ │ │ ├── go │ │ │ │ └── go.js │ │ │ ├── graphql │ │ │ │ └── graphql.js │ │ │ ├── handlebars │ │ │ │ └── handlebars.js │ │ │ ├── html │ │ │ │ └── html.js │ │ │ ├── ini │ │ │ │ └── ini.js │ │ │ ├── java │ │ │ │ └── java.js │ │ │ ├── javascript │ │ │ │ └── javascript.js │ │ │ ├── kotlin │ │ │ │ └── kotlin.js │ │ │ ├── less │ │ │ │ └── less.js │ │ │ ├── lua │ │ │ │ └── lua.js │ │ │ ├── markdown │ │ │ │ └── markdown.js │ │ │ ├── msdax │ │ │ │ └── msdax.js │ │ │ ├── mysql │ │ │ │ └── mysql.js │ │ │ ├── objective-c │ │ │ │ └── objective-c.js │ │ │ ├── pascal │ │ │ │ └── pascal.js │ │ │ ├── perl │ │ │ │ └── perl.js │ │ │ ├── pgsql │ │ │ │ └── pgsql.js │ │ │ ├── php │ │ │ │ └── php.js │ │ │ ├── postiats │ │ │ │ └── postiats.js │ │ │ ├── powerquery │ │ │ │ └── powerquery.js │ │ │ ├── powershell │ │ │ │ └── powershell.js │ │ │ ├── pug │ │ │ │ └── pug.js │ │ │ ├── python │ │ │ │ └── python.js │ │ │ ├── r │ │ │ │ └── r.js │ │ │ ├── razor │ │ │ │ └── razor.js │ │ │ ├── redis │ │ │ │ └── redis.js │ │ │ ├── redshift │ │ │ │ └── redshift.js │ │ │ ├── ruby │ │ │ │ └── ruby.js │ │ │ ├── rust │ │ │ │ └── rust.js │ │ │ ├── sb │ │ │ │ └── sb.js │ │ │ ├── scheme │ │ │ │ └── scheme.js │ │ │ ├── scss │ │ │ │ └── scss.js │ │ │ ├── shell │ │ │ │ └── shell.js │ │ │ ├── solidity │ │ │ │ └── solidity.js │ │ │ ├── sql │ │ │ │ └── sql.js │ │ │ ├── st │ │ │ │ └── st.js │ │ │ ├── swift │ │ │ │ └── swift.js │ │ │ ├── tcl │ │ │ │ └── tcl.js │ │ │ ├── typescript │ │ │ │ └── typescript.js │ │ │ ├── vb │ │ │ │ └── vb.js │ │ │ ├── xml │ │ │ │ └── xml.js │ │ │ └── yaml │ │ │ │ └── yaml.js │ │ │ ├── editor │ │ │ ├── editor.main.css │ │ │ ├── editor.main.js │ │ │ ├── editor.main.nls.de.js │ │ │ ├── editor.main.nls.es.js │ │ │ ├── editor.main.nls.fr.js │ │ │ ├── editor.main.nls.it.js │ │ │ ├── editor.main.nls.ja.js │ │ │ ├── editor.main.nls.js │ │ │ ├── editor.main.nls.ko.js │ │ │ ├── editor.main.nls.ru.js │ │ │ ├── editor.main.nls.zh-cn.js │ │ │ └── editor.main.nls.zh-tw.js │ │ │ ├── language │ │ │ ├── css │ │ │ │ ├── cssMode.js │ │ │ │ └── cssWorker.js │ │ │ ├── html │ │ │ │ ├── htmlMode.js │ │ │ │ └── htmlWorker.js │ │ │ ├── json │ │ │ │ ├── jsonMode.js │ │ │ │ └── jsonWorker.js │ │ │ └── typescript │ │ │ │ ├── tsMode.js │ │ │ │ └── tsWorker.js │ │ │ └── loader.js │ │ ├── pako_inflate.min.js │ │ └── socket.io.js ├── checkstyle.json ├── html5-release.hxml ├── html5.hxml └── src │ ├── AnimationUtil.hx │ ├── EventDispatcher.hx │ ├── EventType.hx │ ├── IEditor.hx │ ├── IListener.hx │ ├── IconUtil.hx │ ├── Main.hx │ ├── MainView.hx │ ├── Navigation.hx │ ├── Server.hx │ ├── WorkerKha.hx │ ├── custom │ ├── Canvas.hx │ ├── FileSelector.hx │ ├── IFrame.hx │ └── TreeView.hx │ ├── dialogs │ ├── AboutDialog.hx │ ├── AddResourceDialog.hx │ ├── ExamplesDialog.hx │ ├── ImportDialog.hx │ └── ImportProgressDialog.hx │ ├── editors │ ├── ImageEditor.hx │ ├── ShaderEditor.hx │ └── SourceEditor.hx │ ├── module.xml │ ├── panels │ ├── Khanvas.hx │ ├── LogManager.hx │ ├── ProjectManager.hx │ └── TabManager.hx │ └── project │ ├── IProjectListener.hx │ ├── IResourceListener.hx │ ├── Project.hx │ ├── Resource.hx │ └── ResourceType.hx ├── Server ├── .vscode │ └── launch.json ├── Compiler.ts ├── Exports.ts ├── Git.ts ├── Project.ts ├── install-service.js ├── kodegarden.ts ├── package-lock.json ├── package.json └── tsconfig.json ├── readme.md └── setup.js /.gitignore: -------------------------------------------------------------------------------- 1 | /Client/out 2 | /Client/node_modules 3 | /Server/out 4 | /Server/node_modules 5 | /Projects 6 | -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "Kha"] 2 | path = Kha 3 | url = https://github.com/Kode/Kha 4 | branch = main 5 | [submodule "Client/.haxelib/haxeui-core/git"] 6 | path = Client/.haxelib/haxeui-core/git 7 | url = https://github.com/haxeui/haxeui-core 8 | branch = master 9 | [submodule "Client/.haxelib/haxeui-html5/git"] 10 | path = Client/.haxelib/haxeui-html5/git 11 | url = https://github.com/haxeui/haxeui-html5 12 | branch = master 13 | [submodule "Client/.haxelib/monaco-editor/git"] 14 | path = Client/.haxelib/monaco-editor/git 15 | url = https://github.com/axgord/hx-monaco-editor 16 | branch = master 17 | [submodule "Client/.haxelib/haxeui-code-editor/git"] 18 | path = Client/.haxelib/haxeui-code-editor/git 19 | url = https://github.com/haxeui/haxeui-code-editor 20 | branch = master 21 | -------------------------------------------------------------------------------- /Client/.haxelib/actuate/.current: -------------------------------------------------------------------------------- 1 | 1.8.7 -------------------------------------------------------------------------------- /Client/.haxelib/actuate/1,8,7/.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | -------------------------------------------------------------------------------- /Client/.haxelib/actuate/1,8,7/.travis.yml: -------------------------------------------------------------------------------- 1 | language: c++ 2 | 3 | before_install: 4 | - export DISPLAY=:99.0 5 | - sh -e /etc/init.d/xvfb start 6 | - /sbin/start-stop-daemon --start --quiet --pidfile /tmp/custom_xvfb_99.pid --make-pidfile --background --exec /usr/bin/Xvfb -- :99 -ac -screen 0 1280x1024x32 -extension GLX 7 | - export AUDIODEV=null 8 | - sudo add-apt-repository ppa:eyecreate/haxe -y 9 | - sudo apt-get update 10 | 11 | install: 12 | - sudo apt-get install haxe -y --force-yes 13 | - sudo apt-get install g++-multilib gcc-multilib 14 | - sudo apt-get install mesa-common-dev libgl1-mesa-dev libglu1-mesa-dev -y 15 | - mkdir ~/haxelib 16 | - haxelib setup ~/haxelib 17 | - haxelib install hxcpp 18 | - haxelib install mcover 19 | - haxelib install hamcrest 20 | - git clone https://github.com/jgranick/MassiveUnit ~/munit --depth 1 21 | - haxelib dev munit ~/munit/src 22 | - haxelib dev actuate $(pwd) 23 | - cd ~/munit/tool 24 | - haxe build.hxml 25 | 26 | before_script: 27 | - cd $TRAVIS_BUILD_DIR/tests 28 | - haxelib run munit gen 29 | 30 | script: 31 | - haxelib run munit test -as3 -norun 32 | - haxelib run munit test -browser phantomjs 33 | - haxelib run munit test -neko 34 | - haxelib run munit test -cpp 35 | 36 | notifications: 37 | slack: openfl:sBwVO0kgB7EuWLYzZzUezVIz 38 | -------------------------------------------------------------------------------- /Client/.haxelib/actuate/1,8,7/LICENSE.md: -------------------------------------------------------------------------------- 1 | License 2 | ======= 3 | 4 | The MIT License (MIT) 5 | 6 | Copyright (c) 2009-2015 Joshua Granick 7 | 8 | Permission is hereby granted, free of charge, to any person obtaining a copy 9 | of this software and associated documentation files (the "Software"), to deal 10 | in the Software without restriction, including without limitation the rights 11 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 12 | copies of the Software, and to permit persons to whom the Software is 13 | furnished to do so, subject to the following conditions: 14 | 15 | The above copyright notice and this permission notice shall be included in 16 | all copies or substantial portions of the Software. 17 | 18 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 19 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 20 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 21 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 22 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 23 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 24 | THE SOFTWARE. 25 | -------------------------------------------------------------------------------- /Client/.haxelib/actuate/1,8,7/documentation/ImportAll.hx: -------------------------------------------------------------------------------- 1 | package; 2 | 3 | import motion.Actuate; 4 | import motion.MotionPath; 5 | import motion.actuators.FilterActuator; 6 | import motion.actuators.GenericActuator; 7 | import motion.actuators.MethodActuator; 8 | import motion.actuators.MotionPathActuator; 9 | import motion.actuators.PropertyDetails; 10 | import motion.actuators.SimpleActuator; 11 | import motion.actuators.TransformActuator; 12 | import motion.easing.Back; 13 | import motion.easing.Cubic; 14 | import motion.easing.Elastic; 15 | import motion.easing.Expo; 16 | import motion.easing.IEasing; 17 | import motion.easing.Linear; 18 | import motion.easing.Quad; 19 | import motion.easing.Quart; 20 | import motion.easing.Quint; 21 | import motion.easing.Sine; -------------------------------------------------------------------------------- /Client/.haxelib/actuate/1,8,7/documentation/build.hxml: -------------------------------------------------------------------------------- 1 | -swf all.swf 2 | --no-output 3 | -xml ../haxedoc.xml 4 | -cp ../ 5 | ImportAll -------------------------------------------------------------------------------- /Client/.haxelib/actuate/1,8,7/haxelib.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "actuate", 3 | "url": "http://github.com/openfl/actuate", 4 | "license": "MIT", 5 | "tags": [ "flash", "cpp", "neko", "js" ], 6 | "description": "Actuate is a fast and flexible tween library that uses a jQuery-style \"chaining\" syntax. It out-performs other libraries (such as TweenLite) and is easy to extend with custom actuators.", 7 | "version": "1.8.7", 8 | "releasenote": "Timer fix", 9 | "contributors": [ "singmajesty" ], 10 | "dependencies": {} 11 | } 12 | -------------------------------------------------------------------------------- /Client/.haxelib/actuate/1,8,7/motion/actuators/FilterActuator.hx: -------------------------------------------------------------------------------- 1 | package motion.actuators; 2 | #if (flash || nme || openfl) 3 | 4 | 5 | import flash.display.DisplayObject; 6 | import flash.filters.BitmapFilter; 7 | 8 | 9 | class FilterActuator extends SimpleActuator { 10 | 11 | 12 | private var filter:BitmapFilter; 13 | private var filterClass:Class ; 14 | private var filterIndex:Int; 15 | 16 | 17 | public function new (target:DisplayObject, duration:Float, properties:Dynamic) { 18 | 19 | filterIndex = -1; 20 | 21 | super (target, duration, properties); 22 | 23 | if (Std.is (properties.filter, Class)) { 24 | 25 | filterClass = properties.filter; 26 | 27 | if (target.filters.length == 0) { 28 | target.filters = [Type.createInstance(filterClass, [])]; 29 | } 30 | 31 | for (filter in target.filters) { 32 | 33 | if (Std.is (filter, filterClass)) { 34 | 35 | this.filter = filter; 36 | 37 | } 38 | 39 | } 40 | 41 | } else { 42 | 43 | filterIndex = properties.filter; 44 | this.filter = target.filters [filterIndex]; 45 | 46 | } 47 | 48 | } 49 | 50 | 51 | private override function apply ():Void { 52 | 53 | for (propertyName in Reflect.fields (properties)) { 54 | 55 | if (propertyName != "filter") { 56 | 57 | Reflect.setField (filter, propertyName, Reflect.field (properties, propertyName)); 58 | 59 | } 60 | 61 | } 62 | 63 | var filters:Array = getField (target, "filters"); 64 | Reflect.setField (filters, properties.filter, filter); 65 | setField (target, "filters", filters); 66 | 67 | } 68 | 69 | 70 | private override function initialize ():Void { 71 | 72 | var details:PropertyDetails; 73 | var start:Float; 74 | 75 | for (propertyName in Reflect.fields (properties)) { 76 | 77 | if (propertyName != "filter") { 78 | 79 | start = getField (filter, propertyName); 80 | details = new PropertyDetails (filter, propertyName, start, Reflect.field (properties, propertyName) - start); 81 | propertyDetails.push (details); 82 | 83 | } 84 | 85 | } 86 | 87 | detailsLength = propertyDetails.length; 88 | initialized = true; 89 | 90 | } 91 | 92 | 93 | private override function update (currentTime:Float):Void { 94 | 95 | super.update (currentTime); 96 | 97 | var filters = target.filters; 98 | 99 | if (filterIndex > -1) { 100 | 101 | Reflect.setField (filters, properties.filter, filter); 102 | 103 | } else { 104 | 105 | for (i in 0...filters.length) { 106 | 107 | if (Std.is (filters[i], filterClass)) { 108 | 109 | filters[i] = filter; 110 | 111 | } 112 | 113 | } 114 | 115 | } 116 | 117 | setField (target, "filters", filters); 118 | 119 | } 120 | 121 | 122 | } 123 | 124 | 125 | #end 126 | -------------------------------------------------------------------------------- /Client/.haxelib/actuate/1,8,7/motion/actuators/MethodActuator.hx: -------------------------------------------------------------------------------- 1 | package motion.actuators; 2 | 3 | 4 | class MethodActuator extends SimpleActuator { 5 | 6 | 7 | private var currentParameters:Array ; 8 | private var tweenProperties:Dynamic; 9 | 10 | 11 | public function new (target:T, duration:Float, properties:Dynamic) { 12 | 13 | currentParameters = new Array (); 14 | tweenProperties = { }; 15 | 16 | super (target, duration, properties); 17 | 18 | if (!Reflect.hasField (properties, "start")) { 19 | 20 | this.properties.start = new Array (); 21 | 22 | } 23 | 24 | if (!Reflect.hasField (properties, "end")) { 25 | 26 | this.properties.end = this.properties.start; 27 | 28 | } 29 | 30 | for (i in 0...this.properties.start.length) { 31 | 32 | currentParameters.push (this.properties.start[i]); 33 | 34 | } 35 | } 36 | 37 | 38 | private override function apply ():Void { 39 | 40 | callMethod (target, properties.end); 41 | 42 | } 43 | 44 | 45 | private override function complete (sendEvent:Bool = true):Void { 46 | 47 | for (i in 0...properties.start.length) { 48 | 49 | currentParameters[i] = Reflect.field (tweenProperties, "param" + i); 50 | 51 | } 52 | 53 | callMethod (target, currentParameters); 54 | 55 | super.complete (sendEvent); 56 | 57 | } 58 | 59 | 60 | private override function initialize ():Void { 61 | 62 | var details:PropertyDetails; 63 | var propertyName:String; 64 | var start:Dynamic; 65 | 66 | for (i in 0...properties.start.length) { 67 | 68 | propertyName = "param" + i; 69 | start = properties.start[i]; 70 | 71 | Reflect.setField (tweenProperties, propertyName, start); 72 | 73 | if (Std.is (start, Float) || Std.is (start, Int)) { 74 | 75 | details = new PropertyDetails (tweenProperties, propertyName, start, properties.end[i] - start); 76 | propertyDetails.push (details); 77 | 78 | } 79 | 80 | } 81 | 82 | detailsLength = propertyDetails.length; 83 | initialized = true; 84 | 85 | } 86 | 87 | 88 | private override function update (currentTime:Float):Void { 89 | 90 | super.update (currentTime); 91 | 92 | if (active && !paused) { 93 | 94 | for (i in 0...properties.start.length) { 95 | 96 | currentParameters[i] = Reflect.field (tweenProperties, "param" + i); 97 | 98 | } 99 | 100 | callMethod (target, currentParameters); 101 | 102 | } 103 | 104 | } 105 | 106 | 107 | } -------------------------------------------------------------------------------- /Client/.haxelib/actuate/1,8,7/motion/actuators/PropertyDetails.hx: -------------------------------------------------------------------------------- 1 | package motion.actuators; 2 | 3 | 4 | class PropertyDetails { 5 | 6 | 7 | public var change:Float; 8 | public var isField:Bool; 9 | public var propertyName:String; 10 | public var start:Float; 11 | public var target:T; 12 | 13 | 14 | public function new (target:T, propertyName:String, start:Float, change:Float, isField:Bool = true):Void { 15 | 16 | this.target = target; 17 | this.propertyName = propertyName; 18 | this.start = start; 19 | this.change = change; 20 | this.isField = isField; 21 | 22 | } 23 | 24 | 25 | } -------------------------------------------------------------------------------- /Client/.haxelib/actuate/1,8,7/motion/easing/Back.hx: -------------------------------------------------------------------------------- 1 | /** 2 | * @author Joshua Granick 3 | * @author Zeh Fernando, Nate Chatellier 4 | * @author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.html 5 | */ 6 | 7 | 8 | package motion.easing; 9 | 10 | 11 | class Back { 12 | 13 | 14 | static public var easeIn (get_easeIn, never):IEasing; 15 | static public var easeInOut (get_easeInOut, never):IEasing; 16 | static public var easeOut (get_easeOut, never):IEasing; 17 | 18 | 19 | private static function get_easeIn ():IEasing { 20 | 21 | return new BackEaseIn (1.70158); 22 | 23 | } 24 | 25 | 26 | private static function get_easeInOut ():IEasing { 27 | 28 | return new BackEaseInOut (1.70158); 29 | 30 | } 31 | 32 | 33 | private static function get_easeOut ():IEasing { 34 | 35 | return new BackEaseOut (1.70158); 36 | 37 | } 38 | 39 | 40 | } 41 | 42 | 43 | class BackEaseIn implements IEasing { 44 | 45 | 46 | public var s:Float; 47 | 48 | 49 | public function new (s:Float) { 50 | 51 | this.s = s; 52 | 53 | } 54 | 55 | 56 | public function calculate (k:Float):Float { 57 | 58 | return k * k * ((s + 1) * k - s); 59 | 60 | } 61 | 62 | 63 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 64 | 65 | return c*(t/=d)*t*((s+1)*t - s) + b; 66 | 67 | } 68 | 69 | 70 | } 71 | 72 | 73 | class BackEaseInOut implements IEasing { 74 | 75 | 76 | public var s:Float; 77 | 78 | 79 | public function new (s:Float) { 80 | 81 | this.s = s; 82 | 83 | } 84 | 85 | 86 | public function calculate (k:Float):Float { 87 | 88 | if ((k /= 0.5) < 1) return 0.5 * (k * k * (((s *= (1.525)) + 1) * k - s)); 89 | return 0.5 * ((k -= 2) * k * (((s *= (1.525)) + 1) * k + s) + 2); 90 | 91 | } 92 | 93 | 94 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 95 | 96 | if ((t/=d/2) < 1) return c/2*(t*t*(((s*=(1.525))+1)*t - s)) + b; 97 | return c/2*((t-=2)*t*(((s*=(1.525))+1)*t + s) + 2) + b; 98 | 99 | } 100 | 101 | 102 | } 103 | 104 | 105 | class BackEaseOut implements IEasing { 106 | 107 | 108 | public var s:Float; 109 | 110 | 111 | public function new (s:Float) { 112 | 113 | this.s = s; 114 | 115 | } 116 | 117 | 118 | public function calculate (k:Float):Float { 119 | 120 | return ((k = k - 1) * k * ((s + 1) * k + s) + 1); 121 | 122 | } 123 | 124 | 125 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 126 | 127 | return c*((t=t/d-1)*t*((s+1)*t + s) + 1) + b; 128 | 129 | } 130 | 131 | 132 | } -------------------------------------------------------------------------------- /Client/.haxelib/actuate/1,8,7/motion/easing/Bounce.hx: -------------------------------------------------------------------------------- 1 | 2 | /** 3 | * @author Erik Escoffier 4 | * @author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.html 5 | */ 6 | 7 | 8 | package motion.easing; 9 | 10 | 11 | class Bounce { 12 | 13 | static public var easeIn (get_easeIn, never):IEasing; 14 | static public var easeInOut (get_easeInOut, never):IEasing; 15 | static public var easeOut (get_easeOut, never):IEasing; 16 | 17 | 18 | private static function get_easeIn ():IEasing { 19 | 20 | return new BounceEaseIn (); 21 | 22 | } 23 | 24 | 25 | private static function get_easeInOut ():IEasing { 26 | 27 | return new BounceEaseInOut (); 28 | 29 | } 30 | 31 | 32 | private static function get_easeOut ():IEasing { 33 | 34 | return new BounceEaseOut (); 35 | 36 | } 37 | 38 | 39 | } 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | class BounceEaseIn implements IEasing { 48 | 49 | 50 | public function new () { 51 | 52 | 53 | } 54 | 55 | 56 | public function calculate (k:Float):Float { 57 | return BounceEaseIn._ease(k,0,1,1); 58 | } 59 | 60 | 61 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 62 | return BounceEaseIn._ease(t,b,c,d); 63 | } 64 | 65 | public static inline function _ease (t:Float, b:Float, c:Float, d:Float):Float { 66 | return c - BounceEaseOut._ease (d-t, 0, c, d) + b; 67 | } 68 | } 69 | 70 | 71 | 72 | class BounceEaseInOut implements IEasing { 73 | 74 | 75 | public function new () { 76 | 77 | 78 | } 79 | 80 | 81 | public function calculate (k:Float):Float { 82 | 83 | if (k < .5) { 84 | return BounceEaseIn._ease(k*2, 0, 1, 1) * .5; 85 | } else { 86 | return BounceEaseOut._ease(k*2-1, 0, 1, 1) * .5 + 1*.5; 87 | } 88 | } 89 | 90 | 91 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 92 | 93 | if (t < d/2) { 94 | return BounceEaseIn._ease(t*2, 0, c, d) * .5 + b; 95 | } else { 96 | return BounceEaseOut._ease(t*2-d, 0, c, d) * .5 + c*.5 + b; 97 | } 98 | 99 | } 100 | } 101 | 102 | 103 | 104 | 105 | 106 | class BounceEaseOut implements IEasing { 107 | 108 | 109 | public function new () { 110 | 111 | 112 | } 113 | 114 | 115 | public function calculate (k:Float):Float { 116 | 117 | return BounceEaseOut._ease(k,0,1,1); 118 | 119 | } 120 | 121 | 122 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 123 | 124 | return BounceEaseOut._ease(t,b,c,d); 125 | 126 | } 127 | 128 | public static inline function _ease(t:Float, b:Float, c:Float, d:Float):Float { 129 | if ((t/=d) < (1/2.75)) { 130 | return c*(7.5625*t*t) + b; 131 | } else if (t < (2/2.75)) { 132 | return c*(7.5625*(t-=(1.5/2.75))*t + .75) + b; 133 | } else if (t < (2.5/2.75)) { 134 | return c*(7.5625*(t-=(2.25/2.75))*t + .9375) + b; 135 | } else { 136 | return c*(7.5625*(t-=(2.625/2.75))*t + .984375) + b; 137 | } 138 | } 139 | 140 | } 141 | 142 | -------------------------------------------------------------------------------- /Client/.haxelib/actuate/1,8,7/motion/easing/Cubic.hx: -------------------------------------------------------------------------------- 1 | /** 2 | * @author Joshua Granick 3 | * @author Philippe / http://philippe.elsass.me 4 | * @author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.html 5 | */ 6 | 7 | 8 | package motion.easing; 9 | 10 | 11 | class Cubic { 12 | 13 | 14 | static public var easeIn (get_easeIn, never):IEasing; 15 | static public var easeInOut (get_easeInOut, never):IEasing; 16 | static public var easeOut (get_easeOut, never):IEasing; 17 | 18 | 19 | private static function get_easeIn ():IEasing { 20 | 21 | return new CubicEaseIn (); 22 | 23 | } 24 | 25 | 26 | private static function get_easeInOut ():IEasing { 27 | 28 | return new CubicEaseInOut (); 29 | 30 | } 31 | 32 | 33 | private static function get_easeOut ():IEasing { 34 | 35 | return new CubicEaseOut (); 36 | 37 | } 38 | 39 | 40 | } 41 | 42 | 43 | class CubicEaseIn implements IEasing { 44 | 45 | 46 | public function new () { 47 | 48 | 49 | 50 | } 51 | 52 | 53 | public function calculate (k:Float):Float { 54 | 55 | return k * k * k; 56 | 57 | } 58 | 59 | 60 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 61 | 62 | return c * (t /= d) * t * t + b; 63 | 64 | } 65 | 66 | 67 | } 68 | 69 | 70 | class CubicEaseInOut implements IEasing { 71 | 72 | 73 | public function new () { 74 | 75 | 76 | 77 | } 78 | 79 | 80 | public function calculate (k:Float):Float { 81 | 82 | return ((k /= 1 / 2) < 1) ? 0.5 * k * k * k : 0.5 * ((k -= 2) * k * k + 2); 83 | 84 | } 85 | 86 | 87 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 88 | 89 | return ((t /= d / 2) < 1) ? c / 2 * t * t * t + b : c / 2 * ((t -= 2) * t * t + 2) + b; 90 | 91 | } 92 | 93 | 94 | } 95 | 96 | 97 | class CubicEaseOut implements IEasing { 98 | 99 | 100 | public function new () { 101 | 102 | 103 | 104 | } 105 | 106 | 107 | public function calculate (k:Float):Float { 108 | 109 | return --k * k * k + 1; 110 | 111 | } 112 | 113 | 114 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 115 | 116 | return c * ((t = t / d - 1) * t * t + 1) + b; 117 | 118 | } 119 | 120 | 121 | } -------------------------------------------------------------------------------- /Client/.haxelib/actuate/1,8,7/motion/easing/Expo.hx: -------------------------------------------------------------------------------- 1 | /** 2 | * @author Joshua Granick 3 | * @author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.html 4 | */ 5 | 6 | 7 | package motion.easing; 8 | 9 | 10 | 11 | class Expo { 12 | 13 | 14 | static public var easeIn (get_easeIn, never):IEasing; 15 | static public var easeInOut (get_easeInOut, never):IEasing; 16 | static public var easeOut (get_easeOut, never):IEasing; 17 | 18 | 19 | private static function get_easeIn ():IEasing { 20 | 21 | return new ExpoEaseIn (); 22 | 23 | } 24 | 25 | 26 | private static function get_easeInOut ():IEasing { 27 | 28 | return new ExpoEaseInOut (); 29 | 30 | } 31 | 32 | 33 | private static function get_easeOut ():IEasing { 34 | 35 | return new ExpoEaseOut (); 36 | 37 | } 38 | 39 | 40 | } 41 | 42 | 43 | class ExpoEaseIn implements IEasing { 44 | 45 | 46 | public function new () { 47 | 48 | 49 | 50 | } 51 | 52 | 53 | public function calculate (k:Float):Float { 54 | 55 | return k == 0 ? 0 : Math.pow(2, 10 * (k - 1)); 56 | 57 | } 58 | 59 | 60 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 61 | 62 | return t == 0 ? b : c * Math.pow(2, 10 * (t / d - 1)) + b; 63 | 64 | } 65 | 66 | 67 | } 68 | 69 | 70 | class ExpoEaseInOut implements IEasing { 71 | 72 | 73 | public function new () { 74 | 75 | 76 | 77 | } 78 | 79 | 80 | public function calculate (k:Float):Float { 81 | 82 | if (k == 0) { return 0; } 83 | if (k == 1) { return 1; } 84 | if ((k /= 1 / 2.0) < 1.0) { 85 | return 0.5 * Math.pow(2, 10 * (k - 1)); 86 | } 87 | return 0.5 * (2 - Math.pow(2, -10 * --k)); 88 | 89 | } 90 | 91 | 92 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 93 | 94 | if (t == 0) { 95 | return b; 96 | } 97 | if (t == d) { 98 | return b + c; 99 | } 100 | if ((t /= d / 2.0) < 1.0) { 101 | return c / 2 * Math.pow(2, 10 * (t - 1)) + b; 102 | } 103 | return c / 2 * (2 - Math.pow(2, -10 * --t)) + b; 104 | 105 | } 106 | 107 | 108 | } 109 | 110 | 111 | class ExpoEaseOut implements IEasing { 112 | 113 | 114 | public function new () { 115 | 116 | 117 | 118 | } 119 | 120 | 121 | public function calculate (k:Float):Float { 122 | 123 | return k == 1 ? 1 : (1 - Math.pow(2, -10 * k)); 124 | 125 | } 126 | 127 | 128 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 129 | 130 | return t == d ? b + c : c * (1 - Math.pow(2, -10 * t / d)) + b; 131 | 132 | } 133 | 134 | 135 | } -------------------------------------------------------------------------------- /Client/.haxelib/actuate/1,8,7/motion/easing/IEasing.hx: -------------------------------------------------------------------------------- 1 | package motion.easing; 2 | 3 | 4 | /** 5 | * @author Joshua Granick 6 | * @author Philippe / http://philippe.elsass.me 7 | */ 8 | interface IEasing { 9 | 10 | 11 | function calculate (k:Float):Float; 12 | function ease (t:Float, b:Float, c:Float, d:Float):Float; 13 | 14 | 15 | } -------------------------------------------------------------------------------- /Client/.haxelib/actuate/1,8,7/motion/easing/Linear.hx: -------------------------------------------------------------------------------- 1 | /** 2 | * @author Joshua Granick 3 | * @author Philippe / http://philippe.elsass.me 4 | * @author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.html 5 | */ 6 | 7 | 8 | package motion.easing; 9 | 10 | 11 | class Linear { 12 | 13 | 14 | static public var easeNone (get_easeNone, never):IEasing; 15 | 16 | 17 | private static function get_easeNone ():IEasing { 18 | 19 | return new LinearEaseNone (); 20 | 21 | } 22 | 23 | 24 | } 25 | 26 | 27 | class LinearEaseNone implements IEasing { 28 | 29 | 30 | public function new () { 31 | 32 | 33 | 34 | } 35 | 36 | 37 | public function calculate (k:Float):Float { 38 | 39 | return k; 40 | 41 | } 42 | 43 | 44 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 45 | 46 | return c * t / d + b; 47 | 48 | } 49 | 50 | 51 | } -------------------------------------------------------------------------------- /Client/.haxelib/actuate/1,8,7/motion/easing/Quad.hx: -------------------------------------------------------------------------------- 1 | /** 2 | * @author Joshua Granick 3 | * @author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.html 4 | */ 5 | 6 | 7 | package motion.easing; 8 | 9 | 10 | 11 | class Quad { 12 | 13 | 14 | static public var easeIn (get_easeIn, never):IEasing; 15 | static public var easeInOut (get_easeInOut, never):IEasing; 16 | static public var easeOut (get_easeOut, never):IEasing; 17 | 18 | 19 | private static function get_easeIn ():IEasing { 20 | 21 | return new QuadEaseIn (); 22 | 23 | } 24 | 25 | 26 | private static function get_easeInOut ():IEasing { 27 | 28 | return new QuadEaseInOut (); 29 | 30 | } 31 | 32 | 33 | private static function get_easeOut ():IEasing { 34 | 35 | return new QuadEaseOut (); 36 | 37 | } 38 | 39 | 40 | } 41 | 42 | 43 | class QuadEaseIn implements IEasing { 44 | 45 | 46 | public function new () { 47 | 48 | 49 | 50 | } 51 | 52 | 53 | public function calculate (k:Float):Float { 54 | 55 | return k * k; 56 | 57 | } 58 | 59 | 60 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 61 | 62 | return c * (t /= d) * t + b; 63 | 64 | } 65 | 66 | 67 | } 68 | 69 | 70 | class QuadEaseInOut implements IEasing { 71 | 72 | 73 | public function new () { 74 | 75 | 76 | 77 | } 78 | 79 | 80 | public function calculate (k:Float):Float { 81 | 82 | if ((k *= 2) < 1) { 83 | return 1 / 2 * k * k; 84 | } 85 | return -1 / 2 * ((k - 1) * (k - 3) - 1); 86 | 87 | } 88 | 89 | 90 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 91 | 92 | if ((t /= d / 2) < 1) { 93 | return c / 2 * t * t + b; 94 | } 95 | return -c / 2 * ((t - 1) * (t - 3) - 1) + b; 96 | 97 | } 98 | 99 | 100 | } 101 | 102 | 103 | class QuadEaseOut implements IEasing { 104 | 105 | 106 | public function new () { 107 | 108 | 109 | 110 | } 111 | 112 | 113 | public function calculate (k:Float):Float { 114 | 115 | return -k * (k - 2); 116 | 117 | } 118 | 119 | 120 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 121 | 122 | return -c * (t /= d) * (t - 2) + b; 123 | 124 | } 125 | 126 | 127 | } -------------------------------------------------------------------------------- /Client/.haxelib/actuate/1,8,7/motion/easing/Quart.hx: -------------------------------------------------------------------------------- 1 | /** 2 | * @author Joshua Granick 3 | * @author Philippe / http://philippe.elsass.me 4 | * @author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.html 5 | */ 6 | 7 | 8 | package motion.easing; 9 | 10 | 11 | class Quart { 12 | 13 | 14 | static public var easeIn (get_easeIn, never):IEasing; 15 | static public var easeInOut (get_easeInOut, never):IEasing; 16 | static public var easeOut (get_easeOut, never):IEasing; 17 | 18 | 19 | private static function get_easeIn ():IEasing { 20 | 21 | return new QuartEaseIn (); 22 | 23 | } 24 | 25 | 26 | private static function get_easeInOut ():IEasing { 27 | 28 | return new QuartEaseInOut (); 29 | 30 | } 31 | 32 | 33 | private static function get_easeOut ():IEasing { 34 | 35 | return new QuartEaseOut (); 36 | 37 | } 38 | 39 | 40 | } 41 | 42 | 43 | class QuartEaseIn implements IEasing { 44 | 45 | 46 | public function new () { 47 | 48 | 49 | 50 | } 51 | 52 | 53 | public function calculate (k:Float):Float { 54 | 55 | return k * k * k * k; 56 | 57 | } 58 | 59 | 60 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 61 | 62 | return c * (t /= d) * t * t * t + b; 63 | 64 | } 65 | 66 | 67 | } 68 | 69 | 70 | class QuartEaseInOut implements IEasing { 71 | 72 | 73 | public function new () { 74 | 75 | 76 | 77 | } 78 | 79 | 80 | public function calculate (k:Float):Float { 81 | 82 | if ((k *= 2) < 1) return 0.5 * k * k * k * k; 83 | return -0.5 * ((k -= 2) * k * k * k - 2); 84 | 85 | } 86 | 87 | 88 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 89 | 90 | if ((t /= d / 2) < 1) { 91 | return c / 2 * t * t * t * t + b; 92 | } 93 | return -c / 2 * ((t -= 2) * t * t * t - 2) + b; 94 | 95 | } 96 | 97 | 98 | } 99 | 100 | 101 | class QuartEaseOut implements IEasing { 102 | 103 | 104 | public function new () { 105 | 106 | 107 | 108 | } 109 | 110 | 111 | public function calculate (k:Float):Float { 112 | 113 | return -(--k * k * k * k - 1); 114 | 115 | } 116 | 117 | 118 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 119 | 120 | return -c * ((t = t / d - 1) * t * t * t - 1) + b; 121 | 122 | } 123 | 124 | 125 | } -------------------------------------------------------------------------------- /Client/.haxelib/actuate/1,8,7/motion/easing/Quint.hx: -------------------------------------------------------------------------------- 1 | /** 2 | * @author Joshua Granick 3 | * @author Philippe / http://philippe.elsass.me 4 | * @author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.html 5 | */ 6 | 7 | 8 | package motion.easing; 9 | 10 | 11 | class Quint { 12 | 13 | 14 | static public var easeIn (get_easeIn, never):IEasing; 15 | static public var easeInOut (get_easeInOut, never):IEasing; 16 | static public var easeOut (get_easeOut, never):IEasing; 17 | 18 | 19 | private static function get_easeIn ():IEasing { 20 | 21 | return new QuintEaseIn (); 22 | 23 | } 24 | 25 | 26 | private static function get_easeInOut ():IEasing { 27 | 28 | return new QuintEaseInOut (); 29 | 30 | } 31 | 32 | 33 | private static function get_easeOut ():IEasing { 34 | 35 | return new QuintEaseOut (); 36 | 37 | } 38 | 39 | 40 | } 41 | 42 | 43 | class QuintEaseIn implements IEasing { 44 | 45 | 46 | public function new () { 47 | 48 | 49 | 50 | } 51 | 52 | 53 | public function calculate (k:Float):Float { 54 | 55 | return k * k * k * k * k; 56 | 57 | } 58 | 59 | 60 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 61 | 62 | return c * (t /= d) * t * t * t * t + b; 63 | 64 | } 65 | 66 | 67 | } 68 | 69 | 70 | class QuintEaseInOut implements IEasing { 71 | 72 | 73 | public function new () { 74 | 75 | 76 | 77 | } 78 | 79 | 80 | public function calculate (k:Float):Float { 81 | 82 | if ((k *= 2) < 1) return 0.5 * k * k * k * k * k; 83 | return 0.5 * ((k -= 2) * k * k * k * k + 2); 84 | 85 | } 86 | 87 | 88 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 89 | 90 | if ((t /= d / 2) < 1) { 91 | return c / 2 * t * t * t * t * t + b; 92 | } 93 | return c / 2 * ((t -= 2) * t * t * t * t + 2) + b; 94 | 95 | } 96 | 97 | 98 | } 99 | 100 | 101 | class QuintEaseOut implements IEasing { 102 | 103 | 104 | public function new () { 105 | 106 | 107 | 108 | } 109 | 110 | 111 | public function calculate (k:Float):Float { 112 | 113 | return --k * k * k * k * k + 1; 114 | 115 | } 116 | 117 | 118 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 119 | 120 | return c * ((t = t / d - 1) * t * t * t * t + 1) + b; 121 | 122 | } 123 | 124 | 125 | } -------------------------------------------------------------------------------- /Client/.haxelib/actuate/1,8,7/motion/easing/Sine.hx: -------------------------------------------------------------------------------- 1 | /** 2 | * @author Joshua Granick 3 | * @author Robert Penner / http://www.robertpenner.com/easing_terms_of_use.html 4 | */ 5 | 6 | 7 | package motion.easing; 8 | 9 | 10 | class Sine { 11 | 12 | 13 | static public var easeIn (get_easeIn, never):IEasing; 14 | static public var easeInOut (get_easeInOut, never):IEasing; 15 | static public var easeOut (get_easeOut, never):IEasing; 16 | 17 | 18 | private static function get_easeIn ():IEasing { 19 | 20 | return new SineEaseIn (); 21 | 22 | } 23 | 24 | 25 | private static function get_easeInOut ():IEasing { 26 | 27 | return new SineEaseInOut (); 28 | 29 | } 30 | 31 | 32 | private static function get_easeOut ():IEasing { 33 | 34 | return new SineEaseOut (); 35 | 36 | } 37 | 38 | 39 | } 40 | 41 | 42 | class SineEaseIn implements IEasing { 43 | 44 | 45 | public function new () { 46 | 47 | 48 | 49 | } 50 | 51 | 52 | public function calculate (k:Float):Float { 53 | 54 | return 1 - Math.cos(k * (Math.PI / 2)); 55 | 56 | } 57 | 58 | 59 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 60 | 61 | return -c * Math.cos(t / d * (Math.PI / 2)) + c + b; 62 | 63 | } 64 | 65 | 66 | } 67 | 68 | 69 | class SineEaseInOut implements IEasing { 70 | 71 | 72 | public function new () { 73 | 74 | 75 | 76 | } 77 | 78 | 79 | public function calculate (k:Float):Float { 80 | 81 | return - (Math.cos(Math.PI * k) - 1) / 2; 82 | 83 | } 84 | 85 | 86 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 87 | 88 | return -c / 2 * (Math.cos(Math.PI * t / d) - 1) + b; 89 | 90 | } 91 | 92 | 93 | } 94 | 95 | 96 | class SineEaseOut implements IEasing { 97 | 98 | 99 | public function new () { 100 | 101 | 102 | 103 | } 104 | 105 | 106 | public function calculate (k:Float):Float { 107 | 108 | return Math.sin(k * (Math.PI / 2)); 109 | 110 | } 111 | 112 | 113 | public function ease (t:Float, b:Float, c:Float, d:Float):Float { 114 | 115 | return c * Math.sin(t / d * (Math.PI / 2)) + b; 116 | 117 | } 118 | 119 | 120 | } -------------------------------------------------------------------------------- /Client/.haxelib/haxeui-code-editor/.current: -------------------------------------------------------------------------------- 1 | git -------------------------------------------------------------------------------- /Client/.haxelib/haxeui-core/.current: -------------------------------------------------------------------------------- 1 | git -------------------------------------------------------------------------------- /Client/.haxelib/haxeui-html5/.current: -------------------------------------------------------------------------------- 1 | git -------------------------------------------------------------------------------- /Client/.haxelib/hscript/.current: -------------------------------------------------------------------------------- 1 | 2.1.1 -------------------------------------------------------------------------------- /Client/.haxelib/hscript/2,1,1/README.md: -------------------------------------------------------------------------------- 1 | hscript 2 | ======= 3 | 4 | [![TravisCI Build Status](https://travis-ci.org/HaxeFoundation/hscript.svg?branch=master)](https://travis-ci.org/HaxeFoundation/hscript) 5 | [![AppVeyor Build Status](https://ci.appveyor.com/api/projects/status/github/HaxeFoundation/hscript?branch=master&svg=true)](https://ci.appveyor.com/project/HaxeFoundation/hscript) 6 | 7 | Parse and evalutate Haxe expressions. 8 | 9 | 10 | In some projects it's sometimes useful to be able to interpret some code dynamically, without recompilation. 11 | 12 | Haxe script is a complete subset of the Haxe language. 13 | 14 | It is dynamically typed but allows all Haxe expressions apart from type (class,enum,typedef) declarations. 15 | 16 | Usage 17 | ----- 18 | 19 | ```haxe 20 | var expr = "var x = 4; 1 + 2 * x"; 21 | var parser = new hscript.Parser(); 22 | var ast = parser.parseString(expr); 23 | var interp = new hscript.Interp(); 24 | trace(interp.execute(ast)); 25 | ``` 26 | 27 | In case of a parsing error an `hscript.Expr.Error` is thrown. You can use `parser.line` to check the line number. 28 | 29 | You can set some globaly accessible identifiers by using `interp.variables.set("name",value)` 30 | 31 | Example 32 | ------- 33 | 34 | Here's a small example of Haxe Script usage : 35 | ```haxe 36 | var script = " 37 | var sum = 0; 38 | for( a in angles ) 39 | sum += Math.cos(a); 40 | sum; 41 | "; 42 | var parser = new hscript.Parser(); 43 | var program = parser.parseString(script); 44 | var interp = new hscript.Interp(); 45 | interp.variables.set("Math",Math); // share the Math class 46 | interp.variables.set("angles",[0,1,2,3]); // set the angles list 47 | trace( interp.execute(program) ); 48 | ``` 49 | 50 | This will calculate the sum of the cosines of the angles given as input. 51 | 52 | Haxe Script has not been really optimized, and it's not meant to be very fast. But it's entirely crossplatform since it's pure Haxe code (it doesn't use any platform-specific API). 53 | 54 | Advanced Usage 55 | -------------- 56 | 57 | When compiled with `-D hscriptPos` you will get fine error reporting at parsing time. 58 | 59 | You can subclass `hscript.Interp` to override behaviors for `get`, `set`, `call`, `fcall` and `cnew`. 60 | 61 | You can add more binary and unary operations to the parser by setting `opPriority`, `opRightAssoc` and `unops` content. 62 | 63 | You can use `parser.allowJSON` to allow JSON data. 64 | 65 | You can use `parser.allowTypes` to parse types for local vars, exceptions, function args and return types. Types are ignored by the interpreter. 66 | 67 | You can use `new hscript.Macro(pos).convert(ast)` to convert an hscript AST to a Haxe macros one. 68 | 69 | Limitations 70 | ----------- 71 | 72 | Compared to Haxe, limitations are : 73 | 74 | - no type declarations (classes, enums, typedefs) : only expressions 75 | - `switch` construct is supported but not pattern matching (no variable capture, we use strict equality to compare `case` values and `switch` value) 76 | - only one variable declaration is allowed in `var` 77 | - the parser supports optional types for `var` and `function` if `allowTypes` is set, but the interpreter ignores them 78 | - you can enable per-expression position tracking by compiling with `-D hscriptPos` 79 | 80 | Install 81 | ------- 82 | 83 | In order to install Haxe Script, use `haxelib install hscript` and compile your program with `-lib hscript`. 84 | 85 | There are only three files in hscript : 86 | 87 | - `hscript.Expr` : contains enums declarations 88 | - `hscript.Parser` : a small parser that turns a string into an expression structure (AST) 89 | - `hscript.Interp` : a small interpreter that execute the AST and returns the latest evaluated value 90 | -------------------------------------------------------------------------------- /Client/.haxelib/hscript/2,1,1/extraParams.hxml: -------------------------------------------------------------------------------- 1 | --macro keep('IntIterator') -------------------------------------------------------------------------------- /Client/.haxelib/hscript/2,1,1/haxelib.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "hscript", 3 | "url": "https://github.com/HaxeFoundation/hscript", 4 | "license": "MIT", 5 | "description": "Haxe Script is a scripting engine for a subset of the Haxe language", 6 | "version": "2.1.1", 7 | "releasenote": "added metadata support", 8 | "contributors": ["ncannasse"] 9 | } -------------------------------------------------------------------------------- /Client/.haxelib/hscript/2,1,1/hscript/Tools.hx: -------------------------------------------------------------------------------- 1 | package hscript; 2 | import hscript.Expr; 3 | 4 | class Tools { 5 | 6 | public static function iter( e : Expr, f : Expr -> Void ) { 7 | switch( e ) { 8 | case EConst(_), EIdent(_): 9 | case EVar(_, _, e): if( e != null ) f(e); 10 | case EParent(e): f(e); 11 | case EBlock(el): for( e in el ) f(e); 12 | case EField(e, _): f(e); 13 | case EBinop(_, e1, e2): f(e1); f(e2); 14 | case EUnop(_, _, e): f(e); 15 | case ECall(e, args): f(e); for( a in args ) f(a); 16 | case EIf(c, e1, e2): f(c); f(e1); if( e2 != null ) f(e2); 17 | case EWhile(c, e): f(c); f(e); 18 | case EDoWhile(c, e): f(c); f(e); 19 | case EFor(_, it, e): f(it); f(e); 20 | case EBreak,EContinue: 21 | case EFunction(_, e, _, _): f(e); 22 | case EReturn(e): if( e != null ) f(e); 23 | case EArray(e, i): f(e); f(i); 24 | case EArrayDecl(el): for( e in el ) f(e); 25 | case ENew(_,el): for( e in el ) f(e); 26 | case EThrow(e): f(e); 27 | case ETry(e, _, _, c): f(e); f(c); 28 | case EObject(fl): for( fi in fl ) f(fi.e); 29 | case ETernary(c, e1, e2): f(c); f(e1); f(e2); 30 | case ESwitch(e, cases, def): 31 | f(e); 32 | for( c in cases ) { 33 | for( v in c.values ) f(v); 34 | f(c.expr); 35 | } 36 | if( def != null ) f(def); 37 | } 38 | } 39 | 40 | public static function map( e : Expr, f : Expr -> Expr ) { 41 | return switch( e ) { 42 | case EConst(_), EIdent(_): e; 43 | case EVar(n, t, e): EVar(n, t, if( e != null ) f(e) else null); 44 | case EParent(e): EParent(f(e)); 45 | case EBlock(el): EBlock([for( e in el ) f(e)]); 46 | case EField(e, fi): EField(f(e),fi); 47 | case EBinop(op, e1, e2): EBinop(op, f(e1), f(e2)); 48 | case EUnop(op, pre, e): EUnop(op, pre, f(e)); 49 | case ECall(e, args): ECall(f(e),[for( a in args ) f(a)]); 50 | case EIf(c, e1, e2): EIf(f(c),f(e1),if( e2 != null ) f(e2) else null); 51 | case EWhile(c, e): EWhile(f(c),f(e)); 52 | case EDoWhile(c, e): EDoWhile(f(c),f(e)); 53 | case EFor(v, it, e): EFor(v, f(it), f(e)); 54 | case EBreak, EContinue: e; 55 | case EFunction(args, e, name, t): EFunction(args, f(e), name, t); 56 | case EReturn(e): EReturn(if( e != null ) f(e) else null); 57 | case EArray(e, i): EArray(f(e),f(i)); 58 | case EArrayDecl(el): EArrayDecl([for( e in el ) f(e)]); 59 | case ENew(cl,el): ENew(cl,[for( e in el ) f(e)]); 60 | case EThrow(e): EThrow(f(e)); 61 | case ETry(e, v, t, c): ETry(f(e), v, t, f(c)); 62 | case EObject(fl): EObject([for( fi in fl ) { name : fi.name, e : f(fi.e) }]); 63 | case ETernary(c, e1, e2): ETernary(f(c), f(e1), f(e2)); 64 | case ESwitch(e, cases, def): ESwitch(f(e), [for( c in cases ) { values : [for( v in c.values ) f(v)], expr : f(c.expr) } ], def == null ? null : f(def)); 65 | } 66 | } 67 | 68 | } -------------------------------------------------------------------------------- /Client/.haxelib/hscript/2,1,1/run.n: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/.haxelib/hscript/2,1,1/run.n -------------------------------------------------------------------------------- /Client/.haxelib/hscript/2,1,1/script/build.hxml: -------------------------------------------------------------------------------- 1 | -main RunScript 2 | -neko ../run.n 3 | -lib hscript 4 | -dce no 5 | -------------------------------------------------------------------------------- /Client/.haxelib/monaco-editor/.current: -------------------------------------------------------------------------------- 1 | git -------------------------------------------------------------------------------- /Client/.haxelib/tink_await/.current: -------------------------------------------------------------------------------- 1 | 0.3.0 -------------------------------------------------------------------------------- /Client/.haxelib/tink_await/0,3,0/extraParams.hxml: -------------------------------------------------------------------------------- 1 | --macro tink.await.Await.use() -------------------------------------------------------------------------------- /Client/.haxelib/tink_await/0,3,0/haxelib.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "tink_await", 3 | "url" : "https://github.com/haxetink/tink_await", 4 | "license": "MIT", 5 | "tags": ["tink", "cross", "utility", "sugar", "async"], 6 | "description": "Haxe async/await", 7 | "version": "0.3.0", 8 | "releasenote": "Support haxe 4", 9 | "contributors": ["benmerckx"], 10 | "classPath": "src", 11 | "dependencies": { 12 | "tink_macro": "", 13 | "tink_core": "", 14 | "tink_syntaxhub": "" 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Client/.haxelib/tink_await/0,3,0/src/tink/await/Await.hx: -------------------------------------------------------------------------------- 1 | package tink.await; 2 | 3 | import haxe.macro.Expr; 4 | import tink.macro.ClassBuilder; 5 | import tink.macro.Member; 6 | import haxe.macro.Type.MetaAccess; 7 | 8 | using tink.MacroApi; 9 | 10 | class Await { 11 | 12 | public static function isAwait(keyword: String) 13 | return keyword == 'await' || keyword == ':await'; 14 | 15 | public static function isAsync(keyword: String) 16 | return keyword == 'async' || keyword == ':async'; 17 | 18 | public static function use() { 19 | trace('ok'); 20 | function appliesTo(m: MetaAccess) 21 | return m.has('await') || m.has(':await'); 22 | 23 | SyntaxHub.classLevel.after( 24 | function (_) return true, 25 | function (c: ClassBuilder) { 26 | if (c.target.isInterface && !appliesTo(c.target.meta)) 27 | return false; 28 | 29 | if (!appliesTo(c.target.meta)) { 30 | for (i in c.target.interfaces) 31 | if (appliesTo(i.t.get().meta)) { 32 | applyTo(c); 33 | return true; 34 | } 35 | return false; 36 | } 37 | else { 38 | applyTo(c); 39 | return true; 40 | } 41 | } 42 | ); 43 | } 44 | 45 | @:access(tink.macro.Constructor) 46 | static function applyTo(builder: ClassBuilder) { 47 | for (member in builder) 48 | processMember(member); 49 | if(builder.hasConstructor()) { 50 | var constructor = builder.getConstructor(); 51 | for (meta in constructor.meta) 52 | if (isAwait(meta.name)) 53 | constructor.onGenerate(function(func) { 54 | var processed = transform(func, false, 'new', constructor.pos); 55 | func.expr = processed.expr; 56 | }); 57 | else if (isAsync(meta.name)) 58 | haxe.macro.Context.error('@async not allowed on constructor', constructor.pos); 59 | } 60 | } 61 | 62 | static function transform(func: Function, async: Bool, name: String, pos:Position): Function { 63 | var async = new AsyncField(func, async); 64 | var processed = async.transform(); 65 | #if await_debug 66 | Sys.println('======================='); 67 | Sys.println(pos); 68 | Sys.println(name); 69 | Sys.println('======================='); 70 | Sys.println(processed.expr.toString()); 71 | #end 72 | return processed; 73 | } 74 | 75 | static function processMember(member: Member) { 76 | var field: Field = member; 77 | switch member.getFunction() { 78 | case Success(func): 79 | if (field.meta != null) 80 | for (meta in field.meta) { 81 | if (isAsync(meta.name) || isAwait(meta.name)) { 82 | field.kind = FieldType.FFun(transform(func, isAsync(meta.name), field.name, field.pos)); 83 | } 84 | } 85 | default: 86 | } 87 | } 88 | 89 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_await/0,3,0/src/tink/await/Error.hx: -------------------------------------------------------------------------------- 1 | package tink.await; 2 | 3 | import tink.core.Error in TinkError; 4 | import tink.core.Any; 5 | 6 | @:forward 7 | abstract Error(TinkError) from TinkError to TinkError { 8 | 9 | @:from static public function fromAny(any: Any) 10 | return Std.is(any, TinkError) 11 | ? (any: Error) 12 | : (TinkError.withData('Unexpected Error', any): Error); 13 | 14 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_await/0,3,0/src/tink/await/LoopIterator.hx: -------------------------------------------------------------------------------- 1 | package tink.await; 2 | 3 | @:forward 4 | abstract LoopIterator(Iterator) from Iterator to Iterator { 5 | 6 | @:from public static inline function fromIterable(i: Iterable) 7 | return (i.iterator(): LoopIterator); 8 | 9 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_await/0,3,0/src/tink/await/MacroTools.hx: -------------------------------------------------------------------------------- 1 | package tink.await; 2 | 3 | import haxe.macro.Expr; 4 | using tink.CoreApi; 5 | using tink.MacroApi; 6 | 7 | class MacroExprTools { 8 | public static function at(e: Expr, pos: Position) { 9 | e.pos = pos; 10 | return e; 11 | } 12 | } 13 | 14 | class MacroTools { 15 | static var count = 0; 16 | 17 | public static function unpack(e: Expr): Expr 18 | return switch e.expr { 19 | case EBlock(el): 20 | switch el.length { 21 | case 1: unpack(el[0]); 22 | default: e; 23 | } 24 | default: e; 25 | } 26 | 27 | public static function unfold(e: Expr): Array 28 | return switch e.expr { 29 | case EBlock(el): el; 30 | default: [e]; 31 | } 32 | 33 | public static function bundle(el: Array): Expr { 34 | var response = []; 35 | for (e in el) 36 | response = response.concat(unfold(unpack(e))); 37 | return switch response.length { 38 | case 0: throw 'No expression found'; 39 | case 1: response[0]; 40 | default: response.toBlock(); 41 | } 42 | } 43 | 44 | public static function tmpVar() 45 | return "__t"+(count++); 46 | 47 | public static function emptyExpr() 48 | return [].toBlock(); 49 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_await/0,3,0/src/tink/await/OutcomeTools.hx: -------------------------------------------------------------------------------- 1 | package tink.await; 2 | 3 | import haxe.macro.Context; 4 | 5 | using tink.CoreApi; 6 | 7 | class OutcomeTools { 8 | 9 | public static function getOutcome(?outcome: tink.core.Outcome, ?value: A): Outcome { 10 | if (outcome == null) return Success(value); 11 | return outcome; 12 | } 13 | 14 | } 15 | 16 | /* TODO: see if this could work someway 17 | abstract OutcomeData(T) to T { 18 | 19 | public inline function new(data) 20 | this = data; 21 | 22 | @:from static public function fromOutcome(outcome: tink.core.Outcome) 23 | return switch outcome { 24 | case tink.core.Outcome.Success(v): 25 | return new OutcomeData(v); 26 | case tink.core.Outcome.Failure(e): 27 | throw e; 28 | } 29 | 30 | @:from inline static public function fromAny(any: Dynamic) 31 | return new OutcomeData(any); 32 | 33 | } 34 | */ -------------------------------------------------------------------------------- /Client/.haxelib/tink_await/0,3,0/src/tink/await/Thunk.hx: -------------------------------------------------------------------------------- 1 | package tink.await; 2 | 3 | abstract Thunk(ThunkData) from ThunkData to ThunkData { 4 | 5 | inline function new(data: ThunkData) 6 | this = data; 7 | 8 | @:from public static inline function fromCont(thunk: Void -> Thunk): Thunk 9 | return new Thunk(Cont(thunk)); 10 | 11 | @:from public static inline function fromCall(thunk: Void -> T): Thunk 12 | return new Thunk(Call(thunk)); 13 | 14 | @:from public static inline function fromValue(value: T): Thunk 15 | return new Thunk(Done(value)); 16 | 17 | @:to public inline function toT(): T { 18 | var result: T, part: ThunkData = this; 19 | while(true) switch part { 20 | case Cont(thunk): 21 | part = thunk(); 22 | case Call(thunk): 23 | result = thunk(); 24 | break; 25 | case Done(v): 26 | result = v; 27 | break; 28 | } 29 | return result; 30 | } 31 | } 32 | 33 | enum ThunkData { 34 | Cont(thunk: Void -> Thunk); 35 | Call(thunk: Void -> T); 36 | Done(value: T); 37 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_core/.current: -------------------------------------------------------------------------------- 1 | 1.15.3 -------------------------------------------------------------------------------- /Client/.haxelib/tink_core/1,15,3/README.md: -------------------------------------------------------------------------------- 1 | # Tinkerbell Core Library 2 | 3 | [![Build Status](https://travis-ci.org/haxetink/tink_core.svg)](https://travis-ci.org/haxetink/tink_core) 4 | [![Gitter](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/haxetink/public) 5 | 6 | The `tink_core` lib contains a set of lightweight tools for robust programming. 7 | 8 | All modules are situated in `tink.core.*`. Some contain more than a single type. Generally, it is advisable to import the modules of this package through `using` rather than `import`. 9 | 10 | In addition, you can import all modules at once with `using tink.CoreApi;`. 11 | 12 | ### Documentations 13 | 14 | Documentations have been moved to a new home: https://haxetink.github.io/tink_core/ 15 | -------------------------------------------------------------------------------- /Client/.haxelib/tink_core/1,15,3/haxelib.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "tink_core", 3 | "license": "MIT", 4 | "tags": [ 5 | "tink", 6 | "cross", 7 | "utility", 8 | "reactive", 9 | "functional", 10 | "async", 11 | "lazy", 12 | "signal", 13 | "event" 14 | ], 15 | "classPath": "src", 16 | "description": "Tinkerbell Core", 17 | "contributors": [ 18 | "back2dos" 19 | ], 20 | "releasenote": "Shorthand to create future/promise that resolves a null", 21 | "version": "1.15.3", 22 | "url": "http://haxetink.org/tink_core" 23 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_core/1,15,3/src/tink/CoreApi.hx: -------------------------------------------------------------------------------- 1 | package tink; 2 | 3 | typedef Annex = tink.core.Annex; 4 | 5 | typedef Next = tink.core.Promise.Next; 6 | typedef Combiner = tink.core.Promise.Combiner; 7 | typedef Promise = tink.core.Promise; 8 | typedef Future = tink.core.Future; 9 | typedef Futuristic = tink.core.Future.Futuristic; 10 | 11 | typedef Surprise = tink.core.Future.Surprise; 12 | #if js typedef JsPromiseTools = tink.core.Future.JsPromiseTools; #end 13 | typedef FutureTrigger = tink.core.Future.FutureTrigger; 14 | 15 | typedef Outcome = tink.core.Outcome; 16 | typedef OutcomeTools = tink.core.Outcome.OutcomeTools; 17 | 18 | typedef Either = tink.core.Either; 19 | typedef Option = tink.core.Option; 20 | typedef OptionTools = tink.core.Option.OptionTools; 21 | 22 | typedef Pair = tink.core.Pair; 23 | typedef MPair = tink.core.Pair.MPair; 24 | 25 | typedef Signal = tink.core.Signal; 26 | typedef SignalTrigger = tink.core.Signal.SignalTrigger; 27 | 28 | typedef Noise = tink.core.Noise; 29 | 30 | typedef Error = tink.core.Error; 31 | typedef TypedError = tink.core.Error.TypedError; 32 | 33 | typedef Callback = tink.core.Callback; 34 | typedef CallbackLink = tink.core.Callback.CallbackLink; 35 | typedef CallbackList = tink.core.Callback.CallbackList; 36 | 37 | typedef Ref = tink.core.Ref; 38 | typedef Lazy = tink.core.Lazy; 39 | typedef Any = tink.core.Any; 40 | 41 | typedef Named = tink.core.Named; 42 | typedef NamedWith = tink.core.Named.NamedWith; -------------------------------------------------------------------------------- /Client/.haxelib/tink_core/1,15,3/src/tink/core/Annex.hx: -------------------------------------------------------------------------------- 1 | package tink.core; 2 | 3 | private typedef AnnexableTo = 4 | #if (haxe_ver >= 3.4) 5 | haxe.Constraints.ConstructibleVoid> 6 | #else 7 | { function new(targeT:T):Void; } 8 | #end 9 | 10 | class Annex { 11 | 12 | var target:Target; 13 | var registry:Map; 14 | 15 | public function new(target:Target) { 16 | this.target = target; 17 | this.registry = cast new haxe.ds.ObjectMap(); 18 | } 19 | #if (java || cs) @:extern #end 20 | @:generic public inline function get>(c:Class):A 21 | return switch registry[c] { 22 | case null: registry[c] = new A(target); 23 | case v: v; 24 | } 25 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_core/1,15,3/src/tink/core/Any.hx: -------------------------------------------------------------------------------- 1 | package tink.core; 2 | 3 | abstract Any(Dynamic) from Dynamic { 4 | @:noCompletion @:to inline function __promote():A return this; 5 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_core/1,15,3/src/tink/core/Either.hx: -------------------------------------------------------------------------------- 1 | package tink.core; 2 | 3 | typedef Either = haxe.ds.Either; -------------------------------------------------------------------------------- /Client/.haxelib/tink_core/1,15,3/src/tink/core/Lazy.hx: -------------------------------------------------------------------------------- 1 | package tink.core; 2 | 3 | abstract Lazy(LazyObject) from LazyObject { 4 | 5 | @:to public inline function get():T 6 | return this.get(); 7 | 8 | @:from static public inline function ofFunc(f:Void->T):Lazy 9 | return new LazyFunc(f); 10 | 11 | public inline function map(f:T->A):Lazy 12 | return this.map(f); 13 | 14 | public inline function flatMap(f:T->Lazy):Lazy 15 | return this.flatMap(f); 16 | 17 | @:from @:noUsing static inline function ofConst(c:T):Lazy 18 | return new LazyConst(c); 19 | } 20 | 21 | private interface LazyObject { 22 | function get():T; 23 | function map(f:T->R):Lazy; 24 | function flatMap(f:T->Lazy):Lazy; 25 | } 26 | 27 | private class LazyConst implements LazyObject { 28 | 29 | var value:T; 30 | 31 | public inline function new(value) 32 | this.value = value; 33 | 34 | public inline function get() 35 | return value; 36 | 37 | public inline function map(f:T->R):Lazy 38 | return new LazyConst(f(value)); 39 | 40 | public inline function flatMap(f:T->Lazy):Lazy 41 | return f(value); 42 | } 43 | 44 | private class LazyFunc implements LazyObject { 45 | var f:Void->T; 46 | var result:T; 47 | #if debug var busy = false; #end 48 | 49 | public function new(f) this.f = f; 50 | 51 | public function get() { 52 | #if debug if (busy) throw new Error('circular lazyness');#end 53 | if (f != null) { 54 | #if debug busy = true;#end 55 | result = f(); 56 | f = null; 57 | #if debug busy = false;#end 58 | } 59 | return result; 60 | } 61 | 62 | public inline function map(f:T->R):Lazy 63 | return new LazyFunc(function () return f(get())); 64 | 65 | public inline function flatMap(f:T->Lazy):Lazy 66 | return new LazyFunc(function () return f(get()).get()); 67 | } 68 | -------------------------------------------------------------------------------- /Client/.haxelib/tink_core/1,15,3/src/tink/core/Named.hx: -------------------------------------------------------------------------------- 1 | package tink.core; 2 | 3 | typedef Named = NamedWith; 4 | 5 | class NamedWith { 6 | 7 | public var name(default, null):N; 8 | public var value(default, null):V; 9 | 10 | public function new(name, value) { 11 | this.name = name; 12 | this.value = value; 13 | } 14 | 15 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_core/1,15,3/src/tink/core/Noise.hx: -------------------------------------------------------------------------------- 1 | package tink.core; 2 | 3 | #if cs 4 | @:native('tink.core.TinkNoise') 5 | #end 6 | enum Noise { Noise; } -------------------------------------------------------------------------------- /Client/.haxelib/tink_core/1,15,3/src/tink/core/Option.hx: -------------------------------------------------------------------------------- 1 | package tink.core; 2 | 3 | typedef Option = haxe.ds.Option; 4 | 5 | class OptionTools { 6 | 7 | /** 8 | * Extracts the value if the option is `Some`, throws an `Error` otherwise 9 | */ 10 | static public inline function force(o:Option, ?pos:tink.core.Error.Pos) 11 | return switch o { 12 | case Some(v): 13 | v; 14 | default: 15 | throw new Error(NotFound, 'Some value expected but none found', pos); 16 | } 17 | 18 | /** 19 | * Extracts the value if the option is `Some`, uses the fallback value otherwise 20 | */ 21 | static public inline function or(o:Option, l:Lazy):T 22 | return switch o { 23 | case Some(v): v; 24 | default: l.get(); 25 | } 26 | 27 | /** 28 | * Extracts the value if the option is `Some`, otherwise `null` 29 | */ 30 | static public inline function orNull(o:Option):Null 31 | return switch o { 32 | case Some(v): v; 33 | default: null; 34 | } 35 | 36 | /** 37 | * Returns `Some(value)` if the option is `Some` and the filter function evaluates to `true`, otherwise `None` 38 | */ 39 | static public inline function filter(o:Option, f:T->Bool):Option 40 | return switch o { 41 | case Some(f(_) => false): None; 42 | default: o; 43 | } 44 | 45 | /** 46 | * Returns `true` if the option is `Some` and the filter function evaluates to `true`, otherwise `false` 47 | */ 48 | static public inline function satisfies(o:Option, f:T->Bool):Bool 49 | return switch o { 50 | case Some(v): f(v); 51 | default: false; 52 | } 53 | 54 | /** 55 | * Returns `true` if the option is `Some` and the value is equal to `v`, otherwise `false` 56 | */ 57 | static public inline function equals(o:Option, v:T):Bool 58 | return satisfies(o, function (found) return found == v); 59 | 60 | /** 61 | * Transforms the option value with a transform function 62 | * Different from `flatMap`, the transform function of `map` returns a plain value 63 | */ 64 | static public inline function map(o:Option, f:In->Out):Option 65 | return switch o { 66 | case Some(v): Some(f(v)); 67 | default: None; 68 | } 69 | 70 | /** 71 | * Transforms the option value with a transform function 72 | * Different from `map`, the transform function of `flatMap` returns an `Option` 73 | */ 74 | static public inline function flatMap(o:Option, f:In->Option) 75 | return switch o { 76 | case Some(v): f(v); 77 | default: None; 78 | } 79 | 80 | /** 81 | * Creates an iterator from the option. 82 | * The iterator has one item if the option is `Some`, and no items if it is `None` 83 | */ 84 | static public inline function iterator(o:Option) 85 | return new OptionIter(o); 86 | 87 | /** 88 | * Creates an array from the option. 89 | * The array has one item if the option is `Some`, and no items if it is `None` 90 | */ 91 | static public inline function toArray(o:Option) 92 | return switch o { 93 | case Some(v): [v]; 94 | default: []; 95 | } 96 | 97 | } 98 | 99 | class OptionIter { 100 | var value:T; 101 | var alive = true; 102 | 103 | public inline function new(o:Option) 104 | switch o { 105 | case Some(v): value = v; 106 | default: alive = false; 107 | } 108 | 109 | public inline function hasNext() 110 | return alive; 111 | 112 | public inline function next() { 113 | alive = false; 114 | //TODO: we might want to null the value after usage, but iterators are usually short lived 115 | return value; 116 | } 117 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_core/1,15,3/src/tink/core/Pair.hx: -------------------------------------------------------------------------------- 1 | package tink.core; 2 | 3 | abstract Pair(MPair) { 4 | 5 | public var a(get, never):A; 6 | public var b(get, never):B; 7 | 8 | public inline function new(a:A, b:B) this = new MPair(a, b); 9 | 10 | inline function get_a():A return this.a; 11 | inline function get_b():B return this.b; 12 | 13 | @:to inline function toBool() 14 | return this != null; 15 | 16 | @:op(!a) public function isNil() 17 | return this == null; 18 | 19 | static public function nil():Pair 20 | return null; 21 | } 22 | 23 | class MPair { 24 | public var a:A; 25 | public var b:B; 26 | public function new(a, b) { 27 | this.a = a; 28 | this.b = b; 29 | } 30 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_core/1,15,3/src/tink/core/Ref.hx: -------------------------------------------------------------------------------- 1 | package tink.core; 2 | 3 | abstract Ref(haxe.ds.Vector) { 4 | public var value(get, set):T; 5 | 6 | inline function new() this = new haxe.ds.Vector(1); 7 | 8 | @:to inline function get_value():T return this[0]; 9 | inline function set_value(param:T) return this[0] = param; 10 | 11 | public function toString():String return '@[' + Std.string(value)+']'; 12 | 13 | @:noUsing @:from static inline public function to(v:A):Ref { 14 | var ret = new Ref(); 15 | ret.value = v; 16 | return ret; 17 | } 18 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_macro/.current: -------------------------------------------------------------------------------- 1 | 0.15.4 -------------------------------------------------------------------------------- /Client/.haxelib/tink_macro/0,15,4/haxelib.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "tink_macro", 3 | "license": "MIT", 4 | "tags": [ 5 | "tink", 6 | "macro", 7 | "utility" 8 | ], 9 | "classPath": "src", 10 | "description": "The macro toolkit ;)", 11 | "contributors": [ 12 | "back2dos" 13 | ], 14 | "releasenote": "Report invalid type in getFields.", 15 | "version": "0.15.4", 16 | "url": "http://haxetink.org/tink_macro", 17 | "dependencies": { 18 | "tink_core": "" 19 | } 20 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_macro/0,15,4/src/tink/MacroApi.hx: -------------------------------------------------------------------------------- 1 | package tink; 2 | 3 | import haxe.macro.Expr.TypeDefinition; 4 | 5 | using tink.CoreApi; 6 | using tink.macro.Positions; 7 | 8 | typedef Positions = tink.macro.Positions; 9 | typedef ExprTools = haxe.macro.ExprTools; 10 | typedef Exprs = tink.macro.Exprs; 11 | typedef Functions = tink.macro.Functions; 12 | typedef Metadatas = tink.macro.Metadatas; 13 | typedef Bouncer = tink.macro.Bouncer; 14 | typedef Types = tink.macro.Types; 15 | typedef Binops = tink.macro.Ops.Binary; 16 | typedef Unops = tink.macro.Ops.Unary; 17 | typedef TypeMap = tink.macro.TypeMap; 18 | 19 | //TODO: consider adding stuff from haxe.macro.Expr here 20 | typedef MacroOutcome = tink.core.Outcome; 21 | typedef MacroOutcomeTools = tink.OutcomeTools; 22 | 23 | typedef Member = tink.macro.Member; 24 | typedef Constructor = tink.macro.Constructor; 25 | typedef ClassBuilder = tink.macro.ClassBuilder; 26 | 27 | typedef TypeResolution = Ref>; 28 | 29 | class MacroApi { 30 | 31 | static var idCounter = 0; 32 | 33 | @:noUsing static public inline function tempName(?prefix:String = 'tmp'):String 34 | return '__tink_' + prefix + Std.string(idCounter++); 35 | 36 | static public function pos() 37 | return haxe.macro.Context.currentPos(); 38 | 39 | } 40 | -------------------------------------------------------------------------------- /Client/.haxelib/tink_macro/0,15,4/src/tink/macro/Bouncer.hx: -------------------------------------------------------------------------------- 1 | package tink.macro; 2 | 3 | #if macro 4 | import haxe.macro.Context; 5 | import haxe.macro.Expr; 6 | 7 | using tink.macro.Positions; 8 | using tink.macro.Exprs; 9 | #end 10 | @:exclude class Bouncer { 11 | #if macro 12 | static var idCounter = 0; 13 | static var bounceMap = new MapExpr>(); 14 | static var outerMap = new MapExpr>(); 15 | static public function bounceExpr(e:Expr, transform:Expr->Expr) { 16 | var id = idCounter++, 17 | pos = e.pos; 18 | outerMap.set(id, transform); 19 | return macro @:pos(e.pos) tink.macro.Bouncer.catchBounceExpr($e, $v{id}); 20 | } 21 | static public function bounce(f:Void->Expr, ?pos:Position) { 22 | var id = idCounter++; 23 | pos = pos.sanitize(); 24 | bounceMap.set(id, f); 25 | return macro @:pos(pos) tink.macro.Bouncer.catchBounce($v{id}); 26 | } 27 | static public function outerTransform(e:Expr, transform:Expr->Expr) { 28 | var id = idCounter++, 29 | pos = e.pos; 30 | outerMap.set(id, transform); 31 | return macro @:pos(e.pos) tink.macro.Bouncer.makeOuter($e).andBounce($v{id}); 32 | } 33 | static function doOuter(id:Int, e:Expr) { 34 | return 35 | if (outerMap.exists(id)) 36 | outerMap.get(id)(e); 37 | else 38 | Context.currentPos().error('unknown id ' + id); 39 | } 40 | static function doBounce(id:Int) { 41 | return 42 | if (bounceMap.exists(id)) 43 | bounceMap.get(id)(); 44 | else 45 | Context.currentPos().error('unknown id ' + id); 46 | } 47 | #else 48 | @:noUsing static public function makeOuter(a:A):Bouncer 49 | return null; 50 | #end 51 | @:noUsing macro public function andBounce(ethis:Expr, id:Int) 52 | return 53 | switch (ethis.expr) { 54 | case ECall(_, params): doOuter(id, params[0]); 55 | default: ethis.reject(); 56 | } 57 | 58 | @:noUsing macro static public function catchBounce(id:Int) 59 | return doBounce(id); 60 | 61 | @:noUsing macro static public function catchBounceExpr(e:Expr, id:Int) 62 | return doOuter(id, e); 63 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_macro/0,15,4/src/tink/macro/DirectType.hx: -------------------------------------------------------------------------------- 1 | package tink.macro; 2 | 3 | @:genericBuild(tink.macro.Types.resolveDirectType()) 4 | class DirectType { 5 | 6 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_macro/0,15,4/src/tink/macro/Functions.hx: -------------------------------------------------------------------------------- 1 | package tink.macro; 2 | 3 | import haxe.macro.Expr; 4 | 5 | using tink.macro.Exprs; 6 | 7 | class Functions { 8 | static public inline function asExpr(f:Function, ?name, ?pos) 9 | return EFunction(name, f).at(pos); 10 | 11 | static public inline function toArg(name:String, ?t, ?opt = false, ?value = null):FunctionArg { 12 | return { 13 | name: name, 14 | opt: opt, 15 | type: t, 16 | value: value 17 | }; 18 | } 19 | static public inline function func(e:Expr, ?args:Array, ?ret:ComplexType, ?params, ?makeReturn = true):Function { 20 | return { 21 | args: args == null ? [] : args, 22 | ret: ret, 23 | params: params == null ? [] : params, 24 | expr: if (makeReturn) EReturn(e).at(e.pos) else e 25 | } 26 | } 27 | static public function getArgIdents(f:Function):Array { 28 | var ret = []; 29 | for (arg in f.args) 30 | ret.push(arg.name.resolve()); 31 | return ret; 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /Client/.haxelib/tink_macro/0,15,4/src/tink/macro/Metadatas.hx: -------------------------------------------------------------------------------- 1 | package tink.macro; 2 | 3 | import haxe.macro.Expr; 4 | 5 | class Metadatas { 6 | static public function toMap(m:Metadata) { 7 | var ret = new Map>>(); 8 | if (m != null) 9 | for (meta in m) { 10 | if (!ret.exists(meta.name)) 11 | ret.set(meta.name, []); 12 | ret.get(meta.name).push(meta.params); 13 | } 14 | return ret; 15 | } 16 | 17 | static public function getValues(m:Metadata, name:String) 18 | return 19 | if (m == null) []; 20 | else [for (meta in m) if (meta.name == name) meta.params]; 21 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_macro/0,15,4/src/tink/macro/Ops.hx: -------------------------------------------------------------------------------- 1 | package tink.macro; 2 | 3 | import haxe.macro.Expr; 4 | 5 | using tink.MacroApi; 6 | 7 | class Binary { 8 | static public function get(o:Binop, e:Expr) 9 | return 10 | switch e.expr { 11 | case EBinop(op, e1, e2): 12 | if (Type.enumEq(o, op)) 13 | Success({ e1: e1, e2:e2, pos:e.pos }); 14 | else 15 | e.pos.makeFailure('expected ' + o + ' but found ' + op); 16 | default: 17 | e.pos.makeFailure('expected binary operation ' + o); 18 | } 19 | 20 | static public function getBinop(e:Expr) 21 | return 22 | switch e.expr { 23 | case EBinop(op, e1, e2): 24 | Success({ e1: e1, e2:e2, op:op, pos:e.pos }); 25 | default: 26 | e.pos.makeFailure('expected binary operation but found ' + Type.enumConstructor(e.expr)); 27 | } 28 | 29 | static public inline function make(op:Binop, e1:Expr, e2:Expr, ?pos) 30 | return Exprs.binOp(e1, e2, op, pos); 31 | } 32 | 33 | class Unary { 34 | static public function get(o:Unop, e:Expr, postfix:Bool = false) 35 | return 36 | switch e.expr { 37 | case EUnop(op, postFix, arg): 38 | if (postFix != postfix) 39 | e.pos.makeFailure(postfix ? 'expected postfix operator' : 'expected prefix operator'); 40 | else if (!Type.enumEq(o, op)) 41 | e.pos.makeFailure('expected ' + o + ' but found ' + op); 42 | else 43 | Success({ e: arg, pos:e.pos }); 44 | default: 45 | e.pos.makeFailure('expected unary operation ' + o); 46 | } 47 | 48 | static public function getUnop(e:Expr) 49 | return 50 | switch e.expr { 51 | case EUnop(op, postFix, arg): 52 | Success({ op: op, postfix: postFix, e: arg, pos: e.pos }); 53 | default: 54 | e.pos.makeFailure('expected unary operation but found ' + Type.enumConstructor(e.expr)); 55 | } 56 | 57 | static public function make(op:Unop, e:Expr, ?postFix = false, ?pos) 58 | return EUnop(op, postFix, e).at(pos); 59 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_macro/0,15,4/src/tink/macro/Positions.hx: -------------------------------------------------------------------------------- 1 | package tink.macro; 2 | 3 | import haxe.macro.Context; 4 | import haxe.macro.Expr; 5 | import tink.core.Error; 6 | 7 | using tink.macro.Positions; 8 | using tink.core.Outcome; 9 | 10 | class Positions { 11 | static public function getOutcome(pos:Position, outcome:Outcome):D 12 | return 13 | switch outcome { 14 | case Success(d): d; 15 | case Failure(f): pos.error(f); 16 | } 17 | 18 | static public function makeBlankType(pos:Position):ComplexType 19 | return Types.toComplex(Context.typeof(macro @:pos(pos.sanitize()) null)); 20 | 21 | static public inline function sanitize(pos:Position) 22 | return 23 | if (pos == null) 24 | Context.currentPos(); 25 | else 26 | pos; 27 | 28 | static public function errorExpr(pos:Position, error:Dynamic) 29 | return Bouncer.bounce(function ():Expr { 30 | return Positions.error(pos, error); 31 | }, pos); 32 | 33 | 34 | static public function error(pos:Position, error:Dynamic):Dynamic 35 | return 36 | switch Std.instance(error, tink.core.Error) { 37 | case null: errorFunc(sanitize(pos), Std.string(error)); 38 | case error: 39 | errorFunc( 40 | error.pos, 41 | error.message + 42 | if (pos == null) '' 43 | else ' (referenced from ' + Std.string(pos).substr(5) 44 | ); 45 | } 46 | 47 | static function contextError(pos:Position, error:String):Dynamic 48 | return Context.fatalError(error, pos); 49 | 50 | static function abortTypeBuild(pos:Position, error:String):Dynamic 51 | return throw new AbortBuild(error, pos); 52 | 53 | static var errorFunc = contextError; 54 | 55 | static public inline function warning(pos:Position, warning:Dynamic, ?ret:A):A { 56 | Context.warning(Std.string(warning), pos); 57 | return ret; 58 | } 59 | 60 | static public function makeFailure(pos:Position, reason:String):Outcome 61 | return Failure(new Error(reason, pos)); 62 | } 63 | 64 | class AbortBuild extends tink.core.Error { 65 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_macro/0,15,4/src/tink/macro/TypeMap.hx: -------------------------------------------------------------------------------- 1 | package tink.macro; 2 | 3 | import haxe.Constraints.IMap; 4 | import haxe.ds.BalancedTree; 5 | import haxe.macro.Context; 6 | import haxe.macro.Type; 7 | 8 | using haxe.macro.Tools; 9 | using tink.MacroApi; 10 | 11 | class TypeMap extends BalancedTree implements IMap { 12 | var follow:Bool; 13 | 14 | public function new(?noFollow:Bool) { 15 | this.follow = noFollow != true; 16 | super(); 17 | } 18 | 19 | override function compare(k1:Type, k2:Type):Int { 20 | 21 | if (follow) { 22 | k1 = k1.reduce(); 23 | k2 = k2.reduce(); 24 | } 25 | 26 | return switch k1.getIndex() - k2.getIndex() { 27 | case 0: 28 | Reflect.compare(k1.toString(), k2.toString());//much to my surprise, this actually seems to work (at least with 3.4) 29 | case v: v; 30 | } 31 | } 32 | 33 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_priority/.current: -------------------------------------------------------------------------------- 1 | 0.1.3 -------------------------------------------------------------------------------- /Client/.haxelib/tink_priority/0,1,3/haxelib.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "tink_priority", 3 | "license": "MIT", 4 | "tags": [ 5 | "tink", 6 | "cross", 7 | "utility", 8 | "priority", 9 | "queue", 10 | "plugin" 11 | ], 12 | "classPath": "src", 13 | "description": "Tinkerbell Priotization", 14 | "contributors": [ 15 | "back2dos" 16 | ], 17 | "releasenote": "Give tink.priority.Queue::between more intuitive behavior.", 18 | "version": "0.1.3", 19 | "url": "http://haxetink.org/tink_priority" 20 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_priority/0,1,3/src/tink/priority/ID.hx: -------------------------------------------------------------------------------- 1 | package tink.priority; 2 | 3 | import haxe.PosInfos; 4 | 5 | using StringTools; 6 | 7 | abstract ID({ cls:String, ?method:String, str:String }) { 8 | 9 | public var cls(get, never):String; 10 | public var method(get, never):Null; 11 | 12 | public function new(cls:String, ?method:String) 13 | this = { 14 | cls: cls, 15 | method: method, 16 | str: 17 | if (method == null) cls 18 | else '$cls::$method' 19 | 20 | }; 21 | 22 | inline function get_cls() 23 | return this.cls; 24 | 25 | inline function get_method() 26 | return this.method; 27 | 28 | @:to public inline function toString():String 29 | return this.str; 30 | 31 | @:from static function ofString(s:String) { 32 | var parts = s.split('::'); 33 | return new ID(parts[0], parts[1]); 34 | } 35 | 36 | @:from static function ofPosInfos(pos:PosInfos) 37 | return new ID(pos.className, pos.methodName); 38 | 39 | @:op(A == B) static function equals(a:ID, b:ID) 40 | return 41 | switch [a, b] { 42 | case [null, null]: true; 43 | case [null, _] | [_, null]: false; 44 | default: a.toString() == b.toString(); 45 | } 46 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_priority/0,1,3/src/tink/priority/Item.hx: -------------------------------------------------------------------------------- 1 | package tink.priority; 2 | 3 | typedef Item = { 4 | var data(default, null) : T; 5 | @:optional var id(default, null): ID; 6 | @:optional var before(default, null): Selector; 7 | @:optional var after(default, null): Selector; 8 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_priority/0,1,3/src/tink/priority/Queue.hx: -------------------------------------------------------------------------------- 1 | package tink.priority; 2 | 3 | import haxe.PosInfos; 4 | 5 | using StringTools; 6 | 7 | abstract Queue({ items: Array>, ?sequence:Array }) { 8 | public function new() 9 | this = { items: [], sequence: [] }; 10 | 11 | inline function invalidate() 12 | this.sequence = null; 13 | 14 | public function add(item:Item, ?pos:PosInfos) { 15 | if (item.id == null) 16 | @:privateAccess item.id = pos; 17 | 18 | for (i in 0...this.items.length) 19 | if (this.items[i].id == item.id) { 20 | var old = this.items[i]; 21 | this.items[i] = item; 22 | 23 | if (this.sequence == null) return; 24 | 25 | if (old.after == item.after && old.before == item.before) return; 26 | 27 | switch item.after { 28 | case null: 29 | case after: 30 | for (i in 0...i) 31 | if (after.matches(this.items[i])) { 32 | invalidate(); 33 | return; 34 | } 35 | } 36 | 37 | switch item.before { 38 | case null: 39 | case before: 40 | for (i in i+1...this.items.length) 41 | if (before.matches(this.items[i])) { 42 | invalidate(); 43 | return; 44 | } 45 | } 46 | 47 | return; 48 | } 49 | 50 | invalidate(); 51 | this.items.push(item); 52 | } 53 | 54 | public function whenever(data:T, ?id:ID, ?pos:PosInfos) 55 | add({ data: data, id: id }, pos); 56 | 57 | public function before(s:Selector, data:T, ?id:ID, ?pos:PosInfos) 58 | add({ data: data, id: id, before: s }, pos); 59 | 60 | public function after(s:Selector, data:T, ?id:ID, ?pos:PosInfos) 61 | add({ data: data, id: id, after: s }, pos); 62 | 63 | public function between(first:Selector, then:Selector, data:T, ?id:ID, ?pos:PosInfos) 64 | add({ data: data, id: id, after: first, before: then }, pos); 65 | 66 | public function iterator():Iterator 67 | return toArray().iterator(); 68 | 69 | public function getData(?optimistic = true) { 70 | if (!optimistic) 71 | throw 'sorry, this is not yet implemented'; 72 | 73 | if (this.sequence == null) { 74 | for (i in 0...this.items.length) { 75 | var best = this.items[i]; 76 | var last = null; 77 | 78 | var after = [], //unneeded maybe? 79 | maybe = [], 80 | rest = this.items.slice(i + 1); 81 | 82 | while (last != best) { 83 | last = best; 84 | for (cur in rest) { 85 | if (best.before.matches(cur) || cur.after.matches(best)) { 86 | after.push(cur); 87 | } 88 | else if (best.after.matches(cur) || cur.before.matches(best)) { 89 | after.push(best); 90 | best = cur; 91 | } 92 | else maybe.push(cur); 93 | } 94 | rest = maybe; 95 | maybe = []; 96 | } 97 | 98 | var index = this.items.indexOf(best); 99 | this.items[index] = this.items[i]; 100 | this.items[i] = best; 101 | 102 | } 103 | 104 | this.sequence = [for (item in this.items) item.data]; 105 | } 106 | return this.sequence; 107 | } 108 | 109 | @:to inline function toArray():Array 110 | return getData(); 111 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_priority/0,1,3/src/tink/priority/Selector.hx: -------------------------------------------------------------------------------- 1 | package tink.priority; 2 | 3 | using StringTools; 4 | 5 | abstract Selector(Null->Bool>) from Item->Bool { 6 | 7 | public function matches(item:Item) 8 | return this != null && this(item); 9 | 10 | @:from static function ofString(s:String):Selector 11 | return function (i:Item) 12 | return i.id.toString().startsWith(s); 13 | 14 | @:from static function ofID(id:ID):Selector 15 | return function (i:Item) 16 | return i.id == id; 17 | 18 | @:from static function ofRegex(e:EReg):Selector 19 | return function (i:Item) 20 | return e.match(i.id); 21 | 22 | @:op(a && b) static function and(a:Selector, b:Selector):Selector 23 | return function (x) 24 | return a.matches(x) && b.matches(x); 25 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_syntaxhub/.current: -------------------------------------------------------------------------------- 1 | 0.3.6 -------------------------------------------------------------------------------- /Client/.haxelib/tink_syntaxhub/0,3,6/extraParams.hxml: -------------------------------------------------------------------------------- 1 | --macro tink.SyntaxHub.use() -------------------------------------------------------------------------------- /Client/.haxelib/tink_syntaxhub/0,3,6/haxelib.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "tink_syntaxhub", 3 | "license": "MIT", 4 | "tags": [ 5 | "tink", 6 | "cross", 7 | "utility", 8 | "macro", 9 | "syntax", 10 | "sugar" 11 | ], 12 | "classPath": "src", 13 | "description": "Hub for plugging in language extensions.", 14 | "contributors": [ 15 | "back2dos" 16 | ], 17 | "releasenote": "Fix main class detection for -x.", 18 | "version": "0.3.6", 19 | "url": "http://haxetink.org/tink_syntaxhub", 20 | "dependencies": { 21 | "tink_priority": "", 22 | "tink_macro": "" 23 | } 24 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_syntaxhub/0,3,6/src/tink/SyntaxHub.hx: -------------------------------------------------------------------------------- 1 | package tink; 2 | 3 | import haxe.macro.*; 4 | import haxe.macro.Expr; 5 | import haxe.ds.Option; 6 | 7 | import tink.macro.ClassBuilder; 8 | 9 | import tink.priority.Queue; 10 | import tink.syntaxhub.*; 11 | 12 | using tink.CoreApi; 13 | using haxe.macro.Tools; 14 | 15 | class SyntaxHub { 16 | 17 | static var MAIN:Null = null; 18 | static function use() { 19 | var args = Sys.args(); 20 | 21 | MAIN = 22 | switch [args.indexOf('-main'), args.indexOf('-x')] { 23 | case [-1, -1]: null; 24 | case [v, -1] | [_, v]: args[v+1]; 25 | } 26 | 27 | FrontendContext.resetCache(); 28 | Context.onTypeNotFound(FrontendContext.findType); 29 | Compiler.addGlobalMetadata('', '@:build(tink.SyntaxHub.build())', true, true, false); 30 | } 31 | 32 | static function build():Array 33 | return 34 | switch Context.getLocalType() { 35 | case null: null; 36 | case TInst(_.get() => c, _): 37 | 38 | var builder = new ClassBuilder(); 39 | 40 | var changed = false; 41 | 42 | for (plugin in classLevel.getData()) 43 | changed = plugin(builder) || changed; 44 | 45 | changed = applyMainTransform(builder) || changed; 46 | 47 | if (changed) 48 | builder.export(builder.target.meta.has(':explain')); 49 | else 50 | null; 51 | default: null; 52 | } 53 | 54 | static public var classLevel(default, null) = new QueueBool>(); 55 | static public var exprLevel(default, null) = new ExprLevelSyntax('tink.SyntaxHub::exprLevel'); 56 | static public var transformMain(default, null) = new QueueExpr>(); 57 | 58 | static public var frontends(get, never):Queue; 59 | 60 | static inline function get_frontends() 61 | return FrontendContext.plugins; 62 | 63 | static public function makeSyntax(rule:ClassBuilder->OptionExpr>):ClassBuilder->Bool 64 | return function (ctx:ClassBuilder) 65 | return switch rule(ctx) { 66 | case Some(rule): 67 | 68 | function transform(f:Function) 69 | if (f.expr != null) 70 | f.expr = rule(f.expr); 71 | 72 | if (ctx.hasConstructor()) 73 | ctx.getConstructor().onGenerate(transform); 74 | 75 | for (m in ctx) 76 | switch m.kind { 77 | case FFun(f): transform(f); 78 | case FProp(_, _, _, e), FVar(_, e): 79 | if (e != null) 80 | e.expr = rule(e).expr;//TODO: it might be better to just create a new kind, rather than modifying the expression in place 81 | } 82 | 83 | true; 84 | case None: 85 | false; 86 | } 87 | 88 | static function applyMainTransform(c:ClassBuilder) 89 | return 90 | if (c.target.pack.concat([c.target.name]).join('.') == MAIN) { 91 | var main = c.memberByName('main').sure(); 92 | var f = main.getFunction().sure(); 93 | 94 | if (f.expr == null) 95 | f.expr = macro @:pos(main.pos) { }; 96 | 97 | for (rule in transformMain) 98 | f.expr = rule(f.expr); 99 | 100 | true; 101 | } 102 | else false; 103 | 104 | static var INITIALIZED = { 105 | classLevel.whenever(makeSyntax(exprLevel.appliedTo), exprLevel.id); 106 | true; 107 | } 108 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_syntaxhub/0,3,6/src/tink/syntaxhub/ExprLevelSyntax.hx: -------------------------------------------------------------------------------- 1 | package tink.syntaxhub; 2 | 3 | import haxe.ds.Option; 4 | import haxe.macro.Expr; 5 | import tink.macro.ClassBuilder; 6 | import tink.priority.ID; 7 | 8 | import tink.priority.Queue; 9 | 10 | using tink.MacroApi; 11 | 12 | class ExprLevelSyntax { 13 | public var inward(default, null):Queue; 14 | public var outward(default, null):Queue; 15 | public var id(default, null):ID; 16 | 17 | public function new(id) { 18 | this.inward = new Queue(); 19 | this.outward = new Queue(); 20 | this.id = id; 21 | } 22 | 23 | public function appliedTo(c:ClassBuilder):OptionExpr> { 24 | function getRelevant(q:Queue) 25 | return [for (p in q.getData()) if (p.appliesTo(c)) p]; 26 | 27 | var inward = getRelevant(inward), 28 | outward = getRelevant(outward); 29 | 30 | if (inward.length + outward.length == 0) 31 | return None; 32 | 33 | function apply(e:Expr) 34 | return 35 | if (e == null || e.expr == null) e; 36 | else 37 | switch e.expr { 38 | case EMeta( { name: ':diet' }, _): e; 39 | default: 40 | for (rule in inward) 41 | e = rule.apply(e); 42 | 43 | e = e.map(apply); 44 | 45 | for (rule in outward) 46 | e = rule.apply(e); 47 | 48 | e; 49 | } 50 | 51 | return Some(apply); 52 | } 53 | } 54 | 55 | typedef ExprLevelRule = { 56 | function appliesTo(c:ClassBuilder):Bool; 57 | function apply(e:Expr):Expr; 58 | } -------------------------------------------------------------------------------- /Client/.haxelib/tink_syntaxhub/0,3,6/src/tink/syntaxhub/FrontendPlugin.hx: -------------------------------------------------------------------------------- 1 | package tink.syntaxhub; 2 | 3 | interface FrontendPlugin { 4 | function extensions():Iterator; 5 | function parse(file:String, context:FrontendContext):Void; 6 | } -------------------------------------------------------------------------------- /Client/Client.hxproj: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 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 | 58 | 59 | 60 | -------------------------------------------------------------------------------- /Client/assets/css/buttons.css: -------------------------------------------------------------------------------- 1 | .button { 2 | border-radius: 3px; 3 | background: #484848; 4 | border-color: #303030; 5 | color: #cccccc; 6 | } 7 | 8 | .button:hover { 9 | background: #555555; 10 | color: #cfcfcf; 11 | } 12 | 13 | .button:down { 14 | background: #484848; 15 | color: #cccccc; 16 | } 17 | 18 | .dropdown { 19 | border-top-left-radius: 3px; 20 | border-top-right-radius: 3px; 21 | border-bottom-left-radius: 3px; 22 | border-bottom-right-radius: 3px; 23 | } 24 | 25 | 26 | .dropdown:down { 27 | border-top-left-radius: 3px; 28 | border-top-right-radius: 3px; 29 | border-bottom-left-radius: 0px; 30 | border-bottom-right-radius: 0px; 31 | } 32 | 33 | .dropdown-popup .listview { 34 | border: 1px solid #303030; 35 | border-radius: 0px; 36 | } 37 | -------------------------------------------------------------------------------- /Client/assets/css/dialogs.css: -------------------------------------------------------------------------------- 1 | .modal-background { 2 | background-color: black; 3 | opacity: 0.5; 4 | backdrop-filter: blur(5); 5 | } 6 | 7 | .dialog { 8 | filter: drop-shadow(1, 45, #000000, 0.2, 30, 2, 1, 3, false); 9 | height: auto; 10 | initial-width: 300px; 11 | padding: 1px; 12 | 13 | background-color: #3a3a3a; 14 | border: 1px solid #484848; 15 | border-radius: 3px; 16 | } 17 | 18 | .dialog-title { 19 | background-color: #484848; 20 | padding: 5px; 21 | border-bottom-width: 1px; 22 | border-bottom-color: #484848; 23 | } 24 | 25 | .dialog-footer-container { 26 | border-top-width: 1px; 27 | border-top-color: #484848; 28 | background-color: #484848; 29 | } 30 | 31 | .scrollview { 32 | border: 1px solid #484848; 33 | border-radius: 1px; 34 | padding: 1px; 35 | width: auto; 36 | height: auto; 37 | background: #303030; 38 | } 39 | 40 | 41 | .dialog #iconImage.info { 42 | resource: "icons/dialogs/info.png"; 43 | } 44 | -------------------------------------------------------------------------------- /Client/assets/css/listviews.css: -------------------------------------------------------------------------------- 1 | .listview { 2 | border: 1px solid #484848; 3 | border-radius: 1px; 4 | padding: 1px; 5 | width: auto; 6 | height: auto; 7 | background: #303030; 8 | } 9 | 10 | .listview .listview-contents { 11 | spacing: 0; 12 | width: 100%; 13 | padding: 0px; 14 | } 15 | 16 | .listview .itemrenderer { 17 | cursor: pointer; 18 | } 19 | 20 | .listview .itemrenderer .label { 21 | } 22 | 23 | .listview .even { 24 | background-color: #303030; 25 | } 26 | 27 | .listview .even:hover { 28 | background-color: #484848; 29 | } 30 | 31 | .listview .odd { 32 | background-color: #353535; 33 | } 34 | 35 | .listview .odd:hover { 36 | background-color: #484848; 37 | } 38 | 39 | .listview .itemrenderer { 40 | height: auto; 41 | padding: 5px; 42 | } 43 | 44 | .listview .itemrenderer:selected { 45 | background-color: #525252; 46 | color: #cccccc; 47 | } 48 | 49 | .listview .itemrenderer:selected .label { 50 | color: #cccccc; 51 | } 52 | -------------------------------------------------------------------------------- /Client/assets/css/main.css: -------------------------------------------------------------------------------- 1 | .label, .button, .textfield, .textarea { 2 | font-name: "fonts/Roboto-Regular.ttf"; 3 | color: #cccccc; 4 | } 5 | 6 | 7 | #log .scrollview-contents .hbox .label { 8 | color: #899fc2; 9 | } 10 | 11 | #log .scrollview-contents .hbox .label.error { 12 | color: #CC2222; 13 | } 14 | 15 | #log .scrollview-contents .hbox .label.resource-link { 16 | color: #899fc2; 17 | font-underline: true; 18 | pointer-events: true; 19 | } 20 | 21 | #log .scrollview-contents .hbox .label.error-resource-link { 22 | color: #CC2222; 23 | font-underline: true; 24 | pointer-events: true; 25 | } 26 | 27 | .code-editor { 28 | border: 1px solid #484848; 29 | background-color: #1e1e1e; 30 | } 31 | -------------------------------------------------------------------------------- /Client/assets/css/menus.css: -------------------------------------------------------------------------------- 1 | .menubar { 2 | border-bottom-width: 1px; 3 | } 4 | 5 | .menubar { 6 | background-color: #3a3a3a; 7 | border-bottom-color: #484848; 8 | } 9 | 10 | .menubar-button { 11 | background-color: #3a3a3a; 12 | border: none; 13 | color: #cccccc; 14 | vertical-align: center; 15 | } 16 | 17 | .menubar-button:hover { 18 | background-color: #3a3a3a; 19 | color: #cccccc; 20 | } 21 | 22 | .menubar-button:down { 23 | background-color: #3a3a3a; 24 | color: #cccccc; 25 | } 26 | 27 | .menu { 28 | border-bottom-color: #484848; 29 | padding: 1px; 30 | border: 1px solid #555555; 31 | width: 200px; 32 | 33 | background: #555555; 34 | border-top-right-radius: 3px; 35 | border-bottom-left-radius: 3px; 36 | border-bottom-right-radius: 3px; 37 | } 38 | 39 | .menu-separator { 40 | background-color: #484848; 41 | } 42 | 43 | .menu-item { 44 | color: #cccccc; 45 | background: #555555; 46 | border-radius: 3px; 47 | padding: 8px; 48 | } 49 | 50 | .menu-item:hover { 51 | background: #353535; 52 | color: #bbbbbb; 53 | } 54 | 55 | .menu-item .label, .menu-item .label { 56 | color: #cccccc; 57 | } 58 | 59 | 60 | .menubar-button { 61 | color: #cccccc; 62 | } 63 | 64 | .menubar-button:hover { 65 | background: #555555; 66 | color: #cfcfcf; 67 | } 68 | 69 | 70 | .menubar-button:down { 71 | background: #555555; 72 | color: #cfcfcf; 73 | } 74 | -------------------------------------------------------------------------------- /Client/assets/css/progressbars.css: -------------------------------------------------------------------------------- 1 | .horizontal-progress { 2 | background: #303030; 3 | border-color: #484848; 4 | color: #cccccc; 5 | filter: none; 6 | } 7 | 8 | .horizontal-progress .progress-value { 9 | background: #6697E6 #6697E6 vertical; 10 | border-radius: none; 11 | } -------------------------------------------------------------------------------- /Client/assets/css/scrolls.css: -------------------------------------------------------------------------------- 1 | .vertical-scroll { 2 | width: 7px; 3 | background-color: #303030; 4 | border-left-width: 1px; 5 | border-left-color: #484848; 6 | padding: 1px; 7 | padding-left: 2px; 8 | } 9 | 10 | .vertical-scroll .thumb { 11 | width: 4px; 12 | background-color: #484848; 13 | border: none; 14 | } 15 | 16 | .vertical-scroll .inc, .vertical-scroll .deinc{ 17 | hidden: true; 18 | } 19 | 20 | .horizontal-scroll { 21 | height: 7px; 22 | background-color: #303030; 23 | border-left-width: 1px; 24 | border-left-color: #484848; 25 | padding: 1px; 26 | padding-top: 2px; 27 | } 28 | 29 | .horizontal-scroll .thumb { 30 | height: 4px; 31 | background-color: #484848; 32 | border: none; 33 | } 34 | 35 | .horizontal-scroll .inc, .horizontal-scroll .deinc{ 36 | hidden: true; 37 | } 38 | 39 | .horizontal-splitter-gripper:hover, .vertical-splitter-gripper:hover { 40 | background-color: #1e1e1e; 41 | } 42 | -------------------------------------------------------------------------------- /Client/assets/css/tabs.css: -------------------------------------------------------------------------------- 1 | .tabbar { 2 | padding-left: 0; 3 | border-bottom-width: 1px; 4 | border-bottom-color: #484848; 5 | } 6 | 7 | .tabbar .tabbar-contents { 8 | border-bottom-width: 1px; 9 | border-bottom-color: #484848; 10 | } 11 | 12 | .tabbar-button { 13 | border-radius: 0px; 14 | background: #303030; 15 | padding: 6px; 16 | vertical-align: bottom; 17 | border-color: #484848; 18 | color: #a0a0a0; 19 | border-top-left-radius: 3px; 20 | border-top-right-radius: 3px; 21 | } 22 | 23 | .tabbar-button:hover { 24 | background: #353535; 25 | color: #bbbbbb; 26 | } 27 | 28 | .tabbar-button-selected { 29 | border-radius: 0px; 30 | 31 | border-bottom-width: 1px; 32 | border-bottom-color: #3a3a3a; 33 | background-color: #3a3a3a; 34 | color: #cccccc; 35 | 36 | border-top-color: #6697E6; 37 | border-top-width: 2px; 38 | } 39 | 40 | .tabview-content { 41 | background-color: #3a3a3a; 42 | border: 1px solid #484848; 43 | 44 | border-top-left-radius: 0px; 45 | border-top-right-radius: 0px; 46 | border-bottom-left-radius: 3px; 47 | border-bottom-right-radius: 3px; 48 | } 49 | 50 | .tabbar-button .tab-close-button { 51 | resource: "icons/close.png"; 52 | } 53 | -------------------------------------------------------------------------------- /Client/assets/css/textinputs.css: -------------------------------------------------------------------------------- 1 | .textfield { 2 | background: #303030; 3 | border-color: #484848; 4 | color: #cccccc; 5 | filter: none; 6 | } 7 | 8 | .textfield:active { 9 | } 10 | 11 | .textfield:empty { 12 | color: #525252; 13 | } 14 | 15 | .stepper-textfield { 16 | border: none; 17 | width: 100%; 18 | padding: 4px; 19 | padding-top: 5px; 20 | padding-bottom: 3px; 21 | vertical-align: center; 22 | filter: none; 23 | } 24 | -------------------------------------------------------------------------------- /Client/assets/css/trees.css: -------------------------------------------------------------------------------- 1 | .treeview { 2 | border: 1px solid #484848; 3 | border-radius: 3px; 4 | padding: 1px; 5 | width: auto; 6 | height: auto; 7 | background: #303030; 8 | } 9 | 10 | #node { 11 | padding: 3px; 12 | padding-right: 4px; 13 | border-radius: 2px; 14 | } 15 | 16 | #node:hover { 17 | background: #484848; 18 | } 19 | 20 | #node:selected { 21 | background: #555555; 22 | } 23 | 24 | #node .label { 25 | color: #cccccc; 26 | } 27 | 28 | #node:selected .label { 29 | color: #cfcfcf; 30 | } 31 | -------------------------------------------------------------------------------- /Client/assets/fonts/Roboto-Black.ttf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/fonts/Roboto-Black.ttf -------------------------------------------------------------------------------- /Client/assets/icons/audio-file.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/icons/audio-file.png -------------------------------------------------------------------------------- /Client/assets/icons/blank.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/icons/blank.png -------------------------------------------------------------------------------- /Client/assets/icons/close.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/icons/close.png -------------------------------------------------------------------------------- /Client/assets/icons/control-000-small.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/icons/control-000-small.png -------------------------------------------------------------------------------- /Client/assets/icons/control-270-small.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/icons/control-270-small.png -------------------------------------------------------------------------------- /Client/assets/icons/dialogs/info.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/icons/dialogs/info.png -------------------------------------------------------------------------------- /Client/assets/icons/document.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/icons/document.png -------------------------------------------------------------------------------- /Client/assets/icons/download.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/icons/download.png -------------------------------------------------------------------------------- /Client/assets/icons/example.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/icons/example.png -------------------------------------------------------------------------------- /Client/assets/icons/file.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/icons/file.png -------------------------------------------------------------------------------- /Client/assets/icons/folder.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/icons/folder.png -------------------------------------------------------------------------------- /Client/assets/icons/help.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/icons/help.png -------------------------------------------------------------------------------- /Client/assets/icons/map.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/icons/map.png -------------------------------------------------------------------------------- /Client/assets/icons/picture.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/icons/picture.png -------------------------------------------------------------------------------- /Client/assets/icons/plus.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/icons/plus.png -------------------------------------------------------------------------------- /Client/assets/icons/puzzle.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/icons/puzzle.png -------------------------------------------------------------------------------- /Client/assets/icons/refresh.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/icons/refresh.png -------------------------------------------------------------------------------- /Client/assets/icons/save-all.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/icons/save-all.png -------------------------------------------------------------------------------- /Client/assets/icons/save.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/icons/save.png -------------------------------------------------------------------------------- /Client/assets/icons/settings.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/icons/settings.png -------------------------------------------------------------------------------- /Client/assets/icons/sound.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/icons/sound.png -------------------------------------------------------------------------------- /Client/assets/icons/upload.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/icons/upload.png -------------------------------------------------------------------------------- /Client/assets/img/parrot.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/img/parrot.png -------------------------------------------------------------------------------- /Client/assets/img/parrot_small.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/Kode/KodeGarden/8a6b88424e3943b241f55c7d68aafebe13420faf/Client/assets/img/parrot_small.png -------------------------------------------------------------------------------- /Client/assets/templates/shaders/Basic.frag.glsl.template: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | out vec4 FragColor; 4 | 5 | void main() { 6 | FragColor = vec4(1.0, 0.0, 0.0, 1.0); 7 | } 8 | -------------------------------------------------------------------------------- /Client/assets/templates/shaders/Basic.vert.glsl.template: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | in vec3 pos; 4 | 5 | void main() { 6 | gl_Position = vec4(pos.x, pos.y, 0.5, 1.0); 7 | } 8 | -------------------------------------------------------------------------------- /Client/assets/templates/shaders/Empty.frag.glsl.template: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | void main() { 4 | } 5 | -------------------------------------------------------------------------------- /Client/assets/templates/shaders/Empty.vert.glsl.template: -------------------------------------------------------------------------------- 1 | #version 450 2 | 3 | void main() { 4 | } 5 | -------------------------------------------------------------------------------- /Client/assets/templates/sources/Abstract.template: -------------------------------------------------------------------------------- 1 | package $package; 2 | 3 | abstract $name() { 4 | 5 | } -------------------------------------------------------------------------------- /Client/assets/templates/sources/Class.template: -------------------------------------------------------------------------------- 1 | package $package; 2 | 3 | class $name { 4 | public function new() { 5 | } 6 | } -------------------------------------------------------------------------------- /Client/assets/templates/sources/Enum.template: -------------------------------------------------------------------------------- 1 | package $package; 2 | 3 | enum $name { 4 | 5 | } -------------------------------------------------------------------------------- /Client/assets/templates/sources/Interface.template: -------------------------------------------------------------------------------- 1 | package $package; 2 | 3 | interface $name { 4 | } -------------------------------------------------------------------------------- /Client/assets/templates/sources/TypeDef.template: -------------------------------------------------------------------------------- 1 | package $package; 2 | 3 | typedef $name = { 4 | } -------------------------------------------------------------------------------- /Client/assets/ui/dialogs/about.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | -------------------------------------------------------------------------------- /Client/assets/ui/dialogs/add-resource.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 8 | 9 | 10 | 11 | 60 | -------------------------------------------------------------------------------- /Client/assets/ui/dialogs/example-item.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 5 | -------------------------------------------------------------------------------- /Client/assets/ui/dialogs/examples.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /Client/assets/ui/dialogs/import-progress.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 7 | -------------------------------------------------------------------------------- /Client/assets/ui/dialogs/import.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 19 | -------------------------------------------------------------------------------- /Client/assets/ui/editors/image-editor.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | -------------------------------------------------------------------------------- /Client/assets/ui/editors/shader-editor.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | -------------------------------------------------------------------------------- /Client/assets/ui/editors/source-editor.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | -------------------------------------------------------------------------------- /Client/assets/ui/main.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 24 | 25 | 26 | 27 | 28 | 29 |