thallada.github.io/js/magic.js

313 lines
11 KiB
JavaScript
Raw Normal View History

2014-12-20 23:18:08 +00:00
var Magic = function (options) {
2014-12-20 23:19:24 +00:00
options = options || {};
2014-07-20 02:42:43 +00:00
// Array to hold all active spells being drawn
2014-12-20 23:18:08 +00:00
this.spells = [];
// When on, wait a certain amount of time before casting (for initial
// load-up)
2014-12-20 23:18:08 +00:00
this.counting = options.counting || true;
// The amount of time to wait (in number of animate() calls)
2014-12-20 23:18:08 +00:00
this.waitTime = options.waitTime || 20;
// How fast to draw the spells
2014-12-20 23:18:08 +00:00
this.step = options.step || 0.2;
// Limit of branches per spell at any time
2014-12-20 23:18:08 +00:00
this.prune_to = options.prune_to || 20;
2014-12-20 23:18:08 +00:00
// Max duration possible (in steps) of a spell
this.maxDuration = options.maxDuration || 600;
2014-06-29 19:51:58 +00:00
2014-12-20 23:18:08 +00:00
// Min duration possible (in steps) of a spell
this.minDuration = options.minDuration || 50;
2014-06-29 19:51:58 +00:00
2014-12-20 23:18:08 +00:00
// Max angle deviation during branch split
this.maxAngleChange = options.maxAngleChange || 180;
2014-06-29 19:51:58 +00:00
2014-12-20 23:18:08 +00:00
// Min angle deviation during branch split
this.minAngleChange = options.minAngleChange || 90;
2014-06-29 19:51:58 +00:00
2014-12-20 23:18:08 +00:00
// Average length of new spline (branch)
this.splineLength = options.splineLength || 15;
2014-06-29 19:51:58 +00:00
2015-01-11 20:13:07 +00:00
// Whether new spells are cast with a new random color
this.randomColored = options.randomColored || true;
this.paused = false;
2014-12-20 23:18:08 +00:00
// Save this query here now that the page is loaded
this.canvas = document.getElementById("magic");
2014-12-20 23:19:24 +00:00
};
2014-06-29 19:51:58 +00:00
2014-07-19 19:49:07 +00:00
2014-12-20 23:18:08 +00:00
/* Get the height and width of full document. To avoid browser
* incompatibility issues, choose the maximum of all height/width values.
*
* Method from http://stackoverflow.com/a/1147768 */
Magic.prototype.getDocumentDimensions = function () {
var body = document.body,
html = document.documentElement;
2014-07-19 19:49:07 +00:00
2014-12-20 23:18:08 +00:00
var height = Math.max(body.scrollHeight, body.offsetHeight,
html.clientHeight, html.scrollHeight,
html.offsetHeight);
var width = Math.max(body.scrollWidth, body.offsetWidth,
html.clientWidth, html.scrollWidth,
html.offsetWidth);
return {"height": height, "width": width};
2014-12-20 23:19:24 +00:00
};
2014-12-20 23:18:08 +00:00
/* Specifies what will be added to the red, green, and blue values of the
* color at each interval. */
Magic.prototype.pickGradient = function () {
var directions = [-1, 0, 1];
var magnitudes = [1, 2, 3];
return {"r": directions[Math.floor(Math.random() * 3)] *
magnitudes[Math.floor(Math.random() * 3)],
"g": directions[Math.floor(Math.random() * 3)] *
magnitudes[Math.floor(Math.random() * 3)],
"b": directions[Math.floor(Math.random() * 3)] *
magnitudes[Math.floor(Math.random() * 3)]};
2014-12-20 23:19:24 +00:00
};
2014-12-20 23:18:08 +00:00
/* Alters the given color by the given gradient and returns both.
If the red, green, or blue value of the color is at 0 or 255 and the
gradient for that value is not zero, then the gradient for that value
will change signs.
Unused for now. It turns out that changing the canvas stroke color is a
costly operation and slows things down a lot. */
Magic.prototype.nextColor = function(color, gradient) {
var values = ["r", "g", "b"];
// Check if color at end of range and reverse gradient direction if so
for (var i = 0; i < 3; i++) {
var colorValue = color[values[i]];
var gradientValue = gradient[values[i]];
if ((colorValue === 255 && gradientValue > 0) ||
(colorValue === 0 && gradientValue < 0)) {
gradient[values[i]] = gradientValue * -1;
2014-07-19 19:49:07 +00:00
}
}
2014-12-20 23:18:08 +00:00
// Modify the color according to the gradient
for (i = 0; i < 3; i++) {
color[values[i]] = color[values[i]] + gradient[values[i]];
}
2014-07-19 19:49:07 +00:00
2014-12-20 23:18:08 +00:00
return {"color": color, "gradient": gradient};
2014-12-20 23:19:24 +00:00
};
2014-12-20 23:18:08 +00:00
/* Choose a random RGB color to begin the color gradient with */
Magic.prototype.pickRandomColor = function() {
return {"r": Math.floor(Math.random() * (255 + 1)),
"g": Math.floor(Math.random() * (255 + 1)),
"b": Math.floor(Math.random() * (255 + 1))};
2014-12-20 23:19:24 +00:00
};
2014-12-20 23:18:08 +00:00
Magic.prototype.clear = function() {
this.context.clearRect(0, 0, this.canvas.width, this.canvas.height);
}
2014-12-20 23:18:08 +00:00
Magic.prototype.drawSplineSegment = function(branch, context) {
var ax = (-branch.points[0].x + 3*branch.points[1].x - 3*branch.points[2].x + branch.points[3].x) / 6;
var ay = (-branch.points[0].y + 3*branch.points[1].y - 3*branch.points[2].y + branch.points[3].y) / 6;
var bx = (branch.points[0].x - 2*branch.points[1].x + branch.points[2].x) / 2;
var by = (branch.points[0].y - 2*branch.points[1].y + branch.points[2].y) / 2;
var cx = (-branch.points[0].x + branch.points[2].x) / 2;
var cy = (-branch.points[0].y + branch.points[2].y) / 2;
var dx = (branch.points[0].x + 4*branch.points[1].x + branch.points[2].x) / 6;
var dy = (branch.points[0].y + 4*branch.points[1].y + branch.points[2].y) / 6;
context.moveTo(
ax*Math.pow(branch.t, 3) + bx*Math.pow(branch.t, 2) + cx*branch.t + dx,
ay*Math.pow(branch.t, 3) + by*Math.pow(branch.t, 2) + cy*branch.t + dy
);
context.lineTo(
ax*Math.pow(branch.t+this.step, 3) + bx*Math.pow(branch.t+this.step, 2) + cx*(branch.t+this.step) + dx,
ay*Math.pow(branch.t+this.step, 3) + by*Math.pow(branch.t+this.step, 2) + cy*(branch.t+this.step) + dy
);
branch.t += this.step;
2014-12-20 23:19:24 +00:00
};
2014-12-20 23:18:08 +00:00
Magic.prototype.splitBranch = function(branch) {
var newBranches = [];
// Replace with 2 new branches
for (var k = 0; k < 2; k++) {
// Generate random deviation from previous angle
var angle = branch.angle - (Math.random() * this.maxAngleChange - this.minAngleChange);
// Generate random length
var length = Math.random() * this.splineLength + 4;
// Calculate new point
var x2 = branch.points[3].x + Math.sin(Math.PI * angle / 180) * length;
var y2 = branch.points[3].y - Math.cos(Math.PI * angle / 180) * length;
// Add to new branch array
newBranches.push({
points:new Array(
branch.points[1],
branch.points[2],
branch.points[3],
{x:x2, y:y2}
),
angle:angle,
t:0,
2014-07-20 02:42:43 +00:00
});
2014-12-20 23:18:08 +00:00
2014-07-19 19:49:07 +00:00
}
2014-12-20 23:18:08 +00:00
return newBranches;
2014-12-20 23:19:24 +00:00
};
2014-07-19 19:49:07 +00:00
2014-12-20 23:18:08 +00:00
Magic.prototype.cast = function(x, y, angle, chain) {
// Find random position if not defined
if (x === undefined) {
x = Math.floor(Math.random() * (this.canvas.width + 1));
}
if (y === undefined) {
y = Math.floor(Math.random() * (this.canvas.height + 1));
}
if (angle === undefined) {
angle = Math.random() * 360;
}
2014-06-29 19:51:58 +00:00
2015-01-11 20:13:07 +00:00
var colorString = "rgb(10,10,10)";
if (this.randomColored) {
var color = this.pickRandomColor();
colorString = "rgb(" + color.r + "," + color.g + "," + color.b + ")";
}
2014-12-20 23:18:08 +00:00
// Create new spell (branch)
this.spells.push({
branches:new Array({
points:new Array({x:x, y:y}, {x:x, y:y}, {x:x, y:y}, {x:x, y:y}),
angle:angle,
t:0,
}),
color:colorString,
duration:Math.floor(Math.random() * (this.maxDuration - this.minDuration + 1)) + 50,
chain:chain,
});
2014-12-20 23:19:24 +00:00
};
2014-12-20 23:18:08 +00:00
/* Most of this funtion is provided by Maissan Inc. in their tutorial:
http://www.maissan.net/articles/simulating-vines */
Magic.prototype.drawSpells = function(context, sort, prune, chain) {
var AnimationFrame = window.AnimationFrame;
AnimationFrame.shim();
var animationFrame = new AnimationFrame(30),
timeCounter = 0,
color,
gradient;
context.lineWidth = 0.5;
var self = this;
function animate(time) {
// resize canvas if document size changed
dimensions = self.getDocumentDimensions();
if ((dimensions.height !== self.canvas.height) ||
(dimensions.width !== self.canvas.width)) {
self.canvas.height = dimensions.height;
self.canvas.width = dimensions.width;
}
2014-07-20 02:42:43 +00:00
if (!self.paused) {
// if enough time has passed, cast another spell to draw
if (timeCounter >= self.waitTime && self.counting) {
self.cast(undefined, undefined, undefined, chain); // start position
self.counting = false;
}
// Draw branches
for (var i in self.spells) {
context.beginPath();
context.strokeStyle = self.spells[i].color;
if (self.spells[i].duration > 0) {
for (var j in self.spells[i].branches) {
self.drawSplineSegment(self.spells[i].branches[j], context);
// When finished drawing splines, create a new set of branches
if (self.spells[i].branches[j].t >= 1) {
var newBranches = self.splitBranch(self.spells[i].branches[j]);
// Replace old branch with two new branches
self.spells[i].branches.splice(j, 1);
self.spells[i].branches = self.spells[i].branches.concat(newBranches);
}
}
// If over 10 branches, prune the branches
if (prune) {
if (sort) {
while (self.spells[i].branches.length > self.prune_to) {
self.spells[i].branches.pop();
}
} else {
while (self.spells[i].branches.length > self.prune_to) {
self.spells[i].branches.splice(
Math.floor(Math.random() * self.spells[i].branches.length),
1);
}
}
}
context.stroke();
context.closePath();
self.spells[i].duration--;
} else {
// cast a new spell at random position
if (self.spells[i].chain) {
self.cast(undefined, undefined, undefined, true);
}
self.spells.splice(i, 1); // spell is done now
}
}
if (self.counting) {
timeCounter++;
}
2014-12-20 23:18:08 +00:00
}
frameId = animationFrame.request(animate);
}
2014-06-29 19:51:58 +00:00
2014-12-20 23:18:08 +00:00
// Drawing interval
var frameId = animationFrame.request(animate);
return frameId;
2014-12-20 23:19:24 +00:00
};
2014-12-20 23:18:08 +00:00
Magic.prototype.canvasClickHandler = function(event) {
var x = event.pageX;
var y = event.pageY;
this.cast(x, y, undefined, false);
2014-12-20 23:19:24 +00:00
};
2014-06-29 19:51:58 +00:00
2014-12-20 23:18:08 +00:00
Magic.prototype.draw = function() {
var interval_time = 2000;
2014-12-20 23:18:08 +00:00
// Initialize canvas
var dimensions = this.getDocumentDimensions();
this.canvas.height = dimensions.height;
this.canvas.width = dimensions.width;
2014-06-29 19:51:58 +00:00
2014-12-20 23:18:08 +00:00
// Check for canvas support, bind click event, and get context
if (this.canvas.getContext){
var self = this;
this.canvas.addEventListener("click", function () { self.canvasClickHandler.apply(self, arguments); });
this.context = this.canvas.getContext("2d");
2014-06-29 19:51:58 +00:00
2014-12-20 23:18:08 +00:00
// Cast magic spells
var frameId = this.drawSpells(this.context, false, true, true);
2014-12-20 23:18:08 +00:00
}
2014-12-20 23:19:24 +00:00
};