studyup 0.0.0-stage → 1.0.1

package/hexgl-package/HexGL-master/libs/Editor_files/Diagram.js

@@ -0,0 +1,148 @@
+var pgli = pgli || {};
+pgli.diagram = pgli.diagram || {};
+
+pgli.diagram.Diagram = gamecore.Base.extend('Diagram',
+{ // static
+
+},
+{ // instance
+
+	dom: null,
+	container: null,
+	width: 1024,
+	height: 768,
+
+	timer: null,
+	redrawDelay: 1000/30,
+
+	stage: null,
+	layers: {
+		background: null,
+		nodes: null,
+		links: null
+	},
+	background: null,
+	links: null,
+
+	project: null,
+
+	nodes: [],
+
+	/**
+	 * Bind a new renderer to given canvas
+	 * @param  HTMLElement domContainer [description]
+	 * @param  Integer width      [description]
+	 * @param  Integer height     [description]
+	 * @param  Integer autoRedraw If defined, sets redraw rate to given FPS
+	 */
+	init: function(domContainer, autoRedraw)
+	{
+		var self = this;
+
+		this.dom = domContainer;
+		this.container = $('#'+domContainer);
+		this.width = this.container.width();
+		this.height = this.container.height();
+
+		this.stage = new Kinetic.Stage({
+			container: this.dom,
+			width: this.width,
+			height: this.height
+		});
+
+		this.layers.background = new Kinetic.Layer();
+		this.layers.nodes = new Kinetic.Layer();
+		this.layers.links = new Kinetic.Layer();
+
+		this.background = new Kinetic.Rect({
+			width: this.width,
+			height: this.height,
+			fill: "#272822"
+		});
+
+		this.layers.background.add(this.background);
+
+		this.links = new pgli.diagram.Links(this);
+		this.layers.links.add(this.links.shape);
+
+		this.stage.add(this.layers.background);
+		this.stage.add(this.layers.nodes);
+		this.stage.add(this.layers.links);
+
+		// Stage drag hack to trigger only on background drag
+		var self = this;
+		this.background.on("mousedown", function(){
+			self.stage.setDraggable(true);
+			self.stage.on("dragmove", function(){
+				self.layers.background.setX(-this.getX());
+				self.layers.background.setY(-this.getY());
+			});
+			self.stage.on("dragend", function(){
+				this.off("dragend");
+				this.off("dragmove");
+				this.setDraggable(false);
+			});
+		});
+
+		if(autoRedraw != undefined && autoRedraw != false && autoRedraw > 0)
+		{
+			this.redrawDelay = 1000 / autoRedraw;
+			this.timer = new bkcore.Timer();
+			this.timer.start();
+			this.autoRedraw(true);
+		}
+	},
+
+	addNode: function(node)
+	{
+		this.nodes.push(node);
+		this.layers.nodes.add(node.shape);
+		this.layers.nodes.draw();
+	},
+
+	getNode: function(nodeKey)
+	{
+		var i = 0, len = this.nodes.length;
+		while(i < len)
+		{
+			if(this.nodes[i].key == nodeKey)
+				return this.nodes[i];
+			i++;
+		}
+		console.warn("Error in Diagram: Unable to find node["+nodeKey+"]");
+		return false;
+	},
+
+	draw: function()
+	{
+		this.layers.background.draw();
+		this.layers.nodes.draw();
+		this.layers.links.draw();
+	},
+
+	autoRedraw: function(keep)
+	{
+		var self = this;
+
+		if(this.timer.update() > this.redrawDelay)
+		{
+			this.timer.start();
+			this.draw();
+		}
+
+		if(keep)
+			requestAnimFrame(function(){
+				self.autoRedraw(true);
+			});
+	},
+
+	resize: function()
+	{
+		this.width = this.container.width();
+		this.height = this.container.height();
+		this.stage.setSize(this.width, this.height);
+		this.background.setSize(this.width, this.height);
+		this.draw();
+	}
+
+});

package/hexgl-package/HexGL-master/libs/Editor_files/Iterator.js

@@ -0,0 +1,92 @@
+var pgli = pgli || {};
+pgli.lang = pgli.lang || {};
+
+pgli.lang.Iterator = gamecore.Base.extend('Iterator',
+// Static
+{
+	MAX_ITERATIONS: 1000,
+
+	COMPARATORS: {
+		"<": 0,
+		">": 1,
+		"<=": 2,
+		">=": 3
+	},
+
+	genComparatorMethod: function(type)
+	{
+		switch(type)
+		{
+		case 0:
+			return function(a, b){ return a < b };
+		case 1:
+			return function(a, b){ return a > b };
+		case 2:
+			return function(a, b){ return a <= b };
+		case 3:
+			return function(a, b){ return a >= b };
+		default:
+			return function(a, b){ return false };
+		}
+	},
+
+	genStepMethod: function(type, scope, attr)
+	{
+		switch(type)
+		{
+		case 1:
+		case 3:
+			return function(){ return --scope[attr] };
+		case 0:
+		case 2:
+		default:
+			return function(){ return ++scope[attr] };
+		}
+	}
+},
+// Instance
+{
+	varname: "i",
+	start: 0,
+	end: 1,
+	comparator: 0,
+	compMethod: null,
+	stepMethod: null,
+	step: 0,
+	iter: 0,
+
+	init: function(name, start, comparator, end)
+	{
+		var static = pgli.lang.Iterator;
+
+		if(comparator in static.COMPARATORS)
+			this.comparator = static.COMPARATORS[comparator];
+		else
+			this.comparator = static.COMPARATORS["<"];
+
+		this.start = start;
+		this.end = end;
+		this.step = start;
+
+		this.varname = name;
+		this.compMethod = static.genComparatorMethod(this.comparator);
+		this.stepMethod = static.genStepMethod(this.comparator, this, "step");
+	},
+
+	loop: function()
+	{
+		return (this.iter < pgli.lang.Iterator.MAX_ITERATIONS && this.compMethod(this.step, this.end));
+	},
+
+	next: function()
+	{
+		++this.iter;
+		return this.stepMethod();
+	},
+
+	toString: function()
+	{
+		return "Iterator("+this.varname+") "+this.start+" - "+this.step+" - "+this.end;
+	}
+
+});

package/hexgl-package/HexGL-master/libs/Editor_files/Links.js

@@ -0,0 +1,56 @@
+var pgli = pgli || {};
+pgli.diagram = pgli.diagram || {};
+
+pgli.diagram.Links = gamecore.Base.extend('Links',
+{ // static
+	bezierOffset: 50
+},
+{ // instance
+	diagram: null,
+
+	shape: null,
+
+	init: function(diagram)
+	{
+		var static = pgli.diagram.Links;
+		var self = this;
+
+		this.diagram = diagram;
+
+		this.shape = new Kinetic.Shape({
+			drawFunc: function(ctx){
+				ctx.beginPath();
+				
+				for(var i = 0, len = self.diagram.nodes.length; i < len; i++)
+				{
+					var node = self.diagram.nodes[i];
+
+					if(! ("layers" in node.module)) continue;
+
+					for(var j = 0, _len = node.module.layers.length; j < _len; j++)
+					{
+						if(! ("use" in node.module.layers[j])) continue;
+
+						var start = node.getLayerSlot(j);
+						var tNode = self.diagram.getNode(node.module.layers[j].use);
+						if(!tNode) continue;
+						var end = tNode.getSlot();
+
+						ctx.moveTo(start[0], start[1]);
+						ctx.bezierCurveTo(
+							start[0]+static.bezierOffset, start[1],
+							end[0]-static.bezierOffset, end[1],
+							end[0], end[1]);
+					}
+				}
+
+				this.stroke(ctx);
+			},
+			x: 0,
+			y: 0,
+			stroke: "#999",
+			strokeWidth: 3,
+			lineCap: "round"
+		});
+	}
+});

package/hexgl-package/HexGL-master/libs/Editor_files/ModuleList.js

