Last active
March 23, 2024 21:27
-
-
Save Rio6/3f0bb7d9ea4409733964262fc942ad6d to your computer and use it in GitHub Desktop.
Turns Istrolid into 3D
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* | |
* Turns Istrolid into 3D | |
* by R26 | |
*/ | |
var istrol3d = window.istrol3d || { | |
GameMode_toGameSpace: GameMode.prototype.toGameSpace, | |
GameMode_fromGameSpace: GameMode.prototype.fromGameSpace, | |
BattleMode_reset: BattleMode.prototype.reset, | |
BattleMode_onmousemove: BattleMode.prototype.onmousemove, | |
BattleMode_onkeydown: BattleMode.prototype.onkeydown, | |
Atlas_startFrame: Atlas.prototype.startFrame, | |
Atlas_beginSprites: Atlas.prototype.beginSprites, | |
}; | |
// battle.js changes | |
GameMode.prototype.toGameSpace = function(point) { | |
var p; | |
if (this.camera) { | |
p = this.camera.unproject([point[0] / window.innerWidth * 2 - 1, -(point[1] / window.innerHeight * 2 - 1)]); | |
return v3.lerp(p[0], p[1], -p[0][2] / (p[1][2] - p[0][2]), point); | |
} | |
return istrol3d.GameMode_toGameSpace.call(this, point); | |
}; | |
GameMode.prototype.fromGameSpace = function(point) { | |
var p; | |
if (this.camera) { | |
p = this.camera.project([point[0], point[1]]); | |
return [(p[0] + 1) / 2 * window.innerWidth, (-p[1] + 1) / 2 * window.innerHeight]; | |
} | |
return istrol3d.GameMode_fromGameSpace.call(this, point); | |
}; | |
_pos = v3.create(); | |
_dir = v3.create(); | |
_fwd = v3.create(); | |
_mat = m4.create(); | |
window.Camera = (function() { | |
function Camera() { | |
this.pos = v3.create([0, 0, 10000]); | |
this.dir = v3.create(); | |
this.yaw = Math.PI / 2 - 0.0001; | |
this.pitch = -Math.PI / 2 + 0.0001; | |
this.near = 50; | |
this.far = 100000; | |
this.fovy = 45; | |
this.redoDir = true; | |
this.followUnit = null; | |
} | |
Camera.prototype.rotate = function(yaw, pitch) { | |
this.yaw += yaw; | |
this.pitch += pitch; | |
if (this.pitch <= -Math.PI / 2) { | |
this.pitch = -Math.PI / 2 + 0.0001; | |
} | |
if (this.pitch >= Math.PI / 2) { | |
this.pitch = Math.PI / 2 - 0.0001; | |
} | |
return this.redoDir = true; | |
}; | |
Camera.prototype.updateDir = function(globCoord) { | |
var cosp, cosy, pitch, sinp, siny, yaw; | |
if (globCoord == null) { | |
globCoord = true; | |
} | |
if (this.redoDir || this.followUnit) { | |
if (!globCoord && this.followUnit) { | |
yaw = this.yaw + this.followUnit.rot - Math.PI / 2; | |
} else { | |
yaw = this.yaw; | |
} | |
pitch = this.pitch; | |
siny = Math.sin(yaw); | |
cosy = Math.cos(yaw); | |
sinp = Math.sin(pitch); | |
cosp = Math.cos(pitch); | |
this.dir[0] = cosy * cosp; | |
this.dir[1] = siny * cosp; | |
this.dir[2] = sinp; | |
return this.redoDir = false; | |
} | |
}; | |
Camera.prototype.move = function(x, y, z) { | |
if (z == null) { | |
z = 0; | |
} | |
this.updateDir(true); | |
v3.set(this.dir, _fwd); | |
_fwd[2] = 0; | |
v3.norm(_fwd); | |
v3.add(this.pos, v3.scale(_fwd, y, _dir)); | |
v3.add(this.pos, v3.scale(v3.cross(_fwd, Z, _fwd), x)); | |
v3.add(this.pos, v3.scale(Z, z, _dir)); | |
if (this.pos[2] < 0) { | |
return this.pos[2] = 0; | |
} | |
}; | |
Camera.prototype.follow = function(unit) { | |
if (unit) { | |
this.followUnit = unit; | |
v2.zero(this.pos); | |
this.pos[2] = 150; | |
return this.yaw = 0; | |
} else { | |
return this.followUnit = null; | |
} | |
}; | |
Camera.prototype.mat = function() { | |
var rot; | |
this.updateDir(false); | |
if (this.followUnit) { | |
rot = this.followUnit.rot - Math.PI / 2; | |
v2.rotate(this.pos, rot, _pos); | |
v2.add(_pos, this.followUnit.pos); | |
_pos[2] = this.pos[2]; | |
} else { | |
v3.set(this.pos, _pos); | |
} | |
v3.add(_pos, this.dir, _dir); | |
m4.lookAt(_pos, _dir, Z, _mat); | |
m4.mul(m4.perspective(this.fovy, window.innerWidth / window.innerHeight, this.near, this.far), _mat, _mat); | |
return _mat; | |
}; | |
Camera.prototype.project = function(point) { | |
var p; | |
p = v3.set(point, []); | |
if (!p[2]) { | |
p[2] = 0; | |
} | |
p[3] = 1; | |
m4.mul_v4(this.mat(), p); | |
return v3.scale(p, 1 / p[3], point); | |
}; | |
Camera.prototype.unproject = function(point) { | |
var mat, p0, p1; | |
mat = m4.inverse(this.mat(), []); | |
p0 = v2.set(point, []); | |
p0[2] = 0; | |
p0[3] = 1; | |
p1 = v2.set(point, []); | |
p1[2] = 1; | |
p1[3] = 1; | |
m4.mul_v4(mat, p0); | |
m4.mul_v4(mat, p1); | |
return [v3.scale(p0, 1 / p0[3]), v3.scale(p1, 1 / p1[3])]; | |
}; | |
return Camera; | |
})(); | |
BattleMode.prototype.reset = function() { | |
this.camera = new Camera(); | |
return istrol3d.BattleMode_reset.call(this); | |
}; | |
BattleMode.prototype.onmousemove = function(e) { | |
if (this.selecting) { | |
this.selection.style.display = "block"; | |
startx = Math.min(this.selectAt[0], e.clientX); | |
starty = Math.min(this.selectAt[1], e.clientY); | |
endx = Math.max(this.selectAt[0], e.clientX); | |
endy = Math.max(this.selectAt[1], e.clientY); | |
this.selection.style.left = startx + "px"; | |
this.selection.style.top = starty + "px"; | |
this.selection.style.width = -startx + endx + "px"; | |
this.selection.style.height = -starty + endy + "px"; | |
selected = []; | |
if (v2.distance([startx, starty], [endx, endy]) < 10) { | |
point = this.toGameSpace([startx, starty]); | |
unit = this.closestUnit(point); | |
if (unit) { | |
selected.push(unit); | |
} | |
} else { | |
ref = intp.things; | |
for (id in ref) { | |
thing = ref[id]; | |
if (!thing.unit) { | |
continue; | |
} | |
pos = this.fromGameSpace(thing.pos); | |
if ((startx < (ref1 = pos[0]) && ref1 < endx) && (starty < (ref2 = pos[1]) && ref2 < endy)) { | |
selected.push(thing); | |
} | |
} | |
} | |
if (this.selectAdd) { | |
ref3 = commander.selection; | |
for (j = 0, len = ref3.length; j < len; j++) { | |
thing = ref3[j]; | |
selected.push(thing); | |
} | |
} | |
ifHasFilter = function(selected, fn) { | |
var has, k, l, len1, len2, newSelected, t; | |
has = false; | |
for (k = 0, len1 = selected.length; k < len1; k++) { | |
t = selected[k]; | |
if (fn(t)) { | |
has = true; | |
} | |
} | |
if (!has) { | |
return selected; | |
} | |
newSelected = []; | |
for (l = 0, len2 = selected.length; l < len2; l++) { | |
t = selected[l]; | |
if (fn(t)) { | |
newSelected.push(t); | |
} | |
} | |
return newSelected; | |
}; | |
selected = (function() { | |
var k, len1, results; | |
results = []; | |
for (k = 0, len1 = selected.length; k < len1; k++) { | |
t = selected[k]; | |
if (t.unit) { | |
results.push(t); | |
} | |
} | |
return results; | |
})(); | |
selected = ifHasFilter(selected, function(u) { | |
return u.owner === commander.id; | |
}); | |
selected.sort(function(a, b) { | |
return a.id - b.id; | |
}); | |
this.selectUnitsFake(selected); | |
} | |
if (this.moving) { | |
dx = e.movementX; | |
dy = e.movementY; | |
if (dx === void 0) { | |
dx = e.mozMovementX; | |
} | |
if (dy === void 0) { | |
dy = e.mozMovementY; | |
} | |
this.camera.rotate(-dx / 1000 * Math.PI, -dy / 1000 * Math.PI); | |
} | |
let selecting = this.selecting; | |
let moving = this.moving; | |
this.selecting = false; | |
this.moving = false; | |
let ret = istrol3d.BattleMode_onmousemove.call(this, e); | |
this.selecting = selecting; | |
this.moving = moving; | |
return ret; | |
}; | |
BattleMode.prototype.onzoom = function(delta, e) { | |
var z; | |
z = 10; | |
return this.camera.move(0, 0, delta * z); | |
}; | |
BattleMode.prototype.controls = function() { | |
this.zoom = 1 + this.camera.pos[2] / 1000; | |
BattleMode.prototype.__proto__.controls.call(this); | |
return this.camera.move(-this.keyScroll[0], -this.keyScroll[1], this.keyZoom * 1000); | |
}; | |
BattleMode.prototype.onkeydown = function(e) { | |
if (settings.key(e, "Focus on Units")) { | |
this.centerOnUnit = true; | |
if (commander.selection.length > 0) { | |
this.camera.follow(commander.selection[0]); | |
} else { | |
this.camera.follow(null); | |
} | |
} | |
return istrol3d.BattleMode_onkeydown.call(this, e); | |
} | |
BattleMode.prototype.draw = function() { | |
var bg_zoom, theme, z; | |
baseAtlas.beginSprites([0, 0], 1, null, this.camera.mat()); | |
if (this.follow) { | |
control.setCursor("mouseAttack"); | |
} else { | |
control.setCursor("mouse"); | |
} | |
if (intp.theme != null) { | |
theme = intp.theme; | |
} else { | |
theme = mapping.themes[0]; | |
} | |
bg_zoom = Math.max(window.innerWidth, window.innerHeight) / 120; | |
z = bg_zoom * 5; | |
baseAtlas.drawSprite("img/newbg/gradient.png", [0, 0], [z, z], 0, theme.spotColor, -100); | |
intp.draw(); | |
if (this.drawPoints.length > 0) { | |
this.computeLineMove(); | |
} | |
return baseAtlas.finishSprites(); | |
}; | |
// Reset battle mode | |
{ | |
let oldServer = battleMode.server; | |
battleMode.reset(); // needed to prevent error when other's still referencing to old mode | |
window.battleMode = new BattleMode(); | |
battleMode.server = oldServer; | |
} | |
// engine.js changes | |
baseAtlas.drawMargin = 0; | |
baseAtlas.camera = m4.create(); | |
gl.enable(gl.DEPTH_TEST); | |
gl.depthFunc(gl.LEQUAL); | |
var initShader = function() { | |
var compileShader, linkShader, simpleFragment, simpleVertex; | |
compileShader = function(type, src) { | |
var shader; | |
shader = gl.createShader(type); | |
gl.shaderSource(shader, src); | |
gl.compileShader(shader); | |
if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS)) { | |
console.log(gl.getShaderInfoLog(shader)); | |
return null; | |
} | |
return shader; | |
}; | |
linkShader = function(fragmentSrc, vertexSrc) { | |
var shader; | |
shader = gl.createProgram(); | |
gl.attachShader(shader, compileShader(gl.FRAGMENT_SHADER, fragmentSrc)); | |
gl.attachShader(shader, compileShader(gl.VERTEX_SHADER, vertexSrc)); | |
gl.linkProgram(shader); | |
if (!gl.getProgramParameter(shader, gl.LINK_STATUS)) { | |
console.log("could not link shader"); | |
return null; | |
} | |
return shader; | |
}; | |
simpleFragment = ` | |
precision mediump float; | |
varying vec2 vTextureCoord; | |
varying vec4 vColor; | |
uniform sampler2D uSampler; | |
void main(void) { | |
vec4 textureColor = texture2D(uSampler, vec2(vTextureCoord.s, vTextureCoord.t)); | |
vec4 finalColor = textureColor * vColor; | |
gl_FragColor = finalColor; | |
if(gl_FragColor.a < 0.01) | |
discard; | |
} | |
`; | |
simpleVertex = ` | |
attribute vec3 aVertexPosition; | |
attribute vec2 aTextureCoord; | |
attribute vec4 aColor; | |
varying vec2 vTextureCoord; | |
varying vec4 vColor; | |
uniform mat4 uCamera; | |
void main(void) { | |
gl_Position = uCamera * vec4(aVertexPosition, 1.0); | |
vColor = aColor; | |
vTextureCoord = aTextureCoord; | |
} | |
`; | |
this.shader = linkShader(simpleFragment, simpleVertex); | |
gl.useProgram(this.shader); | |
this.shader.vertAttr = gl.getAttribLocation(this.shader, "aVertexPosition"); | |
gl.enableVertexAttribArray(this.shader.vertAttr); | |
this.shader.uvsAttr = gl.getAttribLocation(this.shader, "aTextureCoord"); | |
gl.enableVertexAttribArray(this.shader.uvsAttr); | |
this.shader.colorsAttr = gl.getAttribLocation(this.shader, "aColor"); | |
gl.enableVertexAttribArray(this.shader.colorsAttr); | |
this.shader.samplerUniform = gl.getUniformLocation(this.shader, "uSampler"); | |
return this.shader.cameraUniform = gl.getUniformLocation(this.shader, "uCamera"); | |
}; | |
var initBuffers = function() { | |
this.verts = new Float32Array(3 * 4 * this.maxSpritesInBatch); | |
var a, i, j, ref, x, y; | |
for (i = j = 0, ref = this.maxSpritesInBatch; 0 <= ref ? j < ref : j > ref; i = 0 <= ref ? ++j : --j) { | |
a = 0; | |
x = 0; | |
y = 0; | |
this.verts[i * 12 + 0] = x - a; | |
this.verts[i * 12 + 1] = y - a; | |
this.verts[i * 12 + 2] = 0; | |
this.verts[i * 12 + 3] = x + a; | |
this.verts[i * 12 + 4] = y - a; | |
this.verts[i * 12 + 5] = 0; | |
this.verts[i * 12 + 6] = x + a; | |
this.verts[i * 12 + 7] = y + a; | |
this.verts[i * 12 + 8] = 0; | |
this.verts[i * 12 + 9] = x - a; | |
this.verts[i * 12 + 10] = y + a; | |
this.verts[i * 12 + 11] = 0; | |
} | |
gl.bindBuffer(gl.ARRAY_BUFFER, this.vertsBuf); | |
gl.bufferData(gl.ARRAY_BUFFER, this.verts, gl.DYNAMIC_DRAW); | |
}; | |
initShader.call(baseAtlas); | |
initBuffers.call(baseAtlas); | |
Atlas.prototype.startFrame = function() { | |
let ret = istrol3d.Atlas_startFrame.call(this); | |
gl.clearColor(0.1, 0.2, 0.3, 1.0); | |
gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT); | |
return ret; | |
}; | |
Atlas.prototype.beginSprites = function(pos, zoom, viewPort, camera) { | |
var ret = istrol3d.Atlas_beginSprites.call(this, pos, zoom, viewPort); | |
if (!camera) { | |
m4.scale(m4.identity(this.camera), [1 / this.viewPort[2], 1 / this.viewPort[3], 0]); | |
return m4.mul(this.camera, m4.translate(m4.identity(m4.create), [this.viewPort[0], this.viewPort[1], 0])); | |
} else { | |
return this.camera = camera; | |
} | |
return ret; | |
}; | |
Atlas.prototype.drawSprite = function(src, pos, size, rot, color, z) { | |
var _z, cos, h, i, m, mapping, sin, sx, sy, w; | |
if (color == null) { | |
color = [255, 255, 255, 255]; | |
} | |
if (z == null) { | |
z = 0; | |
} | |
if (!this.ready) { | |
return; | |
} | |
if (this.curSprite >= this.maxSpritesInBatch) { | |
this.finishSprites(); | |
} | |
mapping = this.spriteMap[src]; | |
if (!mapping) { | |
console.error("not in mapping", src); | |
return; | |
} | |
i = this.curSprite; | |
m = this.drawMargin / this.originalTextureSize; | |
this.uvs[i * 8 + 0] = mapping.uv[0] - m; | |
this.uvs[i * 8 + 1] = mapping.uv[1] + m; | |
this.uvs[i * 8 + 2] = mapping.uv[2] + m; | |
this.uvs[i * 8 + 3] = mapping.uv[1] + m; | |
this.uvs[i * 8 + 4] = mapping.uv[2] + m; | |
this.uvs[i * 8 + 5] = mapping.uv[3] - m; | |
this.uvs[i * 8 + 6] = mapping.uv[0] - m; | |
this.uvs[i * 8 + 7] = mapping.uv[3] - m; | |
this.colors[i * 16 + 0] = color[0]; | |
this.colors[i * 16 + 1] = color[1]; | |
this.colors[i * 16 + 2] = color[2]; | |
this.colors[i * 16 + 3] = color[3]; | |
this.colors[i * 16 + 4] = color[0]; | |
this.colors[i * 16 + 5] = color[1]; | |
this.colors[i * 16 + 6] = color[2]; | |
this.colors[i * 16 + 7] = color[3]; | |
this.colors[i * 16 + 8] = color[0]; | |
this.colors[i * 16 + 9] = color[1]; | |
this.colors[i * 16 + 10] = color[2]; | |
this.colors[i * 16 + 11] = color[3]; | |
this.colors[i * 16 + 12] = color[0]; | |
this.colors[i * 16 + 13] = color[1]; | |
this.colors[i * 16 + 14] = color[2]; | |
this.colors[i * 16 + 15] = color[3]; | |
w = (mapping.uv[2] - mapping.uv[0]) * this.originalTextureSize; | |
h = (mapping.uv[1] - mapping.uv[3]) * this.originalTextureSize; | |
sx = (w + this.drawMargin * 2) * size[0] / 2; | |
sy = (h + this.drawMargin * 2) * size[1] / 2; | |
cos = Math.cos(rot); | |
sin = Math.sin(rot); | |
if (typeof z === "function") { | |
_z = z; | |
} else { | |
_z = function() { | |
return z; | |
}; | |
} | |
this.verts[i * 12 + 0] = pos[0] + (-sx * cos + sy * sin); | |
this.verts[i * 12 + 1] = pos[1] + (-sx * sin - sy * cos); | |
this.verts[i * 12 + 2] = _z([this.verts[i * 12 + 0], this.verts[i * 12 + 1]]); | |
this.verts[i * 12 + 3] = pos[0] + (+sx * cos + sy * sin); | |
this.verts[i * 12 + 4] = pos[1] + (+sx * sin - sy * cos); | |
this.verts[i * 12 + 5] = _z([this.verts[i * 12 + 3], this.verts[i * 12 + 4]]); | |
this.verts[i * 12 + 6] = pos[0] + (+sx * cos - sy * sin); | |
this.verts[i * 12 + 7] = pos[1] + (+sx * sin + sy * cos); | |
this.verts[i * 12 + 8] = _z([this.verts[i * 12 + 6], this.verts[i * 12 + 7]]); | |
this.verts[i * 12 + 9] = pos[0] + (-sx * cos - sy * sin); | |
this.verts[i * 12 + 10] = pos[1] + (-sx * sin + sy * cos); | |
this.verts[i * 12 + 11] = _z([this.verts[i * 12 + 9], this.verts[i * 12 + 10]]); | |
return this.curSprite += 1; | |
}; | |
Atlas.prototype.finishSprites = function(blend) { | |
if (blend == null) { | |
blend = false; | |
} | |
if (blend) { | |
gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA); | |
} else { | |
gl.blendFunc(gl.SRC_ALPHA, gl.ONE_MINUS_SRC_ALPHA); | |
} | |
gl.useProgram(this.shader); | |
gl.bindBuffer(gl.ARRAY_BUFFER, this.vertsBuf); | |
gl.bufferData(gl.ARRAY_BUFFER, this.verts, gl.DYNAMIC_DRAW); | |
gl.vertexAttribPointer(this.shader.vertAttr, 3, gl.FLOAT, false, 0, 0); | |
gl.bindBuffer(gl.ARRAY_BUFFER, this.uvsBuf); | |
gl.bufferData(gl.ARRAY_BUFFER, this.uvs, gl.DYNAMIC_DRAW); | |
gl.vertexAttribPointer(this.shader.uvsAttr, 2, gl.FLOAT, false, 0, 0); | |
gl.bindBuffer(gl.ARRAY_BUFFER, this.colorsBuf); | |
gl.bufferData(gl.ARRAY_BUFFER, this.colors, gl.DYNAMIC_DRAW); | |
gl.vertexAttribPointer(this.shader.colorsAttr, 4, gl.UNSIGNED_BYTE, true, 0, 0); | |
gl.activeTexture(gl.TEXTURE0); | |
gl.bindTexture(gl.TEXTURE_2D, this.texture); | |
gl.uniform1i(this.shader.samplerUniform, 0); | |
gl.uniformMatrix4fv(this.shader.cameraUniform, false, this.camera); | |
gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this.indexsBuf); | |
gl.drawElements(gl.TRIANGLES, this.curSprite * 6, gl.UNSIGNED_SHORT, 0); | |
return this.curSprite = 0; | |
}; | |
// maths.js changes | |
m4.mul_v4 = function(m, v, d) { | |
var w, x, y, z; | |
if (d == null) { | |
d = v; | |
} | |
x = v[0]; | |
y = v[1]; | |
z = v[2]; | |
w = v[3]; | |
d[0] = m[0] * x + m[4] * y + m[8] * z + m[12] * w; | |
d[1] = m[1] * x + m[5] * y + m[9] * z + m[13] * w; | |
d[2] = m[2] * x + m[6] * y + m[10] * z + m[14] * w; | |
d[3] = m[3] * x + m[7] * y + m[11] * z + m[15] * w; | |
return d; | |
}; | |
// parts.js changes | |
parts.EnergyTransfer.prototype.draw = function() { | |
var r; | |
parts.EnergyTransfer.prototype.__proto__.draw.call(this); | |
if (this.working) { | |
r = (this.range + 40) / 255; | |
return baseAtlas.drawSprite("img/point02.png", this.unit.pos, [r, r], 0, [255, 255, 255, 10], this.unit.z); | |
} | |
}; | |
parts.StasisField.prototype.draw = function() { | |
var a, r; | |
parts.StasisField.prototype.__proto__.draw.call(this); | |
if (this.working) { | |
a = 100; | |
} else { | |
a = 25; | |
} | |
r = (this.range + 40) / 255; | |
return baseAtlas.drawSprite("img/point02.png", [this.worldPos[0] + (Math.sin(this.unit.rot) * 100), this.worldPos[1] - (Math.cos(this.unit.rot) * 100)], [r, r], 0, [0, 0, 0, a], this.unit.z); | |
}; | |
// things.js changes | |
var _color = [0,0,0,0]; | |
Trail.prototype.draw = function() { | |
var alive, j, len, p, ref, ref1, results, s, t; | |
while (this.trail.length > 0 && intp.smoothStep - this.trail[0][1] > this.trailTime) { | |
this.trail.shift(); | |
} | |
_color[0] = 155 + this.color[0] / 255 * 100; | |
_color[1] = 155 + this.color[1] / 255 * 100; | |
_color[2] = 155 + this.color[2] / 255 * 100; | |
_color[3] = 0; | |
s = this.trailSize; | |
ref = this.trail; | |
results = []; | |
for (j = 0, len = ref.length; j < len; j++) { | |
ref1 = ref[j], p = ref1[0], t = ref1[1]; | |
alive = (intp.smoothStep - t) / this.trailTime; | |
if (alive < 1 && alive > 0) { | |
_color[3] = 255 - 255 * alive; | |
} else { | |
_color[3] = 0; | |
} | |
results.push(baseAtlas.drawSprite("img/fire02.png", p, [s, s], 0, _color, 5)); | |
} | |
return results; | |
}; | |
Particle.prototype.z = 0; | |
Particle.prototype.draw = function() { | |
if (this.dead) { | |
return; | |
} | |
return baseAtlas.drawSprite(this.image, this.pos, this.size, this.rot, this.color, this.z - this.life); | |
}; | |
Bullet.prototype.draw = function() { | |
var max; | |
if (this.hitPos) { | |
max = v2.distance(this.pos, this.hitPos) / this.speed; | |
this.z = this.life * max; | |
} else { | |
this.z = 50; | |
} | |
return Bullet.prototype.__proto__.draw.call(this); | |
}; | |
var _offset = v2.create(); | |
LaserBullet.prototype.draw = function() { | |
var d, rot, w; | |
if (this.target) { | |
v2.set(this.target.pos, this.targetPos); | |
} | |
if (this.origin) { | |
w = this.origin.weapons[this.turretNum || 0]; | |
if (w) { | |
v2.set(w.worldPos, this.pos); | |
} | |
} | |
v2.sub(this.targetPos, this.pos, _offset); | |
rot = v2.angle(_offset); | |
d = v2.mag(_offset) / this.drawLength; | |
v2.scale(_offset, .5); | |
v2.add(_offset, this.pos); | |
if (w) { | |
w.rot = rot; | |
} | |
return baseAtlas.drawSprite(this.image, _offset, [this.size[0], d], rot, this.color, this.z + 40); | |
}; | |
types.Debree.prototype.draw = function() { | |
var fade; | |
if (this.dead) { | |
return; | |
} | |
fade = this.life / this.maxLife; | |
this.color[3] = Math.floor((1 - fade) * 255); | |
return baseAtlas.drawSprite(this.image, this.pos, this.size, this.rot, this.color, 50 - this.life); | |
}; | |
// unit.js changes | |
types.Unit.prototype.createDebree = function() { | |
var exp, j, len, part, ref, results; | |
ref = this.parts; | |
results = []; | |
for (j = 0, len = ref.length; j < len; j++) { | |
part = ref[j]; | |
if (Math.random() < .5 || part.decal) { | |
continue; | |
} | |
exp = new types.Debree(); | |
if (part.stripe) { | |
exp.image = "parts/gray-" + part.image; | |
} else { | |
exp.image = "parts/" + part.image; | |
} | |
exp.z = this.z + rand() * 10 - 5; | |
exp.pos = [0, 0]; | |
part.computeWorldPos(); | |
v2.set(part.worldPos, exp.pos); | |
v2.set(this.vel, exp.vel); | |
exp.vel[0] += (part.worldPos[0] - this.pos[0]) * .1 + rand(); | |
exp.vel[1] += (part.worldPos[1] - this.pos[1]) * .1 + rand(); | |
exp.rot = this.rot; | |
exp.vrot = rand(); | |
results.push(intp.particles[exp.id] = exp); | |
} | |
return results; | |
}; | |
types.Unit.prototype.draw = function() { | |
var a, color, j, l, len, len1, part, partNum, r, ref, ref1, s, t, value; | |
if (this.dead) { | |
return; | |
} | |
ref = this.parts; | |
for (j = 0, len = ref.length; j < len; j++) { | |
part = ref[j]; | |
if (typeof part.preDraw === "function") { | |
part.preDraw(); | |
} | |
part.computeWorldPos(); | |
} | |
if (this.maxShield > 0) { | |
s = this.warpIn * 2 - 1; | |
if (s > 0) { | |
color = [this.color[0], this.color[1], this.color[2], 255 * this.shield / this.maxShield * s]; | |
r = (this.radius + 40) / 255; | |
baseAtlas.drawSprite("img/point02.png", this.pos, [r, r], 0, color, this.z); | |
} | |
} | |
if (this.warpIn < 1) { | |
this.warpIn += 1 / 60; | |
} | |
ref1 = this.parts; | |
for (partNum = l = 0, len1 = ref1.length; l < len1; partNum = ++l) { | |
part = ref1[partNum]; | |
value = part.pos[1] / 700 - .5 + this.warpIn; | |
if (value > 0) { | |
part.draw(); | |
} else if (value > -0.2) { | |
a = -Math.sin(value / Math.PI * 50); | |
baseAtlas.drawSprite("img/unitBar/fire02.png", part.worldPos, [1, 1], 0, [255, 255, 255, 255 * a]); | |
continue; | |
} | |
} | |
if (this.energy / this.storeEnergy < .05) { | |
t = Math.abs(Math.sin(Date.now() / 300)); | |
baseAtlas.drawSprite("img/unitBar/energy1.png", [this.pos[0], this.pos[1] + 100 + this.radius], [1, 1], 0, [255, 100, 100, t * 200], this.z + 20); | |
} | |
if (control.debug && (this._pos2 != null) && this._pos) { | |
a = 16; | |
_offset[0] = this._pos2[0] + (this._pos[0] - this._pos2[0]) * a; | |
_offset[1] = this._pos2[1] + (this._pos[1] - this._pos2[1]) * a; | |
baseAtlas.drawSprite("img/pip1.png", this._pos, [1, 1], 0, [0, 255, 0, 255]); | |
baseAtlas.drawSprite("img/pip1.png", this.pos, [1, 1], 0); | |
return baseAtlas.drawSprite("img/pip1.png", this._pos2, [1, 1], 0, [255, 0, 0, 255]); | |
} | |
}; | |
Part.prototype.draw = function() { | |
var alpha, angle, c, flip, id, num, numParts, rot, showDamage, t; | |
if (this.pos[0] < 0 && this.flip) { | |
flip = -1; | |
} else { | |
flip = 1; | |
} | |
if (this.gimble) { | |
rot = Math.PI + this.rot; | |
} else { | |
rot = Math.PI + this.unit.rot; | |
} | |
angle = Math.PI * this.dir / 2; | |
rot += angle; | |
if (this.canShowDamage && this.image === this.orignalImage) { | |
numParts = this.unit.parts.length; | |
id = this.unit.id; | |
num = this.partNum % numParts; | |
showDamage = num / numParts > this.unit.hp / this.unit.maxHP; | |
if (showDamage) { | |
t = (this.partNum + id) % 3 + 1; | |
this.image = this.orignalImage.replace(".png", ".d" + t + ".png"); | |
} | |
} | |
if (this.northWest) { | |
if (this.dir === 0 || this.dir === 2) { | |
this.image = this.orignalImage; | |
} else { | |
this.image = this.orignalImage.replace("N", "W"); | |
} | |
} | |
alpha = 255; | |
if (this.unit.cloakFade > 0) { | |
alpha = 255 - this.unit.cloakFade * 200; | |
} | |
if (this.ghostCopy) { | |
alpha = 170; | |
} | |
this.z = (function(_this) { | |
return function(arg) { | |
var x, y; | |
x = arg[0], y = arg[1]; | |
return (_this.unit.radius - v2.distance([x, y], _this.unit.pos)) / 3 + _this.unit.z * 50; | |
}; | |
})(this); | |
if (this.stripe) { | |
baseAtlas.drawSprite("parts/gray-" + this.image, this.worldPos, [flip, -1], rot, [255, 255, 255, alpha], (function(_this) { | |
return function(pos) { | |
return _this.z(pos) + 1; | |
}; | |
})(this)); | |
c = this.unit.color; | |
return baseAtlas.drawSprite("parts/red-" + this.image, this.worldPos, [flip, -1], rot, [c[0], c[1], c[2], alpha], (function(_this) { | |
return function(pos) { | |
return _this.z(pos) + 1; | |
}; | |
})(this)); | |
} else if (this.decal) { | |
c = this.unit.color; | |
return baseAtlas.drawSprite("parts/" + this.image, this.worldPos, [flip / this.scale, -1 / this.scale], rot, [c[0], c[1], c[2], alpha * this.opacity], (function(_this) { | |
return function(pos) { | |
return _this.z(pos) + 1; | |
}; | |
})(this)); | |
} else if (this.weapon) { | |
return baseAtlas.drawSprite("parts/" + this.image, this.worldPos, [flip, -1], rot, [255, 255, 255, alpha], (function(_this) { | |
return function() { | |
return _this.z(_this.worldPos) + 5; | |
}; | |
})(this)); | |
} else { | |
return baseAtlas.drawSprite("parts/" + this.image, this.worldPos, [flip, -1], rot, [255, 255, 255, alpha], this.z); | |
} | |
}; | |
Engine.prototype.preDraw = function() { | |
var ref; | |
if (v2.mag(this.unit.vel) > 1) { | |
if (!this.trail) { | |
this.trail = new Trail(this.unit.id, this.trailSize, this.trailTime, this.unit.color, this.unit.z * 20); | |
} | |
if ((ref = this.trail) != null) { | |
ref.grow(this.worldPos); | |
} | |
this.trail.color = this.unit.color; | |
return this.trail.z = this.unit.z * 20 - 3; | |
} | |
}; | |
parts.JumpEngine.prototype.draw = function() { | |
parts.JumpEngine.prototype.__proto__.draw.call(this); | |
if (this.working) { | |
return baseAtlas.drawSprite("parts/engineJumpPip.png", this.worldPos, [1, 1], this.unit.rot, [255, 255, 255, 255], (function(_this) { | |
return function(pos) { | |
return _this.z(pos) + 3; | |
}; | |
})(this)); | |
} | |
}; | |
parts.RingTurret.prototype.draw = function() { | |
if (this.working) { | |
this.spin += .0010 * this.damage; | |
this.image = "turRing.png"; | |
} else { | |
this.spin += .0001 * this.damage; | |
this.image = "turRingReload.png"; | |
} | |
return baseAtlas.drawSprite("parts/" + this.image, this.worldPos, [1, 1], this.spin, [255, 255, 255, 255], (function(_this) { | |
return function() { | |
return (_this.unit.radius - v2.distance(_this.worldPos, _this.unit.pos)) / 3 + _this.unit.z * 50 + 5; | |
}; | |
})(this)); | |
}; |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment