studyup 0.0.0-stage → 1.0.1

package/hexgl-package/HexGL-master/.htaccess

@@ -0,0 +1,4 @@
+AddType application/x-web-app-manifest+json .webapp
+ExpiresByType application/x-web-app-manifest+json "access"
+AddType text/cache-manifest .appcache
+ExpiresByType text/cache-manifest "access"

package/hexgl-package/HexGL-master/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Thibaut Despoulain
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/hexgl-package/HexGL-master/README.md

@@ -0,0 +1,26 @@
+HexGL
+=========
+
+Source code of [HexGL](http://hexgl.bkcore.com), the futuristic HTML5 racing game by [Thibaut Despoulain](http://bkcore.com)
+
+## Branches
+  * **[Master](https://github.com/BKcore/HexGL)** - Public release (stable).
+
+## License
+
+Unless specified in the file, HexGL's code and resources are now licensed under the *MIT License*.
+
+## Installation
+
+	cd ~/
+	git clone git://github.com/BKcore/HexGL.git
+	cd HexGL
+	python -m SimpleHTTPServer
+	chromium index.html
+
+To use full size textures, swap the two textures/ and textures.full/ directories.
+
+## Note
+
+The development of HexGL is in a hiatus for now until I find some time and interest to work on it again.
+That said, feel free to post issues, patches, or anything to make the game better and I'll gladly review and merge them.

package/hexgl-package/HexGL-master/audio/LICENSE

@@ -0,0 +1,28 @@
+Licenses for the sound files
+=============================
+
+*boost.ogg*
+
+Created by IFartInUrGeneralDirection and distributed under
+Creative Commons 3.0 Attribution 3.0 Unported license.
+
+*crash.ogg*
+Created by qubodup and is published into Public Domain.
+
+*wind.ogg*
+Created by kangaroovindaloo and distributed under
+Creative Commons 3.0 Attribution 3.0 Unported license.
+
+This SFX is further cutted and adjusted by Licson.
+
+*bg.ogg*
+Created by mu6k and is released into Public Domain.
+
+Further adjusted by Licson.
+
+*destroyed.ogg*
+Created by beman87 and is distributed under Creative Commons Attribution 3.0 Unported license.
+
+This SFX is further adjusted by Licson.
+
+All sound files converted to OGG Vorbis by baleboy using VLC Media Player.

package/hexgl-package/HexGL-master/bkcore/Audio.js

@@ -0,0 +1,142 @@
+var bkcore = bkcore || {};
+
+bkcore.Audio = {};
+bkcore.Audio.sounds = {};
+
+bkcore.Audio.init = function(){
+	if(window.AudioContext||window.webkitAudioContext){
+		bkcore.Audio._ctx = new (window.AudioContext||window.webkitAudioContext)();
+		bkcore.Audio._panner = bkcore.Audio._ctx.createPanner();
+		bkcore.Audio._panner.connect(bkcore.Audio._ctx.destination);
+	}
+	else {
+		bkcore.Audio._ctx = null;
+	}
+
+	bkcore.Audio.posMultipler = 1.5;
+};
+
+bkcore.Audio.init();
+
+bkcore.Audio.addSound = function(src, id, loop, callback, usePanner){
+	var ctx = bkcore.Audio._ctx;
+	var audio = new Audio();
+	
+	if(ctx){
+		var audio = { src: null, gainNode: null, bufferNode: null, loop: loop };
+		var xhr = new XMLHttpRequest();
+		xhr.responseType = 'arraybuffer';
+
+		xhr.onload = function(){
+			ctx.decodeAudioData(xhr.response, function(b){
+				// Create Gain Node
+				var gainNode = ctx.createGain();
+
+				if(usePanner === true){
+					gainNode.connect(bkcore.Audio._panner);
+				}
+				else {
+					gainNode.connect(ctx.destination);
+				}
+
+				// Add the audio source
+				audio.src = b;
+
+				//Remember the gain node
+				audio.gainNode = gainNode;
+				
+				callback();
+			}, function(e){
+				console.error('Audio decode failed!', e);
+			});
+		};
+
+		xhr.open('GET', src, true);
+		xhr.send(null);
+	}
+	else {
+		// Workaround for old Safari
+		audio.addEventListener('canplay', function(){
+			audio.pause();
+			audio.currentTime = 0;
+
+			callback();
+		}, false);
+
+		audio.autoplay = true;
+		audio.loop = loop;
+		audio.src = src;
+	}
+	
+	bkcore.Audio.sounds[id] = audio;
+};
+
+bkcore.Audio.play = function(id){
+	var ctx = bkcore.Audio._ctx;
+
+	if(ctx){
+		var sound = ctx.createBufferSource();
+		sound.connect(bkcore.Audio.sounds[id].gainNode);
+		
+		sound.buffer = bkcore.Audio.sounds[id].src;
+		sound.loop = bkcore.Audio.sounds[id].loop;
+
+		bkcore.Audio.sounds[id].gainNode.gain.value = 1;
+		bkcore.Audio.sounds[id].bufferNode = sound;
+
+		sound.start ? sound.start(0) : sound.noteOn(0);
+	}
+	else {
+		if(bkcore.Audio.sounds[id].currentTime > 0){
+			bkcore.Audio.sounds[id].pause();
+			bkcore.Audio.sounds[id].currentTime = 0;
+		}
+
+		bkcore.Audio.sounds[id].play();
+	}
+};
+
+bkcore.Audio.stop = function(id){
+	var ctx = bkcore.Audio._ctx;
+
+	if(ctx){
+		if(bkcore.Audio.sounds[id].bufferNode !== null){
+			var bufferNode = bkcore.Audio.sounds[id].bufferNode;
+			bufferNode.stop ? bufferNode.stop(ctx.currentTime) : bufferNode.noteOff(ctx.currentTime);
+		}
+	}
+	else {
+		bkcore.Audio.sounds[id].pause();
+		bkcore.Audio.sounds[id].currentTime = 0;
+	}
+};
+
+bkcore.Audio.volume = function(id, volume){
+	var ctx = bkcore.Audio._ctx;
+
+	if(ctx){
+		bkcore.Audio.sounds[id].gainNode.gain.value = volume;
+	}
+	else {
+		bkcore.Audio.sounds[id].volume = volume;
+	}
+};
+
+bkcore.Audio.setListenerPos = function(vec){
+	if(bkcore.Audio._ctx){
+		var panner = bkcore.Audio._panner;
+		var vec2 = vec.normalize();
+		panner.setPosition(
+			vec2.x * bkcore.Audio.posMultipler,
+			vec2.y * bkcore.Audio.posMultipler,
+			vec2.z * bkcore.Audio.posMultipler
+		);
+	}
+};
+
+bkcore.Audio.setListenerVelocity = function(vec){
+	if(bkcore.Audio._ctx){
+		var panner = bkcore.Audio._panner;
+		//panner.setVelocity(vec.x, vec.y, vec.z);
+	}
+};

package/hexgl-package/HexGL-master/bkcore/hexgl/CameraChase.js

@@ -0,0 +1,73 @@
+ /*
+ * HexGL
+ * @author Thibaut 'BKcore' Despoulain <http://bkcore.com>
+ * @license This work is licensed under the Creative Commons Attribution-NonCommercial 3.0 Unported License. 
+ *          To view a copy of this license, visit http://creativecommons.org/licenses/by-nc/3.0/.
+ */
+
+var bkcore = bkcore || {};
+bkcore.hexgl = bkcore.hexgl || {};
+
+bkcore.hexgl.CameraChase = function(opts)
+{
+	this.dir = new THREE.Vector3(0,0,1);
+	this.up = new THREE.Vector3(0,1,0);
+	this.target = new THREE.Vector3();
+	this.speedOffset = 0;
+	this.speedOffsetMax = 10;
+	this.speedOffsetStep = 0.05;
+
+	this.modes = {
+		CHASE: 0,
+		ORBIT: 1
+	}
+	this.mode = this.modes.CHASE;
+
+	this.camera = opts.camera;
+	this.targetObject = opts.target;
+	this.cameraCube = opts.cameraCube == undefined ? null : opts.cameraCube;
+
+	this.yoffset = opts.yoffest == undefined ? 8.0 : opts.yoffest;
+	this.zoffset = opts.zoffset == undefined ? 10.0 : opts.zoffset;
+	this.viewOffset = opts.viewOffset == undefined ? 10.0 : opts.viewOffset;
+	this.orbitOffset = 12;
+	this.lerp = opts.lerp == undefined ? 0.5 : opts.lerp;
+	this.time = 0.0;
+}
+
+bkcore.hexgl.CameraChase.prototype.update = function(dt, ratio)
+{
+	if(this.mode == this.modes.CHASE)
+	{
+		this.dir.set(0,0,1);
+		this.up.set(0,1,0);
+
+		this.targetObject.matrix.rotateAxis(this.up);
+		this.targetObject.matrix.rotateAxis(this.dir);
+
+		this.speedOffset += (this.speedOffsetMax*ratio - this.speedOffset) * Math.min(1, 0.3*dt);
+
+		this.target.copy(this.targetObject.position);
+		this.target.subSelf(this.dir.multiplyScalar(this.zoffset + this.speedOffset));
+		this.target.addSelf(this.up.multiplyScalar(this.yoffset));
+		this.target.y += -this.up.y + this.yoffset;
+		this.camera.position.copy(this.target);
+		
+		this.camera.lookAt(this.dir.normalize().multiplyScalar(this.viewOffset).addSelf(this.targetObject.position));
+	}
+	else if(this.mode == this.modes.ORBIT)
+	{
+		this.time += dt*.008;
+		this.dir.set(
+			Math.cos(this.time)*this.orbitOffset,
+			this.yoffset/2,
+			Math.sin(this.time)*this.orbitOffset
+		);
+		this.target.copy(this.targetObject.position).addSelf(this.dir);
+		this.camera.position.copy(this.target);
+		this.camera.lookAt(this.targetObject.position);
+	}
+
+	if(this.cameraCube != null)
+		this.cameraCube.rotation.copy(this.camera.rotation);
+}

package/hexgl-package/HexGL-master/bkcore/hexgl/Gameplay.js

@@ -0,0 +1,231 @@
+ /*
+ * HexGL
+ * @author Thibaut 'BKcore' Despoulain <http://bkcore.com>
+ * @license This work is licensed under the Creative Commons Attribution-NonCommercial 3.0 Unported License. 
+ *          To view a copy of this license, visit http://creativecommons.org/licenses/by-nc/3.0/.
+ */
+
+var bkcore = bkcore || {};
+bkcore.hexgl = bkcore.hexgl || {};
+
+bkcore.hexgl.Gameplay = function(opts)
+{
+	var self = this;
+
+	this.startDelay = opts.hud == null ? 0 : 1000;
+	this.countDownDelay = opts.hud == null ? 1000 : 1500;
+
+	this.active = false;
+	this.timer = new bkcore.Timer();
+	this.modes = {
+		'timeattack':null,
+		'survival':null,
+		'replay':null
+	};
+	this.mode = opts.mode == undefined || !(opts.mode in this.modes) ? "timeattack" : opts.mode;
+	this.step = 0;
+
+	this.hud = opts.hud;
+	this.shipControls = opts.shipControls;
+	this.cameraControls = opts.cameraControls;
+	this.track = opts.track;
+	this.analyser = opts.analyser;
+	this.pixelRatio = opts.pixelRatio;
+
+	this.previousCheckPoint = -1;
+
+	this.results = {
+		FINISH: 1,
+		DESTROYED: 2,
+		WRONGWAY: 3,
+		REPLAY: 4,
+		NONE: -1
+	};
+	this.result = this.results.NONE;
+
+	this.lap = 1;
+	this.lapTimes = [];
+	this.lapTimeElapsed = 0;
+	this.maxLaps = 3;
+	this.score = null;
+	this.finishTime = null;
+	this.onFinish = opts.onFinish == undefined ? function(){console.log("FINISH");} : opts.onFinish;
+
+	this.raceData = null;
+
+	this.modes.timeattack = function()
+	{
+		self.raceData.tick(this.timer.time.elapsed);
+
+		self.hud != null && self.hud.updateTime(self.timer.getElapsedTime());
+		var cp = self.checkPoint();
+
+		if(cp == self.track.checkpoints.start && self.previousCheckPoint == self.track.checkpoints.last)
+		{
+			self.previousCheckPoint = cp;
+			var t = self.timer.time.elapsed;
+			self.lapTimes.push(t - self.lapTimeElapsed);
+			self.lapTimeElapsed = t;
+
+			if(self.lap == this.maxLaps)
+			{
+				self.end(self.results.FINISH);
+			}
+			else
+			{
+				self.lap++;
+				self.hud != null && self.hud.updateLap(self.lap, self.maxLaps);
+
+				if(self.lap == self.maxLaps)
+					self.hud != null && self.hud.display("Final lap", 0.5);
+			}
+		}
+		else if(cp != -1 && cp != self.previousCheckPoint)
+		{
+			self.previousCheckPoint = cp;
+			//self.hud.display("Checkpoint", 0.5);
+		}
+
+		if(self.shipControls.destroyed == true)
+		{
+			self.end(self.results.DESTROYED);
+		}
+	};
+
+	this.modes.replay = function()
+	{
+		self.raceData.applyInterpolated(this.timer.time.elapsed);
+
+		if(self.raceData.seek == self.raceData.last)
+		{
+			self.end(self.result.REPLAY);
+		}
+	};
+}
+
+bkcore.hexgl.Gameplay.prototype.simu = function()
+{
+	this.lapTimes = [92300, 91250, 90365];
+	this.finishTime = this.lapTimes[0]+this.lapTimes[1]+this.lapTimes[2];
+	if(this.hud != null) this.hud.display("Finish");
+	this.step = 100;
+	this.result = this.results.FINISH;
+	this.shipControls.active = false;
+}
+
+bkcore.hexgl.Gameplay.prototype.start = function(opts)
+{
+	this.finishTime = null;
+	this.score = null;
+	this.lap = 1;
+
+	this.shipControls.reset(this.track.spawn, this.track.spawnRotation);
+	this.shipControls.active = false;
+
+	this.previousCheckPoint = this.track.checkpoints.start;
+
+	this.raceData = new bkcore.hexgl.RaceData(this.track.name, this.mode, this.shipControls);
+	if(this.mode == 'replay')
+	{
+		this.cameraControls.mode = this.cameraControls.modes.ORBIT;
+		if(this.hud != null) this.hud.messageOnly = true;
+
+		try {
+			var d = localStorage['race-'+this.track.name+'-replay'];
+			if(d == undefined)
+			{
+				console.error('No replay data for '+'race-'+this.track.name+'-replay'+'.');
+				return false;
+			}
+			this.raceData.import(
+				JSON.parse(d)
+			);
+		}
+		catch(e) { console.error('Bad replay format : '+e); return false; }
+	}
+
+	this.active = true;
+	this.step = 0;
+	this.timer.start();
+	if(this.hud != null)
+	{
+		this.hud.resetTime();
+		this.hud.display("Get ready", 1);
+		this.hud.updateLap(this.lap, this.maxLaps);
+	}
+}
+
+bkcore.hexgl.Gameplay.prototype.end = function(result)
+{
+	this.score = this.timer.getElapsedTime();
+	this.finishTime = this.timer.time.elapsed;
+	this.timer.start();
+	this.result = result;
+
+	this.shipControls.active = false;
+
+	if(result == this.results.FINISH)
+	{
+		if(this.hud != null) this.hud.display("Finish");
+		this.step = 100;
+	}
+	else if(result == this.results.DESTROYED)
+	{
+		if(this.hud != null) this.hud.display("Destroyed");
+		this.step = 100;
+	}
+}
+
+bkcore.hexgl.Gameplay.prototype.update = function()
+{
+	if(!this.active) return;
+
+	this.timer.update();
+	
+	if(this.step == 0 && this.timer.time.elapsed >= this.countDownDelay+this.startDelay)
+	{
+		if(this.hud != null) this.hud.display("3");
+		this.step = 1;
+	}
+	else if(this.step == 1 && this.timer.time.elapsed >= 2*this.countDownDelay+this.startDelay)
+	{
+		if(this.hud != null) this.hud.display("2");
+		this.step = 2;
+	}
+	else if(this.step == 2 && this.timer.time.elapsed >= 3*this.countDownDelay+this.startDelay)
+	{
+		if(this.hud != null) this.hud.display("1");
+		this.step = 3;
+	}
+	else if(this.step == 3 && this.timer.time.elapsed >= 4*this.countDownDelay+this.startDelay)
+	{
+		if(this.hud != null) this.hud.display("Go", 0.5);
+		this.step = 4;
+		this.timer.start();
+		
+		if(this.mode != "replay")
+			this.shipControls.active = true;
+	}
+	else if(this.step == 4)
+	{
+		this.modes[this.mode].call(this);
+	}
+	else if(this.step == 100 && this.timer.time.elapsed >= 2000)
+	{
+		this.active = false;
+		this.onFinish.call(this);
+	}
+}
+
+bkcore.hexgl.Gameplay.prototype.checkPoint = function()
+{
+	var x = Math.round(this.analyser.pixels.width/2 + this.shipControls.dummy.position.x * this.pixelRatio);
+	var z = Math.round(this.analyser.pixels.height/2 + this.shipControls.dummy.position.z * this.pixelRatio);
+
+	var color = this.analyser.getPixel(x, z);
+
+	if(color.r == 255 && color.g == 255 && color.b < 250)
+		return color.b;
+	else
+		return -1;
+}