@@ -0,0 +1,47 @@
+var pgli = pgli || {};
+pgli.ui = pgli.ui || {};
+
+pgli.ui.ModuleList = gamecore.Base.extend('ModuleList',
+{ // static
+	tplModuleItem: "<li data-path='$path'>$name</li>",
+	tplModuleList: "<ul data-path='$path'>$list</ul>"
+},
+{ // instance
+
+	project: null,
+	container: null,
+
+	init: function(domContainer)
+	{
+		this.container = $('#'+domContainer);
+		this.container.on("click", "li", {object: this}, this.onModuleClick);
+	},
+
+	bindProject: function(project)
+	{
+		this.project = project;
+	},
+
+	draw: function()
+	{
+		var static = pgli.ui.ModuleList;
+		var modules = "";
+		var module = null;
+		if(!this.project.isEmpty()) for(var i = 0, len = this.project.getModulesCount(); i < len; ++i)
+		{
+			key = this.project.getModuleKey(i);
+			module = this.project.getModule(key);
+			modules += static.tplModuleItem.replace("$path", key).replace("$name", key);
+		}
+		this.container.html(static.tplModuleList.replace("$list", modules));
+	},
+
+	onModuleClick: function(event)
+	{
+		event.data.object.project.rememberActiveFile();
+		event.data.object.project.getAppInstance().showInEditor($(this).attr("data-path"));
+		event.data.object.container.find('li').removeClass('active');
+		$(this).addClass('active');
+	}
+
+});

package/hexgl-package/HexGL-master/libs/Editor_files/Node.js

@@ -0,0 +1,122 @@
+var pgli = pgli || {};
+pgli.diagram = pgli.diagram || {};
+
+pgli.diagram.Node = gamecore.Base.extend('Node',
+{ // static
+	layersWidth: 20,
+	layersMargin: 20,
+	layersHeight: 16,
+	headerHeight: 40,
+	slotX: 10,
+	slotY: 14,
+	slotRadius: 6
+},
+{ // instance
+	module: null,
+
+	key: null,
+
+	shape: null,
+	background: null,
+	name: null,
+	layers: null,
+	slot: null,
+	
+	sockets: [],
+	
+	width: 150,
+	height: 200,
+
+	init: function(key, module, x, y)
+	{
+		var static = pgli.diagram.Node;
+
+		this.key = key;
+		this.module = module;
+
+		this.shape = new Kinetic.Group({
+			x: x == undefined ? 0 : x,
+			y: y == undefined ? 0 : y,
+			draggable: true
+		});
+
+		var layerCount = (module.layers != undefined ? module.layers.length : 0) + 1;
+
+		this.height = static.headerHeight + layerCount * static.layersHeight;
+
+		this.background = new Kinetic.Rect({
+			x: 0,
+			y: 0,
+			width: this.width,
+			height: this.height,
+			fill: "#222",
+			stroke: "#000",
+			strokeWidth: 0.5,
+			shadow: {
+				color: "black",
+				blur: 6,
+				offset: [0, 0],
+				opacity: 0.5
+			}
+		});
+
+		this.layers = new Kinetic.Shape({
+			drawFunc: function(ctx){
+				ctx.beginPath();
+				for(var i=0, len = this.attrs.count; i < len; ++i)
+					ctx.arc(10, 10+i*static.layersHeight, static.slotRadius, 0, Math.PI*2, true); 
+				ctx.closePath();
+				this.fill(ctx);
+			},
+			x: this.width-static.layersWidth,
+			y: static.layersMargin,
+			count: layerCount,
+			fill: "#111"
+		});
+
+		this.slot = new Kinetic.Circle({
+			x: static.slotX,
+			y: static.slotY,
+			radius: static.slotRadius,
+			fill: "#111"
+		});
+
+		this.name = new Kinetic.Text({
+			x: 20,
+			y: 6,
+			text: module.name,
+			fontSize: 13,
+			fontFamily: "Ubuntu Mono",
+			textFill: "#aaa"
+		});
+
+		this.shape.on('mousedown', function(){
+			this.moveToTop();
+		});
+
+		this.shape.add(this.background);
+		this.shape.add(this.name);
+		this.shape.add(this.layers);
+		this.shape.add(this.slot);
+	},
+
+	updateLayers: function()
+	{
+		var layerCount = (module.layers != undefined ? module.layers.length : 0) + 1;
+		this.layers.attrs.count = layerCount;
+	},
+
+	getSlot: function()
+	{
+		var static = pgli.diagram.Node;
+		return [this.shape.getX()+static.slotX, 
+				this.shape.getY()+static.slotY];
+	},
+
+	getLayerSlot: function(index)
+	{
+		var static = pgli.diagram.Node;
+		return [this.shape.getX()+this.width-static.layersWidth/2, 
+				this.shape.getY()+10+index*static.layersHeight+static.layersMargin];
+	}
+});

package/hexgl-package/HexGL-master/libs/Editor_files/Parser.js

@@ -0,0 +1,140 @@
+var pgli = pgli || {};
+pgli.lang = pgli.lang || {};
+
+pgli.lang.Parser = gamecore.Base.extend('Parser',
+{
+
+	xStruct: {
+		"scale": 0,
+		"x": 1,
+		"y": 2,
+		"width": 3,
+		"height": 4
+	},
+
+
+	patternVar:/\@(\w+)/g,
+	patternMethod: /\#(\w+)(\(([^\)]+)\))/g,
+
+	debug: 1,
+
+
+	parseExpression: function(string, scope, xform)
+	{
+		static = pgli.lang.Parser;
+
+		var self = this;
+		var orig = string;
+		var s = (scope !== null && typeof(scope) !== "undefined")
+		var x = (xform !== null && typeof(xform) !== "undefined" && xform.length > 0)
+
+		if(typeof(string) != "string")
+			return string;
+
+		if(scope != undefined)
+		{
+			string = string.replace(this.patternVar,function(match,varName)
+			{
+				if(x && varName in static.xStruct)
+					return xform[static.xStruct[varName]];
+				else if(s && varName in scope)
+					return scope[varName]
+				else
+					return 0
+			});
+		}
+
+		string = string.replace(this.patternMethod,function(match,methodName,a,params)
+		{
+			if(self.debug < 2) console.log(arguments);
+			return self.execFunction(methodName, params);
+		});
+
+		if(self.debug < 2) console.log("#Parsed expr: '"+string+"' from '"+orig+"'");
+		
+		try {
+			return eval(string);
+		} catch (e) {
+			return string;
+		}
+		
+
+	},
+
+	parseRepeat: function(string, scope)
+	{
+		var items = string.split(" ");
+
+		if(items.length != 4)
+			throw "Syntax error in repeat expression";
+
+		if(self.debug < 2) console.warn(items[0].substr(1))
+		if(self.debug < 2) console.warn(Number(this.parseExpression(items[1], scope)))
+		if(self.debug < 2) console.warn(items[2])
+		if(self.debug < 2) console.warn(Number(this.parseExpression(items[3], scope)))
+
+		return new pgli.lang.Iterator(
+			items[0].substr(1),
+			Number(this.parseExpression(items[1], scope)),
+			items[2],
+			Number(this.parseExpression(items[3], scope))
+		);
+	},
+
+	parseModule: function(string)
+	{
+		try
+		{
+			return JSON.parse(string);
+		}
+		catch(e)
+		{
+			trace("(!) Syntax error in module.");
+			return {error:"unable to parse module"};
+		}
+	},
+
+	execFunction: function(methodName, params)
+	{
+		var hasP = params != undefined;
+		var p = hasP ? params.replace(" ", "").split(',') : [];
+
+		if(methodName == "random")
+		{
+			var r = Math.random();
+			if(hasP && p.length == 2) try
+			{
+				var min = eval(p[0]);
+				var max = eval(p[1]);
+				r = Math.round(r * (max-min) + min);
+			} catch(e) {
+				console.warn('Bad method format: '+methodName+' / '+params);
+				return 0;
+			}
+			return r;
+		}
+		else if(methodName == "mod")
+		{
+			if(hasP && p.length == 2) try
+			{
+				var base = eval(p[0]);
+				var div = eval(p[1]);
+				if(div == 0) throw "Divide by 0";
+				return Math.floor(base/div);
+			} catch(e) {
+				console.warn('Bad method format: '+methodName+' / '+params);
+			}
+			return 0;
+		}
+		else
+		{
+			console.warn("Unsupported method : "+methodName);
+			return 0;
+		}
+	}
+},
+{
+
+});
+
+