mirror of
https://github.com/TerryCavanagh/VVVVVV.git
synced 2024-06-26 14:38:30 +02:00
72d018ea04
The android version just got a much needed update to fix some resolution issues on devices with cutouts. It turns out the mobile source was actually pretty out of date, like 3 versions out of date! This commit brings it up to date. All the changes have just been about keeping the game running on modern devices, though. The biggest change was adding the Starling library to the project, which made the game GPU powered and sped the whole thing up.
3129 lines
122 KiB
ActionScript
3129 lines
122 KiB
ActionScript
package{
|
|
import starling.display.*;
|
|
import starling.events.*;
|
|
import starling.textures.*;
|
|
import flash.geom.*;
|
|
import flash.net.*;
|
|
import starling.core.*;
|
|
import starling.text.BitmapFont;
|
|
import starling.text.TextField;
|
|
import starling.utils.AssetManager;
|
|
|
|
import flash.display.Bitmap;
|
|
import flash.display.BitmapData;
|
|
|
|
public class dwgraphicsclass {
|
|
public var screenwidth:int = 320;
|
|
public var screenheight:int = 240;
|
|
|
|
public var BUTTON_BLANK:int = 0;
|
|
public var BUTTON_MENU:int = 1;
|
|
public var BUTTON_BACK:int = 2;
|
|
public var BUTTON_TALK:int = 3;
|
|
public var BUTTON_USE:int = 4;
|
|
public var BUTTON_TELEPORT:int = 5;
|
|
public var BUTTON_GAMECENTER:int = 6;
|
|
public var BUTTON_CONTROLS:int = 7;
|
|
public var BUTTON_DPAD:int = 8;
|
|
|
|
public function init(_stage:Stage):void {
|
|
starstage = _stage;
|
|
starstage.touchable = false;
|
|
|
|
backbuffer = new RenderTexture(screenwidth, screenheight, false);
|
|
frontbuffer_meshbatch = new MeshBatch();
|
|
towerbufferforeground_meshbatch = new MeshBatch();
|
|
towerbufferbackground_meshbatch = new MeshBatch();
|
|
warpzonevertical_meshbatch = new MeshBatch();
|
|
warpzonehorizontal_meshbatch = new MeshBatch();
|
|
towerbufferstatic_meshbatch = new MeshBatch();
|
|
menubuffer = new RenderTexture(screenwidth, screenheight, false);
|
|
menubuffer_image = new Image(menubuffer);
|
|
menubuffer_image.touchable = false;
|
|
menubuffer_image.textureSmoothing = TextureSmoothing.NONE;
|
|
screenmenubuffer = new RenderTexture(screenwidth, screenheight, false);
|
|
screenmenubuffer_image = new Image(screenmenubuffer);
|
|
screenmenubuffer_image.touchable = false;
|
|
screenmenubuffer_image.textureSmoothing = TextureSmoothing.NONE;
|
|
|
|
screen = new Image(backbuffer);
|
|
screen.touchable = false;
|
|
screen.textureSmoothing = TextureSmoothing.BILINEAR;
|
|
smallscreen = new Image(backbuffer);
|
|
smallscreen.touchable = false;
|
|
smallscreen.textureSmoothing = TextureSmoothing.NONE;
|
|
starstage.addChild(screen);
|
|
|
|
tquad = new Quad(1, 1, RGB(255, 255, 255));
|
|
|
|
ttf = new TextField(320, 120, "");
|
|
ttf.touchable = false;
|
|
ttf.format.font = "c64";
|
|
ttf.format.color = 0xFFFFFF;
|
|
ttf.format.size = BitmapFont.NATIVE_SIZE;
|
|
ttf.format.horizontalAlign = "left";
|
|
ttf.format.verticalAlign = "top";
|
|
tposition = new Matrix();
|
|
|
|
//We initialise a few things
|
|
updatebackground = true;
|
|
tiles_rect=new Rectangle(0,0,8,8);
|
|
sprites_rect=new Rectangle(0,0,32,32);
|
|
bfont_rect=new Rectangle(0,0,8,8);
|
|
bfontmask_rect=new Rectangle(0,0,9,9);
|
|
bg_rect = new Rectangle(0, 0, 320, 240);
|
|
footerrect = new Rectangle(0, 230, 320, 10);
|
|
prect = new Rectangle(0, 0, 4, 4);
|
|
line_rect = new Rectangle();
|
|
tl = new Point(0, 0); tpoint = new Point(0, 0); trect = new Rectangle();
|
|
ct = new ColorTransform(0, 0, 0, 1, 255, 255, 255, 1); //Set to white
|
|
madpoint = new Point;
|
|
madrect = new Rectangle;
|
|
|
|
trinketcolset = false;
|
|
|
|
showcutscenebars = false;
|
|
cutscenebarspos = 0;
|
|
|
|
flipmode = false; setflipmode = false;
|
|
flipmatrix.scale(1, -1);
|
|
flipmatrix.translate(0, 240);
|
|
flipfontmatrix.scale(1, -1); flipfontmatrix.translate(0, 8);
|
|
flipfontmatrix2.scale(1, -1); flipfontmatrix2.translate(0, 9);
|
|
|
|
//Android optimisations
|
|
var tbg:Array = [0x19090A, 0x190C0A, 0x190F0A, 0x191309, 0x191609, 0x191909,
|
|
0x171909, 0x151909, 0x131909, 0x111909, 0x0F1909, 0x0E190C,
|
|
0x0D190F, 0x0B1813, 0x0A1816, 0x091819, 0x0A1519, 0x0C1219,
|
|
0x0E0F19, 0x100C19, 0x110919, 0x130919, 0x140919, 0x160919,
|
|
0x170919, 0x190919, 0x190916, 0x190913, 0x190910, 0x19090D];
|
|
for (i = 0; i < tbg.length; i++){
|
|
tower_bgcol.push(tbg[i]);
|
|
}
|
|
|
|
tbg = [0x0A0304, 0x0A0504, 0x0A0604, 0x0A0703, 0x0A0803, 0x0A0A03,
|
|
0x090A03, 0x080A03, 0x070A03, 0x070A03, 0x060A03, 0x050A05,
|
|
0x050A06, 0x040907, 0x040908, 0x03090A, 0x04080A, 0x05070A,
|
|
0x05060A, 0x06040A, 0x07030A, 0x07030A, 0x08030A, 0x08030A,
|
|
0x09030A, 0x0A030A, 0x0A0309, 0x0A0307, 0x0A0306, 0x0A0305];
|
|
for (i = 0; i < tbg.length; i++){
|
|
tower_bgdarkcol.push(tbg[i]);
|
|
}
|
|
|
|
//Background inits
|
|
for (i = 0; i < 50; i++) {
|
|
var s:Rectangle = new Rectangle(Math.random() * 320, Math.random() * 240, 2, 2);
|
|
var s2:int = 4+(Math.random()*4);
|
|
stars.push(s); starsspeed.push(s2);
|
|
|
|
var bb:Rectangle;
|
|
var bvx:int = 0; var bvy:int = 0;
|
|
if(Math.random()*100 > 50){
|
|
bvx = 9 - (Math.random() * 19); if (bvx > -6 && bvx < 6) bvx = 6;
|
|
bvx = bvx * 1.5;
|
|
bb = new Rectangle(Math.random() * 320, Math.random() * 240, 32, 12);
|
|
}else {
|
|
bvy = 9 - (Math.random() * 19); if (bvy > -6 && bvy < 6) bvy = 6;
|
|
bvy = bvy * 1.5;
|
|
bb = new Rectangle(Math.random() * 320, Math.random() * 240, 12, 32);
|
|
}
|
|
var bint:Number = 0.5 + ((Math.random() * 100) / 200);
|
|
backboxes.push(bb);
|
|
backboxvx.push(bvx); backboxvy.push(bvy);
|
|
backboxint.push(bint);
|
|
}
|
|
backboxrect = new Rectangle();
|
|
backoffset = 0; backgrounddrawn = false;
|
|
|
|
warpskip = 0;
|
|
warpfcol = 0x000000; warpbcol = 0x000000;
|
|
warprect = new Rectangle(0, 0, 0, 0);
|
|
|
|
spcol = 0; spcoldel = 0;
|
|
|
|
crewframe = 0; crewframedelay = 4;
|
|
menuoffset = 0; resumegamemode = false;
|
|
|
|
//Textboxes!
|
|
for (i = 0; i < 30; i++) {
|
|
var t:textboxclass = new textboxclass;
|
|
textbox.push(t);
|
|
}
|
|
ntextbox = 0;
|
|
|
|
//Fading stuff
|
|
for (i = 0; i < 15; i++) {
|
|
fadebars.push(0);
|
|
}
|
|
fadeamount = 0;
|
|
fademode = 0;
|
|
|
|
|
|
//var devicexres:int = int(Capabilities.screenResolutionX);
|
|
//var deviceyres:int = int(Capabilities.screenResolutionY);
|
|
//updatescreen(starstage.stageWidth, starstage.stageHeight);
|
|
|
|
//Starling.current.showStats = true;
|
|
}
|
|
|
|
public function initbuttonstuff():void {
|
|
button_image_width.push(0); button_image_height.push(0);
|
|
button_image_width.push(0); button_image_height.push(0);
|
|
button_image_width.push(0); button_image_height.push(0);
|
|
button_image_width.push(0); button_image_height.push(0);
|
|
button_image.push(new Image(button_texture[0]));
|
|
button_image.push(new Image(button_texture[1]));
|
|
button_image.push(new Image(button_texture[2]));
|
|
button_image.push(new Image(button_texture[3]));
|
|
button_image[0].touchable = false; button_image[0].textureSmoothing = TextureSmoothing.NONE;
|
|
button_image[1].touchable = false; button_image[1].textureSmoothing = TextureSmoothing.NONE;
|
|
button_image[2].touchable = false; button_image[2].textureSmoothing = TextureSmoothing.NONE;
|
|
button_image[3].touchable = false; button_image[3].textureSmoothing = TextureSmoothing.NONE;
|
|
|
|
for (i = 0; i < 10; i++) {
|
|
buttonlerp.push(int(0));
|
|
buttonstate.push(int(0));
|
|
currentbuttontype.push(int(-1));
|
|
newbuttontype.push(int(-1));
|
|
buttonframe.push(int(-1));
|
|
}
|
|
|
|
buttonactive.push(false);
|
|
buttonactive.push(false);
|
|
buttonactive.push(false);
|
|
buttonactive.push(false);
|
|
buttonhighlight.push(0); buttonhighlight.push(0); buttonhighlight.push(0); buttonhighlight.push(0);
|
|
buttonpos.push(new Point(0, 0)); buttonpos.push(new Point(0, 0));
|
|
buttonpos.push(new Point(0, 0)); buttonpos.push(new Point(0, 0));
|
|
//So, 0-4 are buffers that can be overwritten. 5+ contains graphics for each button.
|
|
|
|
initbuttonpositions();
|
|
|
|
drawonscreenbutton(0, -1);
|
|
drawonscreenbutton(1, -1);
|
|
drawonscreenbutton(2, -1);
|
|
drawonscreenbutton(3, -1);
|
|
starstage.addChild(button_image[0]);
|
|
starstage.addChild(button_image[1]);
|
|
starstage.addChild(button_image[2]);
|
|
starstage.addChild(button_image[3]);
|
|
|
|
buttonsready = true;
|
|
}
|
|
|
|
public function updatescreen(w:int, h:int):void {
|
|
starstage.stageWidth = w;
|
|
starstage.stageHeight = h;
|
|
|
|
Starling.current.viewPort = new Rectangle(0, 0, w, h);
|
|
|
|
// set rectangle dimensions for viewPort:
|
|
var stretchscalex:Number = w / screenwidth;
|
|
var stretchscaley:Number = h / screenheight;
|
|
screensizemultiplier = Math.min(stretchscalex, stretchscaley);
|
|
|
|
//Never mess with starling's viewport for VVVVVV - instead, mess with the
|
|
//screen image
|
|
screen.width = screenwidth * screensizemultiplier;
|
|
screen.height = screenheight * screensizemultiplier;
|
|
|
|
screen.x = (w / 2) - (screenwidth * screensizemultiplier / 2);
|
|
}
|
|
|
|
public function initbuttonpositions():void {
|
|
devicex = device.xres;
|
|
devicey = device.yres;
|
|
|
|
buttonsize = devicey / (32 / 3);
|
|
buttonyspacing = buttonsize / 3;
|
|
buttonxspacing = (buttonsize * 3) / 3;
|
|
|
|
button_image[0].width = (buttonsize * 46) / 15; button_image[0].height = buttonsize;
|
|
button_image[1].width = (buttonsize * 46) / 15; button_image[1].height = buttonsize;
|
|
button_image[2].width = (buttonsize * 5) / 3; button_image[2].height = (buttonsize * 5) / 3;
|
|
button_image[3].width = (buttonsize * 5) / 3; button_image[3].height = (buttonsize * 5) / 3;
|
|
|
|
button_image_width[0] = int(button_image[0].width);
|
|
button_image_width[1] = int(button_image[1].width);
|
|
button_image_width[2] = int(button_image[2].width);
|
|
button_image_width[3] = int(button_image[3].width);
|
|
button_image_height[0] = int(button_image[0].height);
|
|
button_image_height[1] = int(button_image[1].height);
|
|
button_image_height[2] = int(button_image[2].height);
|
|
button_image_height[3] = int(button_image[3].height);
|
|
|
|
|
|
buttonydiff = button_image_height[2] / 2;
|
|
|
|
button_image[0].x = devicex + 1;
|
|
button_image[0].y = 0;
|
|
buttonpos[0].setTo(button_image[0].x, button_image[0].y);
|
|
|
|
button_image[1].x = 0;
|
|
button_image[1].y = 0;
|
|
buttonpos[1].setTo(button_image[1].x, button_image[1].y);
|
|
|
|
button_image[2].x = (buttonxspacing / 2);
|
|
button_image[2].y = devicey - buttonsize-buttonyspacing - buttonydiff;
|
|
buttonpos[2].setTo(button_image[2].x, button_image[2].y);
|
|
|
|
button_image[3].x = (buttonxspacing/2) + buttonsize + buttonxspacing ;
|
|
button_image[3].y = devicey - buttonsize-buttonyspacing;
|
|
buttonpos[3].setTo(button_image[3].x, button_image[3].y);
|
|
}
|
|
|
|
public function mobile_changebutton(t:int):void {
|
|
if (newbuttontype[0] != t) {
|
|
if (currentbuttontype[0] != t) {
|
|
newbuttontype[0] = t;
|
|
buttonstate[0] = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
public function mobile_changeleftbutton(t:int):void {
|
|
if (newbuttontype[1] != t) {
|
|
if (currentbuttontype[1] != t) {
|
|
newbuttontype[1] = t;
|
|
buttonstate[1] = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
public function mobile_hidearrows():void {
|
|
if (newbuttontype[2] != BUTTON_BLANK) {
|
|
if (currentbuttontype[2] != BUTTON_BLANK) {
|
|
newbuttontype[2] = BUTTON_BLANK;
|
|
buttonstate[2] = 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
public function mobile_showarrows(t:int):void {
|
|
if (t == 2) {
|
|
if (newbuttontype[2] != BUTTON_DPAD) {
|
|
if (currentbuttontype[2] != BUTTON_DPAD) {
|
|
newbuttontype[2] = BUTTON_DPAD;
|
|
buttonstate[2] = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public function drawbutton(game:gameclass, help:helpclass):void {
|
|
//Called every frame, this function controls what buttons appear and when,
|
|
//and lerps them in and out in a nice way.
|
|
//buttonstate[0]:
|
|
// 0 - Normal, slide in if not in
|
|
// 1 - Sliding out, change to new button state
|
|
for (i = 0; i < 3; i++){
|
|
switch(buttonstate[i]) {
|
|
case 0:
|
|
if (buttonlerp[i] > 60) {
|
|
buttonlerp[i] = 60;
|
|
}
|
|
if (buttonlerp[i] > 0) {
|
|
buttonlerp[i] -= 20;
|
|
if (buttonlerp[i] < 0) {
|
|
buttonlerp[i] = 0;
|
|
}
|
|
}
|
|
break;
|
|
case 1:
|
|
if (buttonlerp[i] < 100) {
|
|
buttonlerp[i] += 20;
|
|
}
|
|
if (buttonlerp[i] >= 60) buttonlerp[i] = 100;
|
|
|
|
if (buttonlerp[i] >= 100) {
|
|
buttonlerp[i] = 100;
|
|
buttonstate[i] = 0;
|
|
currentbuttontype[i] = newbuttontype[i];
|
|
newbuttontype[i] = -1;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
switch(currentbuttontype[2]) {
|
|
case BUTTON_BLANK:
|
|
changebuttonframe(2, -1);
|
|
changebuttonframe(3, -1);
|
|
break;
|
|
case BUTTON_DPAD:
|
|
changebuttonframe(2, 11);
|
|
changebuttonframe(3, 12);
|
|
|
|
if (game.press_left) {
|
|
changebuttonpos(2, (buttonxspacing/2), devicey - buttonsize-buttonyspacing - buttonydiff+10);
|
|
}else{
|
|
changebuttonpos(2, (buttonxspacing/2), devicey - buttonsize-buttonyspacing - buttonydiff);
|
|
}
|
|
|
|
if (game.press_right) {
|
|
changebuttonpos(3, (buttonxspacing/2) + buttonsize + buttonxspacing, devicey - buttonsize-buttonyspacing - buttonydiff+10);
|
|
}else{
|
|
changebuttonpos(3, (buttonxspacing/2) + buttonsize + buttonxspacing, devicey - buttonsize-buttonyspacing - buttonydiff);
|
|
}
|
|
break;
|
|
}
|
|
|
|
switch(currentbuttontype[1]) {
|
|
case BUTTON_BLANK:
|
|
//Blank
|
|
changebuttonframe(1, -1);
|
|
changebuttonpos(1, 0 - ((button_image_width[1] * (buttonlerp[1])) / 100), 0);
|
|
break;
|
|
case BUTTON_CONTROLS:
|
|
//Controls button
|
|
if (game.menupage >= 30) {
|
|
changebuttonframe(1, 9);
|
|
}else{
|
|
changebuttonframe(1, 8);
|
|
}
|
|
if (flipmode) {
|
|
changebuttonpos(1, 0 - ((button_image_width[1] * (buttonlerp[1])) / 100), devicey - buttonyspacing - button_image_height[1]);
|
|
}else {
|
|
changebuttonpos(1, 0 - ((button_image_width[1] * (buttonlerp[1])) / 100), buttonyspacing);
|
|
}
|
|
|
|
break;
|
|
case BUTTON_GAMECENTER:
|
|
changebuttonframe(1, 10);
|
|
changebuttonpos(1, 0 - ((button_image_width[1] * (buttonlerp[1])) / 100), 5);
|
|
break;
|
|
}
|
|
|
|
switch(currentbuttontype[0]) {
|
|
case BUTTON_BLANK:
|
|
//Blank
|
|
changebuttonframe(0, -1);
|
|
changebuttonpos(0, devicex - ((button_image_width[0] * (100-buttonlerp[0])) / 100), 0);
|
|
break;
|
|
case BUTTON_MENU:
|
|
//Menu button
|
|
changebuttonframe(0, 0);
|
|
changebuttonpos(0, devicex - ((button_image_width[0] * (100-buttonlerp[0])) / 100), 0);
|
|
break;
|
|
case BUTTON_BACK:
|
|
//Back button
|
|
changebuttonframe(0, 1);
|
|
if (flipmode) {
|
|
changebuttonpos(0, devicex - ((button_image_width[0] * (100 - buttonlerp[0])) / 100), devicey - buttonyspacing - button_image_height[0]);
|
|
}else{
|
|
changebuttonpos(0, devicex - ((button_image_width[0] * (100 - buttonlerp[0])) / 100), buttonyspacing);
|
|
}
|
|
break;
|
|
case BUTTON_USE:
|
|
//Use button
|
|
if (help.slowsine % 16 > 8) {
|
|
changebuttonframe(0, 4);
|
|
}else {
|
|
changebuttonframe(0, 5);
|
|
}
|
|
changebuttonpos(0, devicex - ((button_image_width[0] * (100-buttonlerp[0])) / 100), buttonyspacing);
|
|
break;
|
|
case BUTTON_TALK:
|
|
//Talk button
|
|
if (help.slowsine % 16 > 8) {
|
|
changebuttonframe(0, 2);
|
|
}else {
|
|
changebuttonframe(0, 3);
|
|
}
|
|
changebuttonpos(0, devicex - ((button_image_width[0] * (100-buttonlerp[0])) / 100), buttonyspacing);
|
|
break;
|
|
case BUTTON_TELEPORT:
|
|
//Teleport button
|
|
if (help.slowsine % 16 > 8) {
|
|
changebuttonframe(0, 6);
|
|
}else {
|
|
changebuttonframe(0, 7);
|
|
}
|
|
changebuttonpos(0, devicex - ((button_image_width[0] * (100-buttonlerp[0])) / 100), buttonyspacing);
|
|
break;
|
|
}
|
|
}
|
|
|
|
public function addbutton(imgname:String):void {
|
|
var sourcetexture:Texture = starlingassets.getTexture(imgname);
|
|
var tmpimage:Image = new Image(sourcetexture);
|
|
|
|
var newtexture:RenderTexture = new RenderTexture(int(tmpimage.texture.width), int(tmpimage.texture.height));
|
|
newtexture.draw(tmpimage);
|
|
|
|
sourcetexture.dispose();
|
|
tmpimage.dispose();
|
|
|
|
button_texture.push(newtexture);
|
|
}
|
|
|
|
public function drawonscreenbutton(t:int, t2:int):void {
|
|
//Draw button t with frame t2
|
|
if (t2 == -1) {
|
|
button_texture[t].clear();
|
|
}
|
|
if (buttonframe[t] != t2) {
|
|
buttonframe[t] = t2;
|
|
button_texture[t].clear();
|
|
var tempimg:Image = new Image(button_texture[4 + t2]);
|
|
button_texture[t].draw(tempimg);
|
|
}
|
|
}
|
|
|
|
public function changebuttonframe(t:int, t2:int):void {
|
|
//Draw button t with frame t2
|
|
if (buttonframe[t] != t2) {
|
|
buttonframe[t] = t2;
|
|
if (t2 == -1) {
|
|
button_texture[t].clear();
|
|
}else{
|
|
button_texture[t].clear();
|
|
var tempimg:Image = new Image(button_texture[4 + t2]);
|
|
button_texture[t].draw(tempimg);
|
|
}
|
|
}
|
|
}
|
|
|
|
public function changebuttonpos(t:int, xp:int, yp:int):void {
|
|
button_image[t].x = xp;
|
|
button_image[t].y = yp;
|
|
}
|
|
|
|
public function changebuttonxpos(t:int, xp:int):void {
|
|
button_image[t].x = xp;
|
|
}
|
|
|
|
public function showarrows():void {
|
|
if (buttonactive[0] == false) {
|
|
buttonhighlight[0] = 120;
|
|
buttonactive[0] = true;
|
|
starstage.addChild(button_image[0]);
|
|
starstage.addChild(button_image[1]);
|
|
starstage.addChild(button_image[2]);
|
|
}
|
|
}
|
|
|
|
public function hidearrows():void {
|
|
if (buttonactive[0] == true) {
|
|
buttonactive[0] = false;
|
|
starstage.removeChild(button_image[0]);
|
|
starstage.removeChild(button_image[1]);
|
|
starstage.removeChild(button_image[2]);
|
|
}
|
|
}
|
|
|
|
public function drawspritesetcol(x:int, y:int, t:int, c:int, help:helpclass):void {
|
|
setcol(c, help);
|
|
sprites[t].color = ct.color;
|
|
tposition.identity();
|
|
tposition.translate(x, y);
|
|
backbuffer.draw(sprites[t], tposition);
|
|
}
|
|
|
|
public function makeentcolourarray():void {
|
|
var sourcetexture:Texture = starlingassets.getTexture("entcolours");
|
|
for (var j:int = 0; j < 60; j++) {
|
|
for (var i:int = 0; i < 12; i++) {
|
|
var tiletex:Texture = Texture.fromTexture(sourcetexture, new Rectangle(i * 8, j * 8, 8, 8));
|
|
var t:Image = new Image(tiletex);
|
|
t.textureSmoothing = TextureSmoothing.NONE;
|
|
t.touchable = false;
|
|
entcolours.push(t);
|
|
}
|
|
}
|
|
}
|
|
|
|
public function maketilearray():void {
|
|
var sourcetexture:Texture = starlingassets.getTexture("tiles");
|
|
for (var j:int = 0; j < 30; j++) {
|
|
for (var i:int = 0; i < 40; i++) {
|
|
var tiletex:Texture = Texture.fromTexture(sourcetexture, new Rectangle(i * 8, j * 8, 8, 8));
|
|
var tile:Image = new Image(tiletex);
|
|
tile.textureSmoothing = TextureSmoothing.NONE;
|
|
tile.touchable = false;
|
|
tiles.push(tile);
|
|
}
|
|
}
|
|
}
|
|
|
|
public function maketile2array():void {
|
|
var sourcetexture:Texture = starlingassets.getTexture("tiles2");
|
|
for (var j:int = 0; j < 30; j++) {
|
|
for (var i:int = 0; i < 40; i++) {
|
|
var tiletex:Texture = Texture.fromTexture(sourcetexture, new Rectangle(i * 8, j * 8, 8, 8));
|
|
var tile:Image = new Image(tiletex);
|
|
tile.textureSmoothing = TextureSmoothing.NONE;
|
|
tile.touchable = false;
|
|
tiles2.push(tile);
|
|
}
|
|
}
|
|
}
|
|
|
|
public function maketile3array():void {
|
|
var sourcetexture:Texture = starlingassets.getTexture("tiles3");
|
|
for (var j:int = 0; j < 30; j++) {
|
|
for (var i:int = 0; i < 30; i++) {
|
|
var tiletex:Texture = Texture.fromTexture(sourcetexture, new Rectangle(i * 8, j * 8, 8, 8));
|
|
var tile:Image = new Image(tiletex);
|
|
tile.textureSmoothing = TextureSmoothing.NONE;
|
|
tile.touchable = false;
|
|
tiles3.push(tile);
|
|
}
|
|
}
|
|
}
|
|
|
|
public function makespritearray():void {
|
|
var sourcetexture:Texture = starlingassets.getTexture("sprites");
|
|
for (var j:int = 0; j < 16; j++) {
|
|
for (var i:int = 0; i < 12; i++) {
|
|
var tiletex:Texture = Texture.fromTexture(sourcetexture, new Rectangle(i * 32, j * 32, 32, 32));
|
|
var t:Image = new Image(tiletex);
|
|
t.textureSmoothing = TextureSmoothing.NONE;
|
|
t.touchable = false;
|
|
sprites.push(t);
|
|
}
|
|
}
|
|
|
|
//Sprites also need to load flash bitmapdatas, which are used for pixel perfect hittests
|
|
var b:Bitmap = new img_bitmapsprites();
|
|
var buffer:BitmapData = b.bitmapData;
|
|
|
|
for (j = 0; j < 16; j++) {
|
|
for (i = 0; i < 12; i++) {
|
|
var tb:BitmapData = new BitmapData(32, 32, true, 0x000000);
|
|
var temprect:Rectangle = new Rectangle(i * 32, j * 32, 32, 32);
|
|
tb.copyPixels(buffer, temprect, tl);
|
|
sprites_bitmap.push(tb);
|
|
}
|
|
}
|
|
}
|
|
|
|
public function makeflipspritearray():void {
|
|
var sourcetexture:Texture = starlingassets.getTexture("flipsprites");
|
|
for (var j:int = 0; j < 16; j++) {
|
|
for (var i:int = 0; i < 12; i++) {
|
|
var tiletex:Texture = Texture.fromTexture(sourcetexture, new Rectangle(i * 32, j * 32, 32, 32));
|
|
var t:Image = new Image(tiletex);
|
|
t.textureSmoothing = TextureSmoothing.NONE;
|
|
t.touchable = false;
|
|
flipsprites.push(t);
|
|
}
|
|
}
|
|
|
|
|
|
//Sprites also need to load flash bitmapdatas, which are used for pixel perfect hittests
|
|
var b:Bitmap = new img_bitmapflipsprites();
|
|
var buffer:BitmapData = b.bitmapData;
|
|
|
|
for (j = 0; j < 16; j++) {
|
|
for (i = 0; i < 12; i++) {
|
|
var tb:BitmapData = new BitmapData(32, 32, true, 0x000000);
|
|
var temprect:Rectangle = new Rectangle(i * 32, j * 32, 32, 32);
|
|
tb.copyPixels(buffer, temprect, tl);
|
|
flipsprites_bitmap.push(tb);
|
|
}
|
|
}
|
|
}
|
|
|
|
public function maketelearray():void {
|
|
var sourcetexture:Texture = starlingassets.getTexture("teleporter");
|
|
for (var i:int = 0; i < 10; i++) {
|
|
var tiletex:Texture = Texture.fromTexture(sourcetexture, new Rectangle(i * 96, j * 96, 96, 96));
|
|
var t:Image = new Image(tiletex);
|
|
t.textureSmoothing = TextureSmoothing.NONE;
|
|
t.touchable = false;
|
|
tele.push(t);
|
|
}
|
|
}
|
|
|
|
public function drawmobilebutton(game:gameclass, xp:int, yp:int, wp:int, hp:int, t:String, cr:int, cg:int, cb:int, xoff:int = -8, yoff:int = -10):void {
|
|
xp = xp + xoff;
|
|
yp = yp + yoff;
|
|
drawfillrect(xp + 4, yp + 4, wp, hp, cr * 0.25, cg * 0.25, cb * 0.25);
|
|
drawfillrect(xp, yp, wp, hp, cr, cg, cb);
|
|
drawfillrect(xp + 2, yp + 2, wp - 4, hp - 4, cr * 0.75, cg * 0.75, cb * 0.75);
|
|
xp = xp + (wp / 2) - (t.length * 4);
|
|
print(xp, yp + 9, t, 255, 255, 255);
|
|
}
|
|
|
|
public function drawmenu(game:gameclass, cr:int, cg:int, cb:int, help:helpclass, division:int = 30):void {
|
|
if (game.mobilemenu) {
|
|
for (i = 0; i < game.nummenuoptions; i++) {
|
|
/*
|
|
if (i == game.currentmenuoption) {
|
|
//Draw it highlighted
|
|
if (game.menuoptionsactive[i]) {
|
|
tempstring = game.menuoptions[i]; tempstring = "[ " + tempstring.toUpperCase() + " ]";
|
|
print(110 + (i * division) - 16 +game.menuxoff, 140 + (i * 12) +game.menuyoff, tempstring, cr, cg, cb);
|
|
}else {
|
|
tempstring = game.menuoptions[i]; tempstring = "[ " + tempstring + " ]";
|
|
//Draw it in gray
|
|
print(110 + (i * division) - 16 +game.menuxoff, 140 + (i * 12)+game.menuyoff, tempstring, 128, 128, 128);
|
|
}
|
|
}else {
|
|
*/
|
|
//Draw it normally
|
|
if (game.menuoptionslayout[i] == 0) {
|
|
//Normal Buttons
|
|
if (game.menuoptionsactive[i]) {
|
|
drawfillrect(160 - 70 + 4, 140 + (i * b_gap) + game.menuyoff - 6 + 4, 140, b_size, cr*0.25, cg*0.25, cb*0.25);
|
|
drawfillrect(160 - 70, 140 + (i * b_gap) + game.menuyoff - 6, 140, b_size, cr, cg, cb);
|
|
drawfillrect(160 - 70 + 2, 140 + (i * b_gap) + game.menuyoff - 6 + 2, 140 - 4, b_size - 4, cr*0.75, cg*0.75, cb*0.75);
|
|
print(110 + (i * division) +game.menuxoff, 140 + (i * b_gap) + game.menuyoff+3, game.menuoptions[i], 255, 255, 255, true);
|
|
}else {
|
|
drawfillrect(160 - 70 + 4, 140 + (i * b_gap) + game.menuyoff - 6 + 4, 140, b_size, 128*0.25, 128*0.25, 128*0.25);
|
|
drawfillrect(160 - 70, 140 + (i * b_gap) + game.menuyoff - 6, 140, b_size, 128, 128, 128);
|
|
drawfillrect(160 - 70 + 2, 140 + (i * b_gap) + game.menuyoff - 6 + 2, 140 - 4, b_size - 4, 128*0.75, 128*0.75, 128*0.75);
|
|
print(110 + (i * division) +game.menuxoff, 140 + (i * b_gap) + game.menuyoff+3, "LOCKED", 255, 255, 255, true);
|
|
}
|
|
}else if (game.menuoptionslayout[i] == 1) {
|
|
//Super big button for main menu play
|
|
drawfillrect(160 - 70 + 4, 140 + (i * b_gap) -10+ game.menuyoff - 6 + 4, 140, b_size*2, cr*0.25, cg*0.25, cb*0.25);
|
|
drawfillrect(160 - 70, 140 + (i * b_gap)-10 + game.menuyoff - 6, 140, b_size*2, cr, cg, cb);
|
|
drawfillrect(160 - 70 + 2, 140 + (i * b_gap)-10 + game.menuyoff - 6 + 2, 140 - 4, (b_size*2) - 4, cr*0.75, cg*0.75, cb*0.75);
|
|
bigprint(110 + (i * division) +game.menuxoff, 140 + (i * b_gap) -10 + game.menuyoff + 10, game.menuoptions[i], 255, 255, 255, true);
|
|
}else if (game.menuoptionslayout[i] == 2) {
|
|
//Main menu: Player levels and super gravitron
|
|
if (game.menuoptionsactive[i]) {
|
|
drawfillrect(160 - 70 + 4, 140 + (i * b_gap)+20 + game.menuyoff - 6 + 4, 140, b_size, cr*0.25, cg*0.25, cb*0.25);
|
|
drawfillrect(160 - 70, 140 + (i * b_gap)+20 + game.menuyoff - 6, 140, b_size, cr, cg, cb);
|
|
drawfillrect(160 - 70 + 2, 140 + (i * b_gap) +20+ game.menuyoff - 6 + 2, 140 - 4, b_size - 4, cr*0.75, cg*0.75, cb*0.75);
|
|
print(110 + (i * division) +game.menuxoff, 140 + (i * b_gap) + 20 + game.menuyoff+3, game.menuoptions[i], 255, 255, 255, true);
|
|
}else {
|
|
drawfillrect(160 - 70 + 4, 140 + (i * b_gap)+20 + game.menuyoff - 6 + 4, 140, 20, 128*0.25, 128*0.25, 128*0.25);
|
|
drawfillrect(160 - 70, 140 + (i * b_gap)+20 + game.menuyoff - 6, 140, 20, 128, 128, 128);
|
|
drawfillrect(160 - 70 + 2, 140 + (i * b_gap) +20+ game.menuyoff - 6 + 2, 140 - 4, 20 - 4, 128*0.75, 128*0.75, 128*0.75);
|
|
print(110 + (i * division) +game.menuxoff, 140 + (i * b_gap) + 20 + game.menuyoff+3, "LOCKED", 255, 255, 255, true);
|
|
}
|
|
}else if (game.menuoptionslayout[i] == 3) {
|
|
//Back Button
|
|
drawfillrect(-4, 230 - 6 + 4, 70, b_size, cr*0.10, cg*0.10, cb*0.10);
|
|
drawfillrect(-8, 230 - 6, 70, b_size, cr*0.5, cg*0.5, cb*0.5);
|
|
drawfillrect(-8+2, 230 - 6 + 2, 70 - 4, b_size - 4, cr*0.4, cg*0.4, cb*0.4);
|
|
print(8, 230, game.menuoptions[i], 196, 196, 196);
|
|
}else if (game.menuoptionslayout[i] == 4) {
|
|
//Normal Buttons except wider for longer text
|
|
if (game.menuoptionsactive[i]) {
|
|
drawfillrect(160 - 90 + 4, 140 + (i * b_gap) + game.menuyoff - 6 + 4, 180, b_size, cr*0.25, cg*0.25, cb*0.25);
|
|
drawfillrect(160 - 90, 140 + (i * b_gap) + game.menuyoff - 6, 180, b_size, cr, cg, cb);
|
|
drawfillrect(160 - 90 + 2, 140 + (i * b_gap) + game.menuyoff - 6 + 2, 180 - 4, b_size - 4, cr*0.75, cg*0.75, cb*0.75);
|
|
print(110 + (i * division) +game.menuxoff, 140 + (i * b_gap) + game.menuyoff+3, game.menuoptions[i], 255, 255, 255, true);
|
|
}else {
|
|
drawfillrect(160 - 90 + 4, 140 + (i * b_gap) + game.menuyoff - 6 + 4, 180, b_size, 128*0.25, 128*0.25, 128*0.25);
|
|
drawfillrect(160 - 90, 140 + (i * b_gap) + game.menuyoff - 6, 180, b_size, 128, 128, 128);
|
|
drawfillrect(160 - 90 + 2, 140 + (i * b_gap) + game.menuyoff - 6 + 2, 180 - 4, b_size - 4, 128*0.75, 128*0.75, 128*0.75);
|
|
print(110 + (i * division) +game.menuxoff, 140 + (i * b_gap) + game.menuyoff+3, "LOCKED", 255, 255, 255, true);
|
|
}
|
|
}else if (game.menuoptionslayout[i] == 5) {
|
|
//Time trial button, left
|
|
|
|
if (game.menuoptionsactive[i]) {
|
|
drawfillrect(10, 140 + (i * 68) -10+ game.menuyoff - 6 + 4, 140, 40, cr*0.25, cg*0.25, cb*0.25);
|
|
drawfillrect(10, 140 + (i * 68)-10 + game.menuyoff - 6, 140, 40, cr, cg, cb);
|
|
drawfillrect(12, 140 + (i * 68)-10 + game.menuyoff - 6 + 2, 140 - 4, 40 - 4, cr*0.75, cg*0.75, cb*0.75);
|
|
print(18, 140 + (i * 68) -10 + game.menuyoff + 20, game.menuoptions[i], 255, 255, 255);
|
|
|
|
if (game.besttimes[i] == -1) {
|
|
print( 18, 140 + (i * 68) -10 + game.menuyoff + 3, "Not attempted", 196, 196, 196, false);
|
|
}else {
|
|
print( 18, 140 + (i * 68) -10 + game.menuyoff + 3, game.timetstring(game.besttimes[i], help), 196, 196, 196);
|
|
|
|
print( 18+72, 140 + (i * 68) -10 + game.menuyoff + 3, "Rank: ", 196, 196, 196);
|
|
switch(game.bestrank[i]) {
|
|
case 0: print( 18+116, 140 + (i * 68) -10 + game.menuyoff + 3, "B", 255, 255, 255); break;
|
|
case 1: print( 18+116, 140 + (i * 68) -10 + game.menuyoff + 3, "A", 255, 255, 255); break;
|
|
case 2: print( 18+116, 140 + (i * 68) -10 + game.menuyoff + 3, "S", 255, 255, 255); break;
|
|
case 3: print( 18+116, 140 + (i * 68) -10 + game.menuyoff + 3, "V", 255, 255, 255); break;
|
|
}
|
|
}
|
|
}else {
|
|
drawfillrect(10, 140 + (i * 68) -10+ game.menuyoff - 6 + 4, 140, 40, 128*0.25, 128*0.25, 128*0.25);
|
|
drawfillrect(10, 140 + (i * 68)-10 + game.menuyoff - 6, 140, 40, 128, 128, 128);
|
|
drawfillrect(12, 140 + (i * 68)-10 + game.menuyoff - 6 + 2, 140 - 4, 40 - 4, 128*0.75, 128*0.75, 128*0.75);
|
|
|
|
print( 18, 140 + (i * 68) -10 + game.menuyoff + 12, "Locked...", 255, 255, 255, false);
|
|
}
|
|
|
|
}else if (game.menuoptionslayout[i] == 6) {
|
|
//Time trial button, right
|
|
|
|
if (game.menuoptionsactive[i]) {
|
|
drawfillrect(170, 140 + ((i-3) * 68) -10+ game.menuyoff - 6 + 4, 140, 40, cr*0.25, cg*0.25, cb*0.25);
|
|
drawfillrect(170, 140 + ((i-3) * 68)-10 + game.menuyoff - 6, 140, 40, cr, cg, cb);
|
|
drawfillrect(172, 140 + ((i-3) * 68)-10 + game.menuyoff - 6 + 2, 140 - 4, 40 - 4, cr*0.75, cg*0.75, cb*0.75);
|
|
print(178, 140 + ((i - 3) * 68) -10 + game.menuyoff + 20, game.menuoptions[i], 255, 255, 255);
|
|
|
|
if (game.besttimes[i] == -1) {
|
|
print( 178, 140 + ((i - 3) * 68) -10 + game.menuyoff + 3, "Not attempted", 196, 196, 196, false);
|
|
}else {
|
|
print( 178, 140 + ((i - 3) * 68) -10 + game.menuyoff + 3, game.timetstring(game.besttimes[i], help), 196, 196, 196);
|
|
|
|
print( 178+72, 140 + ((i - 3) * 68) -10 + game.menuyoff + 3, "Rank: ", 196, 196, 196);
|
|
switch(game.bestrank[i]) {
|
|
case 0: print( 178+116, 140 + ((i - 3) * 68) -10 + game.menuyoff + 3, "B", 255, 255, 255); break;
|
|
case 1: print( 178+116, 140 + ((i - 3) * 68) -10 + game.menuyoff + 3, "A", 255, 255, 255); break;
|
|
case 2: print( 178+116, 140 + ((i - 3) * 68) -10 + game.menuyoff + 3, "S", 255, 255, 255); break;
|
|
case 3: print( 178+116, 140 + ((i - 3) * 68) -10 + game.menuyoff + 3, "V", 255, 255, 255); break;
|
|
}
|
|
}
|
|
}else {
|
|
drawfillrect(170, 140 + ((i-3) * 68) -10+ game.menuyoff - 6 + 4, 140, 40, 128*0.25, 128*0.25, 128*0.25);
|
|
drawfillrect(170, 140 + ((i-3) * 68)-10 + game.menuyoff - 6, 140, 40, 128, 128, 128);
|
|
drawfillrect(172, 140 + ((i - 3) * 68) - 10 + game.menuyoff - 6 + 2, 140 - 4, 40 - 4, 128 * 0.75, 128 * 0.75, 128 * 0.75);
|
|
|
|
print( 178, 140 + ((i - 3) * 68) -10 + game.menuyoff + 12, "Locked...", 255, 255, 255, false);
|
|
}
|
|
}else if (game.menuoptionslayout[i] == 7) {
|
|
//Options button on the main menu - don't draw anything, just have a detection zone
|
|
}else if (game.menuoptionslayout[i] == 8) {
|
|
//credits button on the main menu - don't draw anything, just have a detection zone
|
|
}else if (game.menuoptionslayout[i] == 9) {
|
|
//For unlocking and relocking things
|
|
if (game.menuoptionsactive[i]) {
|
|
drawfillrect(160 - 90 + 4, 140 + (i * b_gap) + game.menuyoff - 6 + 4, 180, b_size, cr*0.25, cg*0.25, cb*0.25);
|
|
drawfillrect(160 - 90, 140 + (i * b_gap) + game.menuyoff - 6, 180, b_size, cr, cg, cb);
|
|
drawfillrect(160 - 90 + 2, 140 + (i * b_gap) + game.menuyoff - 6 + 2, 180 - 4, b_size - 4, cr*0.75, cg*0.75, cb*0.75);
|
|
print(110 + (i * division) +game.menuxoff, 140 + (i * b_gap) + game.menuyoff+3, game.menuoptions[i], 255, 255, 255, true);
|
|
}else {
|
|
print(110 + (i * division) +game.menuxoff, 140 + (i * b_gap) + game.menuyoff+3, game.menuoptions_alt[i], 255, 255, 255, true);
|
|
}
|
|
}else if (game.menuoptionslayout[i] == 10) {
|
|
//Player level menu next page button
|
|
if (game.menuoptionsactive[i]) {
|
|
drawfillrect(160 - 70 + 4, 240 - b_gap + 4, 140, b_size, cr*0.25, cg*0.25, cb*0.25);
|
|
drawfillrect(160 - 70, 240 - b_gap, 140, b_size, cr, cg, cb);
|
|
drawfillrect(160 - 70 + 2, 240 - b_gap + 2, 140 - 4, b_size - 4, cr*0.75, cg*0.75, cb*0.75);
|
|
print(110 + (i * division) +game.menuxoff, 240 - b_gap+3+6, game.menuoptions[i], 255, 255, 255, true);
|
|
}else {
|
|
drawfillrect(160 - 70 + 4, 240 - b_gap + 4, 140, 20, 128*0.25, 128*0.25, 128*0.25);
|
|
drawfillrect(160 - 70, 240 - b_gap, 140, 20, 128, 128, 128);
|
|
drawfillrect(160 - 70 + 2, 240 - b_gap + 2, 140 - 4, 20 - 4, 128*0.75, 128*0.75, 128*0.75);
|
|
print(110 + (i * division) +game.menuxoff, 240 - b_gap +3+6, "LOCKED", 255, 255, 255, true);
|
|
}
|
|
}else if (game.menuoptionslayout[i] == 11) {
|
|
//Player level
|
|
drawfillrect(160 - 140 + 4, 140 + (i * 65) -10+ game.menuyoff - 6 + 4, 280, (b_size*2)+5, cr*0.25, cg*0.25, cb*0.25);
|
|
drawfillrect(160 - 140, 140 + (i * 65)-10 + game.menuyoff - 6, 280, (b_size*2)+5, cr, cg, cb);
|
|
drawfillrect(160 - 140 + 2, 140 + (i * 65)-10 + game.menuyoff - 6 + 2, 280 - 4, (b_size*2) - 4+5, cr*0.75, cg*0.75, cb*0.75);
|
|
print(120, 140 + (i * 65) -10 + game.menuyoff, editor.ListOfMetaData[int(game.menuoptions[i])].title, 255, 255, 255);
|
|
print(120, 140 + (i * 65) -10 + game.menuyoff + 10, editor.ListOfMetaData[int(game.menuoptions[i])].creator, 196, 196, 196);
|
|
|
|
print(120, 140 + (i * 65) -10 + game.menuyoff + 35+3, "spikyness: ", 196, 196, 196);
|
|
for (var tiii:int = 0; tiii < editor.playerlevel_spikyness[int(game.menuoptions[i])]; tiii++){
|
|
drawtile(120 + (8 * 11)+(8*tiii), 140 + (i * 65) -10 + game.menuyoff + 35+3, 8);
|
|
}
|
|
|
|
if (int(game.menuoptions_alt[i]) == 3) {
|
|
drawsprite(280-20, 140 + (i * 65) -10 + game.menuyoff + 30-3, 188, 255, 255, 255);
|
|
drawsprite(280, 140 + (i * 65) -10 + game.menuyoff + 30, 184, 255, 255, 255);
|
|
}else if (int(game.menuoptions_alt[i]) == 1) {
|
|
drawsprite(280, 140 + (i * 65) -10 + game.menuyoff + 30, 184, 255, 255, 255);
|
|
}
|
|
|
|
drawplayerlevelimage(int(game.menuoptions[i]), 160 - 140 + 4+2, 140 + (i * 65) -10 + game.menuyoff - 6 + 4+2);
|
|
}else if (game.menuoptionslayout[i] == 12) {
|
|
//more games button on the main menu - don't draw anything, just have a detection zone
|
|
}
|
|
}
|
|
}else {
|
|
for (i = 0; i < game.nummenuoptions; i++) {
|
|
if (i == game.currentmenuoption) {
|
|
//Draw it highlighted
|
|
if (game.menuoptionsactive[i]) {
|
|
tempstring = game.menuoptions[i]; tempstring = "[ " + tempstring.toUpperCase() + " ]";
|
|
print(110 + (i * division) - 16 +game.menuxoff, 140 + (i * 12) +game.menuyoff, tempstring, cr, cg, cb);
|
|
}else {
|
|
tempstring = game.menuoptions[i]; tempstring = "[ " + tempstring + " ]";
|
|
//Draw it in gray
|
|
print(110 + (i * division) - 16 +game.menuxoff, 140 + (i * 12)+game.menuyoff, tempstring, 128, 128, 128);
|
|
}
|
|
}else {
|
|
//Draw it normally
|
|
if (game.menuoptionsactive[i]) {
|
|
print(110 + (i * division) +game.menuxoff, 140 + (i * 12)+game.menuyoff, game.menuoptions[i], cr, cg, cb);
|
|
}else {
|
|
//Draw it in gray
|
|
print(110 + (i * division) +game.menuxoff, 140 + (i * 12)+game.menuyoff, game.menuoptions[i], 128, 128, 128);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public function drawlevelmenu(game:gameclass, cr:int, cg:int, cb:int, division:int = 30):void {
|
|
trace("dwgfx.drawlevelmenu() is not implemented yet");
|
|
}
|
|
|
|
//Fade functions
|
|
public function processfade():void {
|
|
if (fademode > 1) {
|
|
if (fademode == 2) {
|
|
//prepare fade out
|
|
for (i = 0; i < 15; i++) {
|
|
fadebars[i] = -int(Math.random() * 12) * 8;
|
|
}
|
|
fadeamount = 0;
|
|
fademode = 3;
|
|
}else if (fademode == 3) {
|
|
fadeamount += 24;
|
|
if (fadeamount > 416) {
|
|
fademode = 1; //faded
|
|
}
|
|
}else if (fademode == 4) {
|
|
//prepare fade in
|
|
for (i = 0; i < 15; i++) {
|
|
fadebars[i] = 320 + int(Math.random() * 12) * 8;
|
|
}
|
|
fadeamount = 416;
|
|
fademode = 5;
|
|
}else if (fademode == 5) {
|
|
fadeamount -= 24;
|
|
if (fadeamount <= 0) {
|
|
fademode = 0; //normal
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public function drawfade():void {
|
|
if (fademode == 1) {
|
|
cls(0x000000);
|
|
}else if(fademode==3){
|
|
for (i = 0; i < 15; i++) {
|
|
drawfillrect(fadebars[i], i * 16, fadeamount, 16, 0, 0, 0);
|
|
}
|
|
}else if(fademode==5){
|
|
for (i = 0; i < 15; i++) {
|
|
drawfillrect(fadebars[i]-fadeamount, i * 16, 500, 16, 0, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
public function setwarprect(a:int, b:int, c:int, d:int):void {
|
|
warprect.x = a; warprect.y = b;
|
|
warprect.width = c; warprect.height = d;
|
|
}
|
|
|
|
public function createtextbox(t:String, xp:int, yp:int, r:int = 255, g:int = 255, b:int = 255):void {
|
|
if(ntextbox == 0) {
|
|
//If there are no active textboxes, Z=0;
|
|
m = 0; ntextbox++;
|
|
}else {
|
|
/*i = 0; m = -1;
|
|
while (i < ntextbox) {
|
|
if (!textbox[i].active) { m = i; i = ntextbox;}
|
|
i++;
|
|
}
|
|
if (m == -1) {m = ntextbox; ntextbox++;}
|
|
*/
|
|
m = ntextbox; ntextbox++;
|
|
}
|
|
|
|
if (m < 20) {
|
|
textbox[m].clear();
|
|
textbox[m].line[0] = t;
|
|
textbox[m].xp = xp;
|
|
if (xp == -1) textbox[m].xp = 160 - (((t.length / 2) + 1) * 8);
|
|
textbox[m].yp = yp;
|
|
textbox[m].initcol(r, g, b);
|
|
textbox[m].resize();
|
|
}
|
|
}
|
|
|
|
public function textboxcleanup():void {
|
|
i = ntextbox - 1; while (i >= 0 && !textbox[i].active) { ntextbox--; i--; }
|
|
}
|
|
|
|
public function textboxcenter():void {
|
|
textbox[m].centerx(); textbox[m].centery();
|
|
}
|
|
|
|
public function textboxcenterx():void {
|
|
textbox[m].centerx();
|
|
}
|
|
|
|
public function textboxwidth():int {
|
|
return textbox[m].w;
|
|
}
|
|
|
|
public function textboxmove(xo:int, yo:int):void {
|
|
textbox[m].xp += xo; textbox[m].yp += yo;
|
|
}
|
|
|
|
public function textboxmoveto(xo:int):void {
|
|
textbox[m].xp = xo;
|
|
}
|
|
|
|
public function textboxcentery():void {
|
|
textbox[m].centery();
|
|
}
|
|
|
|
public function textboxadjust():void {
|
|
textbox[m].adjust();
|
|
}
|
|
|
|
public function addline(t:String):void {
|
|
textbox[m].addline(t);
|
|
}
|
|
|
|
public function textboxtimer(t:int):void {
|
|
textbox[m].timer=t;
|
|
}
|
|
|
|
public function textboxremove():void {
|
|
//Remove all textboxes
|
|
for (i = 0; i < ntextbox; i++) {
|
|
textbox[i].remove();
|
|
}
|
|
}
|
|
|
|
public function textboxremovefast():void {
|
|
//Remove all textboxes
|
|
for (i = 0; i < ntextbox; i++) {
|
|
textbox[i].removefast();
|
|
}
|
|
}
|
|
|
|
public function textboxactive():void {
|
|
//Remove all but the most recent textbox
|
|
for (i = 0; i < ntextbox; i++) {
|
|
if (m != i) textbox[i].remove();
|
|
}
|
|
}
|
|
|
|
public function setmadrect(x:int, y:int, w:int, h:int):void {
|
|
madrect.x = x; madrect.y = y; madrect.width = w; madrect.height = h;
|
|
}
|
|
|
|
public function drawtextbox(x:int, y:int, w:int, h:int, r:int, g:int, b:int):void {
|
|
//given these parameters, draw a textbox
|
|
drawfillrect(x, y, w * 8, h * 8, r / 6, g / 6, b / 6);
|
|
drawcoloredtile(x, y, 40, r, g, b);
|
|
drawcoloredtile(x + (w*8) - 8, y, 42, r, g, b);
|
|
drawcoloredtile(x, y + (h*8) - 8, 45, r, g, b);
|
|
drawcoloredtile(x + (w*8) - 8, y + (h*8) - 8, 47, r, g, b);
|
|
|
|
for (k = 0; k < w-2; k++) {
|
|
drawcoloredtile(x + 8 + (k * 8), y, 41, r, g, b);
|
|
drawcoloredtile(x + 8 + (k * 8), y + (h * 8) - 8, 46, r, g, b);
|
|
}
|
|
|
|
for (k = 0; k < h-2; k++) {
|
|
drawcoloredtile(x, y + 8 + (k * 8), 43, r, g, b);
|
|
drawcoloredtile(x + (w * 8) - 8, y + 8 + (k * 8), 44, r, g, b);
|
|
}
|
|
}
|
|
|
|
public function drawpixeltextbox(x:int, y:int, w:int, h:int, w2:int, h2:int, r:int, g:int, b:int, xo:int = 0, yo:int = 0):void {
|
|
//given these parameters, draw a textbox with a pixel width
|
|
drawfillrect(x, y, w, h, r / 6, g / 6, b / 6);
|
|
|
|
for (k = 0; k < w2-2; k++) {
|
|
drawcoloredtile(x + 8-xo + (k * 8), y, 41, r, g, b);
|
|
drawcoloredtile(x + 8-xo + (k * 8), y + (h) - 8, 46, r, g, b);
|
|
}
|
|
|
|
for (k = 0; k < h2-2; k++) {
|
|
drawcoloredtile(x, y + 8-yo + (k * 8), 43, r, g, b);
|
|
drawcoloredtile(x + (w) - 8, y + 8-yo + (k * 8), 44, r, g, b);
|
|
}
|
|
|
|
drawcoloredtile(x, y, 40, r, g, b);
|
|
drawcoloredtile(x + (w) - 8, y, 42, r, g, b);
|
|
drawcoloredtile(x, y + (h) - 8, 45, r, g, b);
|
|
drawcoloredtile(x + (w) - 8, y + (h) - 8, 47, r, g, b);
|
|
}
|
|
|
|
public function drawcustompixeltextbox(x:int, y:int, w:int, h:int, w2:int, h2:int, r:int, g:int, b:int, xo:int = 0, yo:int = 0):void {
|
|
//given these parameters, draw a textbox with a pixel width
|
|
drawfillrect(x, y, w, h, r / 6, g / 6, b / 6);
|
|
|
|
for (k = 0; k < w2-2; k++){
|
|
drawcoloredtile(x + 8-xo + (k * 8), y, 41, r, g, b);
|
|
drawcoloredtile(x + 8-xo + (k * 8), y + (h) - 8, 46, r, g, b);
|
|
}
|
|
|
|
drawcoloredtile(x + (w) - 16, y, 41, r, g, b);
|
|
drawcoloredtile(x + (w) - 16, y + (h) - 8, 46, r, g, b);
|
|
drawcoloredtile(x + (w) - 24, y, 41, r, g, b);
|
|
drawcoloredtile(x + (w) - 24, y + (h) - 8, 46, r, g, b);
|
|
|
|
for (k = 0; k < h2-2; k++){
|
|
drawcoloredtile(x, y + 8-yo + (k * 8), 43, r, g, b);
|
|
drawcoloredtile(x + (w) - 8, y + 8-yo + (k * 8), 44, r, g, b);
|
|
}
|
|
|
|
drawcoloredtile(x, y + (h) - 16, 43, r, g, b);
|
|
drawcoloredtile(x + (w) - 8, y + (h) - 16, 44, r, g, b);
|
|
drawcoloredtile(x, y + (h) - 24, 43, r, g, b);
|
|
drawcoloredtile(x + (w) - 8, y + (h) - 24, 44, r, g, b);
|
|
|
|
drawcoloredtile(x, y, 40, r, g, b);
|
|
drawcoloredtile(x + (w) - 8, y, 42, r, g, b);
|
|
drawcoloredtile(x, y + (h) - 8, 45, r, g, b);
|
|
drawcoloredtile(x + (w) - 8, y + (h) - 8, 47, r, g, b);
|
|
}
|
|
|
|
public var subtex:Texture;
|
|
public var subimage:Image;
|
|
public function drawpartimage(t:Texture, xp:int, yp:int, wp:int, hp:int):void {
|
|
// Acquire SubTexture and build an Image from it.
|
|
trect.x = 0;
|
|
trect.y = 0;
|
|
trect.width = wp;
|
|
trect.height = hp;
|
|
|
|
if (subtex == null) {
|
|
subtex = Texture.fromTexture(t, trect);
|
|
subimage = new Image(subtex); // alloc. avoidable with pooling?
|
|
subimage.touchable = false;
|
|
subimage.textureSmoothing = TextureSmoothing.NONE;
|
|
|
|
tposition.identity();
|
|
tposition.translate(xp, yp);
|
|
backbuffer.draw(subimage, tposition);
|
|
return;
|
|
}else {
|
|
//dispose of the old one
|
|
//No memory leaks, but this is throwing away a texture every call, which might
|
|
//get expensive? Ideally you'd reuse an image here if it hasn't changed.
|
|
//Or, maybe easier, make a function that grabs the chunk we need and keeps it somewhere
|
|
//else, hardcoding around the problem. Let's see if this is a problem in practice, though.
|
|
subtex.dispose();
|
|
subimage.dispose();
|
|
|
|
subtex = Texture.fromTexture(t, trect);
|
|
subimage = new Image(subtex);
|
|
subimage.touchable = false;
|
|
subimage.textureSmoothing = TextureSmoothing.NONE;
|
|
|
|
tposition.identity();
|
|
tposition.translate(xp, yp);
|
|
backbuffer.draw(subimage, tposition);
|
|
return;
|
|
}
|
|
}
|
|
|
|
public function cutscenebars():void {
|
|
if (showcutscenebars) {
|
|
cutscenebarspos += 25;
|
|
if (cutscenebarspos >= 360) cutscenebarspos = 360;
|
|
drawfillrect(0, 0, cutscenebarspos, 16, 0, 0, 0);
|
|
drawfillrect(360 - cutscenebarspos, 224, cutscenebarspos, 16, 0, 0, 0);
|
|
}else {
|
|
//disappearing
|
|
if (cutscenebarspos > 0) {
|
|
cutscenebarspos -= 25;
|
|
//draw
|
|
drawfillrect(0, 0, cutscenebarspos, 16, 0, 0, 0);
|
|
drawfillrect(360 - cutscenebarspos, 224, cutscenebarspos, 16, 0, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
//For android: this function draws textboxes to a buffer first, where they're later copied to the screen
|
|
//buffer is a 320x500 image. X coordinates aren't changed, but y coordinates are
|
|
public var textbox_ybuffer:int;
|
|
public var textbox_ybufferheight:int = 0;
|
|
public function drawgui(help:helpclass):void {
|
|
textboxcleanup();
|
|
//Draw all the textboxes to the screen
|
|
for (i = 0; i<ntextbox; i++) {
|
|
//This routine also updates the textboxs
|
|
textbox[i].update();
|
|
if (textbox[i].active) {
|
|
if (textbox[i].r == 0 && textbox[i].g == 0 && textbox[i].b == 0) {
|
|
if(flipmode){
|
|
for (j = 0; j < textbox[i].numlines; j++) {
|
|
print(textbox[i].xp + 8, textbox[i].yp + (textbox[i].numlines*8) - (j * 8), textbox[i].line[j], 196, 196, 255 - help.glow);
|
|
}
|
|
}else {
|
|
for (j = 0; j < textbox[i].numlines; j++) {
|
|
print(textbox[i].xp + 8, textbox[i].yp + 8 + (j * 8), textbox[i].line[j], 196, 196, 255 - help.glow);
|
|
}
|
|
}
|
|
}else {
|
|
drawfillrect(textbox[i].textrect.x, textbox[i].textrect.y, textbox[i].textrect.width, textbox[i].textrect.height, textbox[i].r/6, textbox[i].g/6, textbox[i].b / 6);
|
|
|
|
drawcoloredtile(textbox[i].xp, textbox[i].yp, 40, textbox[i].r, textbox[i].g, textbox[i].b);
|
|
drawcoloredtile(textbox[i].xp+textbox[i].w-8, textbox[i].yp, 42, textbox[i].r, textbox[i].g, textbox[i].b);
|
|
drawcoloredtile(textbox[i].xp, textbox[i].yp+textbox[i].h-8, 45, textbox[i].r, textbox[i].g, textbox[i].b);
|
|
drawcoloredtile(textbox[i].xp+textbox[i].w-8, textbox[i].yp+textbox[i].h-8, 47, textbox[i].r, textbox[i].g, textbox[i].b);
|
|
for (k = 0; k < textbox[i].lw; k++) {
|
|
drawcoloredtile(textbox[i].xp + 8 + (k * 8), textbox[i].yp, 41, textbox[i].r, textbox[i].g, textbox[i].b);
|
|
drawcoloredtile(textbox[i].xp + 8 + (k * 8), textbox[i].yp+textbox[i].h-8, 46, textbox[i].r, textbox[i].g, textbox[i].b);
|
|
}
|
|
for (k = 0; k < textbox[i].numlines; k++) {
|
|
drawcoloredtile(textbox[i].xp, textbox[i].yp + 8 + (k * 8), 43, textbox[i].r, textbox[i].g, textbox[i].b);
|
|
drawcoloredtile(textbox[i].xp + textbox[i].w-8, textbox[i].yp + 8 + (k * 8), 44, textbox[i].r, textbox[i].g, textbox[i].b);
|
|
}
|
|
|
|
if(flipmode){
|
|
for (j = 0; j < textbox[i].numlines; j++) {
|
|
print(textbox[i].xp + 8, textbox[i].yp + (textbox[i].numlines*8) - (j * 8), textbox[i].line[j], textbox[i].r, textbox[i].g, textbox[i].b);
|
|
}
|
|
}else {
|
|
for (j = 0; j < textbox[i].numlines; j++) {
|
|
print(textbox[i].xp + 8, textbox[i].yp +8 + (j * 8), textbox[i].line[j], textbox[i].r, textbox[i].g, textbox[i].b);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((textbox[i].yp == 12 || textbox[i].yp == 180) && textbox[i].r == 165) {
|
|
if (flipmode) { drawimage(5, 0, 180, true);
|
|
}else{ drawimage(0, 0, 12, true); }
|
|
}else if ((textbox[i].yp == 12 || textbox[i].yp == 180) && textbox[i].g == 165) {
|
|
if (flipmode) { drawimage(6, 0, 180, true);
|
|
}else{ drawimage(4, 0, 12, true); }
|
|
}
|
|
if (flipmode) {
|
|
if (textbox[i].r == 175 && textbox[i].g == 175) {
|
|
//purple guy
|
|
drawsprite(80 - 6, 64 + 48 + 4, 6, 220- help.glow/4 - (Math.random()*20), 120- help.glow/4, 210 - help.glow/4);
|
|
}else if (textbox[i].r == 175 && textbox[i].b == 175) {
|
|
//red guy
|
|
drawsprite(80 - 6, 64 + 48+ 4, 6, 255 - help.glow/8, 70 - help.glow/4, 70 - help.glow / 4);
|
|
}else if (textbox[i].r == 175) {
|
|
//green guy
|
|
drawsprite(80 - 6, 64 + 48 + 4, 6, 120 - help.glow / 4 - (Math.random() * 20), 220 - help.glow / 4, 120 - help.glow / 4);
|
|
}else if (textbox[i].g == 175) {
|
|
//yellow guy
|
|
drawsprite(80 - 6, 64 + 48+ 4, 6, 220- help.glow/4 - (Math.random()*20), 210 - help.glow/4, 120- help.glow/4);
|
|
}else if (textbox[i].b == 175) {
|
|
//blue guy
|
|
drawsprite(80 - 6, 64 + 48+ 4, 6, 75, 75, 255- help.glow/4 - (Math.random()*20));
|
|
}
|
|
}else{
|
|
if (textbox[i].r == 175 && textbox[i].g == 175) {
|
|
//purple guy
|
|
drawsprite(80 - 6, 64 + 32 + 4, 0, 220- help.glow/4 - (Math.random()*20), 120- help.glow/4, 210 - help.glow/4);
|
|
}else if (textbox[i].r == 175 && textbox[i].b == 175) {
|
|
//red guy
|
|
drawsprite(80 - 6, 64 + 32 + 4, 0, 255 - help.glow/8, 70 - help.glow/4, 70 - help.glow / 4);
|
|
}else if (textbox[i].r == 175) {
|
|
//green guy
|
|
drawsprite(80 - 6, 64 + 32 + 4, 0, 120 - help.glow / 4 - (Math.random() * 20), 220 - help.glow / 4, 120 - help.glow / 4);
|
|
}else if (textbox[i].g == 175) {
|
|
//yellow guy
|
|
drawsprite(80 - 6, 64 + 32 + 4, 0, 220- help.glow/4 - (Math.random()*20), 210 - help.glow/4, 120- help.glow/4);
|
|
}else if (textbox[i].b == 175) {
|
|
//blue guy
|
|
drawsprite(80 - 6, 64 + 32 + 4, 0, 75, 75, 255- help.glow/4 - (Math.random()*20));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public function RGBA(red:Number,green:Number,blue:Number):Number{
|
|
return (blue | (green << 8) | (red << 16)) + 0xFF000000;
|
|
}
|
|
|
|
public function RGB(red:Number,green:Number,blue:Number):Number{
|
|
return (blue | (green << 8) | (red << 16))
|
|
}
|
|
|
|
public function RGBf(red:Number, green:Number, blue:Number):Number {
|
|
red = (red+128) / 3; green = (green+128) / 3; blue = (blue+128) / 3;
|
|
return (blue | (green << 8) | (red << 16))
|
|
}
|
|
|
|
public function addmobileimage(imgname:String):void {
|
|
var sourcetexture:Texture = starlingassets.getTexture(imgname);
|
|
var t:Image = new Image(sourcetexture);
|
|
t.touchable = false;
|
|
t.textureSmoothing = TextureSmoothing.NONE;
|
|
mobileimages.push(t);
|
|
}
|
|
|
|
public function addimage(imgname:String):void {
|
|
var sourcetexture:Texture = starlingassets.getTexture(imgname);
|
|
var t:Image = new Image(sourcetexture);
|
|
t.touchable = false;
|
|
t.textureSmoothing = TextureSmoothing.NONE;
|
|
images.push(t);
|
|
}
|
|
|
|
public function addimage_rendertexture(imgname:String):void {
|
|
customminimap = starlingassets.getTexture(imgname) as RenderTexture;
|
|
var t:Image = new Image(customminimap);
|
|
t.touchable = false;
|
|
t.textureSmoothing = TextureSmoothing.NONE;
|
|
images.push(t);
|
|
}
|
|
|
|
public function addplayerlevelimage(imgname:String):void {
|
|
var sourcetexture:Texture = starlingassets.getTexture(imgname);
|
|
var t:Image = new Image(sourcetexture);
|
|
t.touchable = false;
|
|
t.textureSmoothing = TextureSmoothing.NONE;
|
|
playerlevelimages.push(t);
|
|
}
|
|
|
|
public function addbackground(imgname:String):void {
|
|
//Don't think this is actually used in VVVVVV
|
|
var sourcetexture:Texture = starlingassets.getTexture(imgname);
|
|
var t:Image = new Image(sourcetexture);
|
|
t.touchable = false;
|
|
t.textureSmoothing = TextureSmoothing.NONE;
|
|
backgrounds.push(t);
|
|
}
|
|
|
|
public var towerx_pix:int;
|
|
public var towery_pix:int;
|
|
public var tower_bgcol:Vector.<int> = new Vector.<int>;
|
|
public var tower_bgdarkcol:Vector.<int> = new Vector.<int>;
|
|
public var lasttowercolstate:int = -1;
|
|
public var lasttowercolstate_front:int = -1;
|
|
public var maptdrawfront:Boolean = true;
|
|
public var forcetowerupdate:int = 10;
|
|
public var forcefronttowerupdate:int = 10;
|
|
public var towerfront_lastypos:int = 0;
|
|
public var tower_lastypos:int = 0;
|
|
|
|
public var forcewarpzonehorizontalupdate:int = 2;
|
|
public var forcewarpzoneverticalupdate:int = 1;
|
|
public var forcetowerstaticupdate:int = 1;
|
|
|
|
public function forcescreenupdates():void {
|
|
if (forcetowerupdate < 3) forcetowerupdate = 3;
|
|
if (forcefronttowerupdate < 3) forcefronttowerupdate = 3;
|
|
if (forcetowerstaticupdate < 3) forcetowerstaticupdate = 3;
|
|
if (forcewarpzoneverticalupdate < 1) forcewarpzoneverticalupdate = 1;
|
|
if (forcewarpzonehorizontalupdate < 1) forcewarpzonehorizontalupdate = 1;
|
|
}
|
|
|
|
public function drawtowerbackground(map:mapclass):void {
|
|
if (map.bypos < 0) {
|
|
map.bypos += 120 * 8;
|
|
forcetowerupdate += 5;
|
|
}
|
|
|
|
if (map.scrolldir == 1) {
|
|
if (map.tdrawback || lasttowercolstate != map.colstate || forcetowerupdate > 0) {
|
|
//Draw the whole thing; needed for every colour cycle!
|
|
towerbufferbackground_meshbatch.y = 0;
|
|
tower_lastypos = map.bypos;
|
|
|
|
towerbufferbackground_meshbatch.clear();
|
|
//Draw the whole thing; needed for every colour cycle!
|
|
for (j = 0; j < 40; j++) {
|
|
for (i = 0; i < 40; i++) {
|
|
temp = map.tower.backat(i, j, map.bypos);
|
|
drawtowertile3(i * 8, (j * 8) - (map.bypos % 8), temp, map.colstate);
|
|
}
|
|
}
|
|
|
|
backbuffer.draw(towerbufferbackground_meshbatch);
|
|
|
|
map.tdrawback = false;
|
|
lasttowercolstate = map.colstate;
|
|
if (forcetowerupdate > 0) forcetowerupdate--;
|
|
}else {
|
|
//just scroll down a bit
|
|
towerbufferbackground_meshbatch.y = -int(map.bypos - tower_lastypos);
|
|
backbuffer.draw(towerbufferbackground_meshbatch);
|
|
|
|
if (towerbufferbackground_meshbatch.y < -80) {
|
|
towerbufferbackground_meshbatch.y = 0;
|
|
map.tdrawback = true;
|
|
}
|
|
}
|
|
}else{
|
|
if (map.tdrawback || lasttowercolstate != map.colstate || forcetowerupdate > 0) {
|
|
//Draw the whole thing; needed for every colour cycle!
|
|
towerbufferbackground_meshbatch.y = 0;
|
|
tower_lastypos = map.bypos;
|
|
|
|
towerbufferbackground_meshbatch.clear();
|
|
//Draw the whole thing; needed for every colour cycle!
|
|
for (j = -10; j < 30; j++) {
|
|
for (i = 0; i < 40; i++) {
|
|
temp = map.tower.backat(i, j, map.bypos);
|
|
drawtowertile3(i * 8, (j * 8) - (map.bypos % 8), temp, map.colstate);
|
|
}
|
|
}
|
|
|
|
backbuffer.draw(towerbufferbackground_meshbatch);
|
|
|
|
map.tdrawback = false;
|
|
lasttowercolstate = map.colstate;
|
|
if (forcetowerupdate > 0) forcetowerupdate--;
|
|
}else {
|
|
//just scroll down a bit
|
|
towerbufferbackground_meshbatch.y = -int(map.bypos - tower_lastypos);
|
|
backbuffer.draw(towerbufferbackground_meshbatch);
|
|
|
|
if (towerbufferbackground_meshbatch.y > 80) {
|
|
towerbufferbackground_meshbatch.y = 0;
|
|
map.tdrawback = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public function drawtowerbackgroundsolo(map:mapclass):void {
|
|
if (map.bypos < 0) {
|
|
map.bypos += 120 * 8;
|
|
forcetowerupdate += 5;
|
|
}
|
|
|
|
if (map.scrolldir == 1) map.tdrawback = true;
|
|
|
|
if (map.tdrawback || lasttowercolstate != map.colstate || forcetowerupdate > 0) {
|
|
//Draw the whole thing; needed for every colour cycle!
|
|
towerbufferbackground_meshbatch.y = 0;
|
|
tower_lastypos = map.bypos;
|
|
|
|
towerbufferbackground_meshbatch.clear();
|
|
//Draw the whole thing; needed for every colour cycle!
|
|
for (j = -10; j < 31; j++) {
|
|
for (i = 0; i < 40; i++) {
|
|
temp = map.tower.backat(i, j, map.bypos);
|
|
drawtowertile3(i * 8, (j * 8) - (map.bypos % 8), temp, map.colstate);
|
|
}
|
|
}
|
|
|
|
backbuffer.draw(towerbufferbackground_meshbatch);
|
|
|
|
map.tdrawback = false;
|
|
lasttowercolstate = map.colstate;
|
|
if (forcetowerupdate > 0) forcetowerupdate--;
|
|
}else {
|
|
//just scroll down a bit
|
|
towerbufferbackground_meshbatch.y = -int(map.bypos - tower_lastypos);
|
|
backbuffer.draw(towerbufferbackground_meshbatch);
|
|
|
|
if (towerbufferbackground_meshbatch.y > 80) {
|
|
towerbufferbackground_meshbatch.y = 0;
|
|
map.tdrawback = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
public function drawtowermap(game:gameclass, map:mapclass):void {
|
|
if (game.deathseq > 0) { forcefronttowerupdate = 20; }
|
|
|
|
if (map.scrolldir == 1) {
|
|
if (maptdrawfront || lasttowercolstate_front != map.colstate || forcefronttowerupdate > 0) {
|
|
towerbufferforeground_meshbatch.y = 0;
|
|
towerfront_lastypos = map.ypos;
|
|
towerbufferforeground_meshbatch.clear();
|
|
|
|
for (j = 0; j < 40; j++) {
|
|
for (i = 0; i < 40; i++) {
|
|
temp = map.tower.at(i, j, map.ypos);
|
|
if (temp > 0) drawtile3_batch(i * 8, (j * 8) - (map.ypos % 8), temp, map.colstate);
|
|
}
|
|
}
|
|
|
|
backbuffer.draw(towerbufferforeground_meshbatch);
|
|
|
|
maptdrawfront = false;
|
|
lasttowercolstate_front = map.colstate;
|
|
if (forcefronttowerupdate > 0) forcefronttowerupdate--;
|
|
}else {
|
|
//just scroll down a bit
|
|
towerbufferforeground_meshbatch.y = -int(map.ypos - towerfront_lastypos);
|
|
backbuffer.draw(towerbufferforeground_meshbatch);
|
|
|
|
if (towerbufferforeground_meshbatch.y < -80) {
|
|
towerbufferforeground_meshbatch.y = 0;
|
|
maptdrawfront = true;
|
|
}
|
|
}
|
|
}else{
|
|
if (maptdrawfront || lasttowercolstate_front != map.colstate || forcefronttowerupdate > 0) {
|
|
towerbufferforeground_meshbatch.y = 0;
|
|
towerfront_lastypos = map.ypos;
|
|
towerbufferforeground_meshbatch.clear();
|
|
|
|
for (j = -10; j < 30; j++) {
|
|
for (i = 0; i < 40; i++) {
|
|
temp = map.tower.at(i, j, map.ypos);
|
|
if (temp > 0) drawtile3_batch(i * 8, (j * 8) - (map.ypos % 8), temp, map.colstate);
|
|
}
|
|
}
|
|
|
|
backbuffer.draw(towerbufferforeground_meshbatch);
|
|
|
|
maptdrawfront = false;
|
|
lasttowercolstate_front = map.colstate;
|
|
if (forcefronttowerupdate > 0) forcefronttowerupdate--;
|
|
}else {
|
|
//just scroll down a bit
|
|
towerbufferforeground_meshbatch.y = -int(map.ypos - towerfront_lastypos);
|
|
backbuffer.draw(towerbufferforeground_meshbatch);
|
|
|
|
if (towerbufferforeground_meshbatch.y > 80) {
|
|
towerbufferforeground_meshbatch.y = 0;
|
|
maptdrawfront = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public function drawtowermap_nobackground(map:mapclass):void {
|
|
towerbufferforeground_meshbatch.clear();
|
|
|
|
for (j = 0; j < 30; j++) {
|
|
for (i = 0; i < 40; i++) {
|
|
temp = map.tower.at(i, j, map.ypos);
|
|
if (temp > 0 && temp<28) drawtile3_batch(i * 8, (j * 8) - (map.ypos % 8), temp, map.colstate);
|
|
}
|
|
}
|
|
|
|
backbuffer.draw(towerbufferforeground_meshbatch);
|
|
}
|
|
|
|
public function drawtowerspikes(map:mapclass):void {
|
|
for (i = 0; i < 40; i++) {
|
|
drawtile3(i * 8, -8 + map.spikeleveltop, 9, map.colstate);
|
|
drawtile3(i * 8, 230 - map.spikelevelbottom, 8, map.colstate);
|
|
}
|
|
}
|
|
|
|
public function drawtowerentities(map:mapclass, obj:entityclass, help:helpclass):void {
|
|
//Update line colours!
|
|
if (linedelay <= 0) {
|
|
linestate++;
|
|
if (linestate >= 10) linestate = 0;
|
|
linedelay = 2;
|
|
}else {
|
|
linedelay--;
|
|
}
|
|
|
|
var j:int, k:int;
|
|
for (var i:int = 0; i < obj.nentity; i++) {
|
|
if (!obj.entities[i].invis && obj.entities[i].active) {
|
|
if (obj.entities[i].size == 0) { // Sprites
|
|
tposition.identity();
|
|
tposition.translate(obj.entities[i].xp, obj.entities[i].yp - map.ypos);
|
|
|
|
setcol(obj.entities[i].colour, help);
|
|
sprites[obj.entities[i].drawframe].color = ct.color;
|
|
backbuffer.draw(sprites[obj.entities[i].drawframe], tposition);
|
|
//screenwrapping!
|
|
if (!map.minitowermode) {
|
|
if ( map.ypos >= 500 && map.ypos <= 5000) { //The "wrapping" area of the tower
|
|
if (tpoint.x < 0) {
|
|
tposition.identity();
|
|
tposition.translate(obj.entities[i].xp + 320, obj.entities[i].yp - map.ypos);
|
|
backbuffer.draw(sprites[obj.entities[i].drawframe], tposition);
|
|
}
|
|
if (tpoint.x > 300) {
|
|
tposition.identity();
|
|
tposition.translate(obj.entities[i].xp - 320, obj.entities[i].yp - map.ypos);
|
|
backbuffer.draw(sprites[obj.entities[i].drawframe], tposition);
|
|
}
|
|
}
|
|
}
|
|
}else if (obj.entities[i].size == 1) { // Tiles
|
|
tposition.identity();
|
|
tposition.translate(obj.entities[i].xp, obj.entities[i].yp - map.ypos);
|
|
backbuffer.draw(tiles[obj.entities[i].drawframe], tposition);
|
|
}else if (obj.entities[i].size == 2) { // Special: Moving platform, 4 tiles
|
|
tposition.identity();
|
|
tposition.translate(obj.entities[i].xp, obj.entities[i].yp - map.ypos);
|
|
backbuffer.draw(tiles[obj.entities[i].drawframe], tposition);
|
|
|
|
tposition.identity();
|
|
tposition.translate(obj.entities[i].xp + 8, obj.entities[i].yp - map.ypos);
|
|
backbuffer.draw(tiles[obj.entities[i].drawframe], tposition);
|
|
|
|
tposition.identity();
|
|
tposition.translate(obj.entities[i].xp + 16, obj.entities[i].yp - map.ypos);
|
|
backbuffer.draw(tiles[obj.entities[i].drawframe], tposition);
|
|
|
|
tposition.identity();
|
|
tposition.translate(obj.entities[i].xp + 24, obj.entities[i].yp - map.ypos);
|
|
}else if (obj.entities[i].size == 3) { // Big chunky pixels!
|
|
prect.x = obj.entities[i].xp; prect.y = obj.entities[i].yp-map.ypos;
|
|
//A seperate index of colours, for simplicity
|
|
if (obj.entities[i].colour == 1) {
|
|
drawfillrect(prect.x, prect.y, prect.width, prect.height, 196 - (Math.random() * 64), 10, 10);
|
|
}else if (obj.entities[i].colour == 2) {
|
|
drawfillrect(prect.x, prect.y, prect.width, prect.height, 160- help.glow/2 - (Math.random()*20), 200- help.glow/2, 220 - help.glow);
|
|
}
|
|
}else if (obj.entities[i].size == 4) { // Small pickups
|
|
drawhuetile(obj.entities[i].xp, obj.entities[i].yp-map.ypos, obj.entities[i].tile, obj.entities[i].colour);
|
|
}else if (obj.entities[i].size == 5) { //Horizontal Line
|
|
line_rect.x = obj.entities[i].xp; line_rect.y = obj.entities[i].yp-map.ypos;
|
|
line_rect.width = obj.entities[i].w; line_rect.height = 1;
|
|
drawgravityline(i, obj);
|
|
}else if (obj.entities[i].size == 6) { //Vertical Line
|
|
line_rect.x = obj.entities[i].xp; line_rect.y = obj.entities[i].yp-map.ypos;
|
|
line_rect.width = 1; line_rect.height = obj.entities[i].h;
|
|
drawgravityline(i, obj);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public function drawbackground(t:int, map:mapclass):void {
|
|
switch(t) {
|
|
case 1:
|
|
//Starfield
|
|
drawfillrect(0, 0, 320, 240, 0, 0, 0);
|
|
for (i = 0; i < 50; i++) {
|
|
if (starsspeed[i] <= 6) {
|
|
drawfillrect(stars[i].x, stars[i].y, stars[i].width, stars[i].height, 34, 34, 34);
|
|
}else {
|
|
drawfillrect(stars[i].x, stars[i].y, stars[i].width, stars[i].height, 85, 85, 85);
|
|
}
|
|
stars[i].x -= starsspeed[i];
|
|
if (stars[i].x < -10) {
|
|
stars[i].x += 340;
|
|
stars[i].y = Math.random() * 240;
|
|
starsspeed[i] = 4 + (Math.random()*4);
|
|
}
|
|
}
|
|
break;
|
|
case 2:
|
|
//Lab
|
|
i = 0;
|
|
switch(rcol) {
|
|
//Akward ordering to match tileset
|
|
case 0: bcol2 = RGB(0, 16*backboxint[i], 16*backboxint[i]); break; //Cyan
|
|
case 1: bcol2 = RGB(16*backboxint[i], 0, 0); break; //Red
|
|
case 2: bcol2 = RGB(16*backboxint[i], 0, 16*backboxint[i]); break; //Purple
|
|
case 3: bcol2 = RGB(0, 0, 16*backboxint[i]); break; //Blue
|
|
case 4: bcol2 = RGB(16*backboxint[i], 16*backboxint[i], 0); break; //Yellow
|
|
case 5: bcol2 = RGB(0, 16 * backboxint[i], 0); break; //Green
|
|
case 6:
|
|
//crazy case
|
|
spcoldel--;
|
|
if (spcoldel <= 0) {
|
|
spcoldel = 15;
|
|
spcol++;
|
|
if (spcol >= 12) spcol = 0;
|
|
}
|
|
switch(spcol) {
|
|
case 0: bcol2 = RGB(0, 16 * backboxint[i], 16 * backboxint[i]); break; //Cyan
|
|
case 1: bcol2 = RGB(0, (spcoldel+1)*backboxint[i], 16*backboxint[i]); break; //Cyan
|
|
case 2: bcol2 = RGB(0, 0, 16*backboxint[i]); break; //Blue
|
|
case 3: bcol2 = RGB((16-spcoldel)*backboxint[i], 0, 16*backboxint[i]); break; //Blue
|
|
case 4: bcol2 = RGB(16*backboxint[i], 0, 16*backboxint[i]); break; //Purple
|
|
case 5: bcol2 = RGB(16*backboxint[i], 0, (spcoldel+1)*backboxint[i]); break; //Purple
|
|
case 6: bcol2 = RGB(16*backboxint[i], 0, 0); break; //Red
|
|
case 7: bcol2 = RGB(16*backboxint[i], (16-spcoldel)*backboxint[i], 0); break; //Red
|
|
case 8: bcol2 = RGB(16*backboxint[i], 16*backboxint[i], 0); break; //Yellow
|
|
case 9: bcol2 = RGB((spcoldel+1)*backboxint[i], 16*backboxint[i], 0); break; //Yellow
|
|
case 10: bcol2 = RGB(0, 16 * backboxint[i], 0); break; //Green
|
|
case 11: bcol2 = RGB(0, 16 * backboxint[i], (16-spcoldel)*backboxint[i]); break; //Green
|
|
}
|
|
break;
|
|
}
|
|
cls(bcol2);
|
|
for (i = 0; i < 18; i++) {
|
|
switch(rcol) {
|
|
//Akward ordering to match tileset
|
|
case 0: bcol = RGB(16, 128*backboxint[i], 128*backboxint[i]); break; //Cyan
|
|
case 1: bcol = RGB(128*backboxint[i], 16, 16); break; //Red
|
|
case 2: bcol = RGB(128*backboxint[i], 16, 128*backboxint[i]); break; //Purple
|
|
case 3: bcol = RGB(16, 16, 128*backboxint[i]); break; //Blue
|
|
case 4: bcol = RGB(128*backboxint[i], 128*backboxint[i], 16); break; //Yellow
|
|
case 5: bcol = RGB(16, 128 * backboxint[i], 16); break; //Green
|
|
case 6:
|
|
//crazy case
|
|
switch(spcol) {
|
|
case 0: bcol = RGB(16, 128*backboxint[i], 128*backboxint[i]); break; //Cyan
|
|
case 1: bcol = RGB(16, ((spcoldel+1)*8)*backboxint[i], 128*backboxint[i]); break; //Cyan
|
|
case 2: bcol = RGB(16, 16, 128*backboxint[i]); break; //Blue
|
|
case 3: bcol = RGB((128-(spcoldel*8))*backboxint[i], 16, 128*backboxint[i]); break; //Blue
|
|
case 4: bcol = RGB(128*backboxint[i], 16, 128*backboxint[i]); break; //Purple
|
|
case 5: bcol = RGB(128*backboxint[i], 16, ((spcoldel+1)*8)*backboxint[i]); break; //Purple
|
|
case 6: bcol = RGB(128*backboxint[i], 16, 16); break; //Red
|
|
case 7: bcol = RGB(128*backboxint[i], (128-(spcoldel*8))*backboxint[i], 16); break; //Red
|
|
case 8: bcol = RGB(128*backboxint[i], 128*backboxint[i], 16); break; //Yellow
|
|
case 9: bcol = RGB(((spcoldel+1)*8)*backboxint[i], 128*backboxint[i], 16); break; //Yellow
|
|
case 10: bcol = RGB(16, 128 * backboxint[i], 16); break; //Green
|
|
case 11: bcol = RGB(16, 128 * backboxint[i], (128-(spcoldel*8))*backboxint[i]); break; //Green
|
|
}
|
|
break;
|
|
}
|
|
drawfillrect(backboxes[i].x, backboxes[i].y, backboxes[i].width, backboxes[i].height, bcol);
|
|
|
|
backboxrect.x = backboxes[i].x + 1; backboxrect.y = backboxes[i].y + 1;
|
|
backboxrect.width = backboxes[i].width - 2; backboxrect.height = backboxes[i].height - 2;
|
|
drawfillrect(backboxrect.x, backboxrect.y, backboxrect.width, backboxrect.height, bcol2);
|
|
|
|
backboxes[i].x += backboxvx[i];
|
|
backboxes[i].y += backboxvy[i];
|
|
if (backboxes[i].x < -40) { backboxes[i].x = 320; backboxes[i].y = Math.random() * 240; }
|
|
if (backboxes[i].x > 320) { backboxes[i].x = -32; backboxes[i].y = Math.random() * 240; }
|
|
if (backboxes[i].y < -40) { backboxes[i].y = 240; backboxes[i].x = Math.random() * 320; }
|
|
if (backboxes[i].y > 260) { backboxes[i].y = -32; backboxes[i].x = Math.random() * 320; }
|
|
}
|
|
break;
|
|
case 3: //Warp zone (horizontal)
|
|
backoffset += 3; if (backoffset >= 16) backoffset -= 16;
|
|
|
|
if (forcewarpzonehorizontalupdate > 0) {
|
|
warpzonehorizontal_meshbatch.x = 0;
|
|
warpzonehorizontal_meshbatch.clear();
|
|
for (j = 0; j < 15; j++) {
|
|
for (i = -1; i < 21; i++) {
|
|
temp = 680 + (rcol * 3);
|
|
tposition.identity(); tposition.translate(int((i * 16) - backoffset), int(j * 16));
|
|
warpzonehorizontal_meshbatch.addMesh(tiles2[temp+40], tposition);
|
|
tposition.identity(); tposition.translate(int((i * 16) - backoffset + 8), int((j * 16)));
|
|
warpzonehorizontal_meshbatch.addMesh(tiles2[temp + 41], tposition);
|
|
tposition.identity(); tposition.translate(int((i * 16) - backoffset), int((j * 16) + 8));
|
|
warpzonehorizontal_meshbatch.addMesh(tiles2[temp + 80], tposition);
|
|
tposition.identity(); tposition.translate(int((i * 16) - backoffset + 8), int((j * 16) + 8));
|
|
warpzonehorizontal_meshbatch.addMesh(tiles2[temp + 81], tposition);
|
|
}
|
|
}
|
|
|
|
backbuffer.draw(warpzonehorizontal_meshbatch);
|
|
forcewarpzonehorizontalupdate--;
|
|
}else {
|
|
warpzonehorizontal_meshbatch.x = backoffset;
|
|
backbuffer.draw(warpzonehorizontal_meshbatch);
|
|
}
|
|
|
|
break;
|
|
case 4: //Warp zone (vertical)
|
|
backoffset += 3;
|
|
if (backoffset >= 16) backoffset -= 16;
|
|
|
|
if (forcewarpzoneverticalupdate > 0) {
|
|
warpzonevertical_meshbatch.y = 0;
|
|
warpzonevertical_meshbatch.clear();
|
|
for (j = -1; j < 16; j++) {
|
|
for (i = 0; i < 21; i++) {
|
|
temp = 760 + (rcol * 3);
|
|
tposition.identity(); tposition.translate(int((i * 16)), int((j * 16) - backoffset));
|
|
warpzonevertical_meshbatch.addMesh(tiles2[temp+40], tposition);
|
|
tposition.identity(); tposition.translate(int((i * 16) + 8), int((j * 16) - backoffset));
|
|
warpzonevertical_meshbatch.addMesh(tiles2[temp + 41], tposition);
|
|
tposition.identity(); tposition.translate(int((i * 16)), int((j * 16) - backoffset + 8));
|
|
warpzonevertical_meshbatch.addMesh(tiles2[temp + 80], tposition);
|
|
tposition.identity(); tposition.translate(int((i * 16) + 8), int((j * 16) - backoffset + 8));
|
|
warpzonevertical_meshbatch.addMesh(tiles2[temp + 81], tposition);
|
|
}
|
|
}
|
|
|
|
backbuffer.draw(warpzonevertical_meshbatch);
|
|
forcewarpzoneverticalupdate--;
|
|
}else {
|
|
warpzonevertical_meshbatch.y = backoffset;
|
|
backbuffer.draw(warpzonevertical_meshbatch);
|
|
}
|
|
|
|
//backbuffer.copyPixels(towerbuffer, towerbuffer.rect, tl);
|
|
break;
|
|
case 5:
|
|
//Warp zone, central
|
|
switch(rcol) {
|
|
//Akward ordering to match tileset
|
|
case 0: warpbcol = 0x0A100E; warpfcol = 0x102221; break; //Cyan
|
|
case 1: warpbcol = 0x11090B; warpfcol = 0x221011; break; //Red
|
|
case 2: warpbcol = 0x0F0A10; warpfcol = 0x221022; break; //Purple
|
|
case 3: warpbcol = 0x0A0B10; warpfcol = 0x101022; break; //Blue
|
|
case 4: warpbcol = 0x100D0A; warpfcol = 0x221E10; break; //Yellow
|
|
case 5: warpbcol = 0x0D100A; warpfcol = 0x142210; break; //Green
|
|
case 6: warpbcol = 0x0A0A0A; warpfcol = 0x121212; break; //Gray
|
|
}
|
|
|
|
backoffset += 1;
|
|
if (backoffset >= 16) {
|
|
backoffset -= 16;
|
|
warpskip = (warpskip + 1) % 2;
|
|
}
|
|
|
|
for (i = 10; i >= 0; i--) {
|
|
temp = (i << 4) + backoffset;
|
|
setwarprect(160 - temp, 120 - temp, temp * 2, temp * 2);
|
|
if (i % 2 == warpskip) {
|
|
drawfillrect(warprect.x, warprect.y, warprect.width, warprect.height, warpbcol);
|
|
}else {
|
|
drawfillrect(warprect.x, warprect.y, warprect.width, warprect.height, warpfcol);
|
|
}
|
|
}
|
|
break;
|
|
case 6:
|
|
//Final Starfield
|
|
cls(0x000000);
|
|
for (i = 0; i < 50; i++) {
|
|
if (starsspeed[i] <= 8) {
|
|
drawfillrect(stars[i].x, stars[i].y, stars[i].width, stars[i].height, 0x222222);
|
|
}else {
|
|
drawfillrect(stars[i].x, stars[i].y, stars[i].width, stars[i].height, 0x555555);
|
|
}
|
|
stars[i].y -= starsspeed[i];
|
|
if (stars[i].y < -10) {
|
|
stars[i].y += 260;
|
|
stars[i].x = Math.random() * 320;
|
|
starsspeed[i] = 5+(Math.random()*5);
|
|
}
|
|
}
|
|
break;
|
|
case 7:
|
|
//Static, unscrolling section of the tower
|
|
if (forcetowerstaticupdate > 0) {
|
|
towerbufferstatic_meshbatch.clear();
|
|
|
|
for (j = 0; j < 30; j++) {
|
|
for (i = 0; i < 40; i++) {
|
|
tposition.identity();
|
|
tposition.translate(int(i * 8), int(j * 8));
|
|
towerbufferstatic_meshbatch.addMesh(tiles3[map.tower.backat(i, j, 200) + (15 * 30)], tposition);
|
|
}
|
|
}
|
|
|
|
backbuffer.draw(towerbufferstatic_meshbatch);
|
|
forcetowerstaticupdate--;
|
|
}else {
|
|
backbuffer.draw(towerbufferstatic_meshbatch);
|
|
}
|
|
break;
|
|
case 8:
|
|
//Static, unscrolling section of the tower
|
|
if (forcetowerstaticupdate > 0) {
|
|
towerbufferstatic_meshbatch.clear();
|
|
|
|
for (j = 0; j < 30; j++) {
|
|
for (i = 0; i < 40; i++) {
|
|
tposition.identity();
|
|
tposition.translate(int(i * 8), int(j * 8));
|
|
towerbufferstatic_meshbatch.addMesh(tiles3[map.tower.backat(i, j, 200) + (15 * 10)], tposition);
|
|
}
|
|
}
|
|
|
|
backbuffer.draw(towerbufferstatic_meshbatch);
|
|
forcetowerstaticupdate--;
|
|
}else {
|
|
backbuffer.draw(towerbufferstatic_meshbatch);
|
|
}
|
|
break;
|
|
case 9:
|
|
//Static, unscrolling section of the tower
|
|
if (forcetowerstaticupdate > 0) {
|
|
towerbufferstatic_meshbatch.clear();
|
|
|
|
for (j = 0; j < 30; j++) {
|
|
for (i = 0; i < 40; i++) {
|
|
tposition.identity();
|
|
tposition.translate(int(i * 8), int(j * 8));
|
|
towerbufferstatic_meshbatch.addMesh(tiles3[map.tower.backat(i, j, 600)], tposition);
|
|
}
|
|
}
|
|
|
|
backbuffer.draw(towerbufferstatic_meshbatch);
|
|
forcetowerstaticupdate--;
|
|
}else {
|
|
backbuffer.draw(towerbufferstatic_meshbatch);
|
|
}
|
|
break;
|
|
default:
|
|
drawfillrect(0, 0, 320, 240, 0, 0, 0);
|
|
break;
|
|
}
|
|
}
|
|
|
|
public function textbox_drawimage(t:int, xp:int, yp:int, cent:Boolean=false):void {
|
|
trace("dwgfx.textbox_drawimage() is not implemented yet");
|
|
}
|
|
|
|
public function drawimage(t:int, xp:int, yp:int, cent:Boolean=false):void {
|
|
if (cent) {
|
|
tposition.identity();
|
|
tposition.translate(160 - int(images[t].width / 2), yp);
|
|
backbuffer.draw(images[t], tposition);
|
|
}else {
|
|
tposition.identity();
|
|
tposition.translate(xp, yp);
|
|
backbuffer.draw(images[t], tposition);
|
|
}
|
|
}
|
|
|
|
public function drawmobileimage(t:int, xp:int, yp:int, cent:Boolean=false):void {
|
|
if (cent) {
|
|
tposition.identity();
|
|
tposition.translate(160 - int(mobileimages[t].width / 2), yp);
|
|
backbuffer.draw(mobileimages[t], tposition);
|
|
}else {
|
|
tposition.identity();
|
|
tposition.translate(xp, yp);
|
|
backbuffer.draw(mobileimages[t], tposition);
|
|
}
|
|
}
|
|
|
|
public function drawmobilehands(t:int, xp:int, yp:int):void {
|
|
tposition.identity();
|
|
tposition.translate(xp, yp);
|
|
backbuffer.draw(mobileimages[t], tposition);
|
|
}
|
|
|
|
public function drawplayerlevelimage(t:int, xp:int, yp:int):void {
|
|
tposition.identity();
|
|
tposition.translate(xp, yp);
|
|
backbuffer.draw(playerlevelimages[t], tposition);
|
|
}
|
|
|
|
public function drawimagecol(t:int, xp:int, yp:int, r:int, g:int, b:int, cent:Boolean = false):void {
|
|
if (cent) {
|
|
tposition.identity();
|
|
tposition.translate(160 - int(images[t].width / 2), yp);
|
|
images[t].color = RGB(r, g, b);
|
|
backbuffer.draw(images[t], tposition);
|
|
}else {
|
|
tposition.identity();
|
|
tposition.translate(xp, yp);
|
|
images[t].color = RGB(r, g, b);
|
|
backbuffer.draw(images[t], tposition);
|
|
}
|
|
}
|
|
|
|
public function crewcolour(t:int):int {
|
|
//given crewmate t, return colour in setcol
|
|
if (t == 0) return 0;
|
|
if (t == 1) return 20;
|
|
if (t == 2) return 14;
|
|
if (t == 3) return 15;
|
|
if (t == 4) return 13;
|
|
if (t == 5) return 16;
|
|
return 0;
|
|
}
|
|
|
|
public function setcol(t:int, help:helpclass):void {
|
|
//Setup predefinied colours as per our zany palette
|
|
switch(t) {
|
|
//Player Normal
|
|
case 0: ct.color = RGB(160- help.glow/2 - (Math.random()*20), 200- help.glow/2, 220 - help.glow); break;
|
|
//Player Hurt
|
|
case 1: ct.color = RGB(196 - (Math.random() * 64), 10, 10); break;
|
|
//Enemies and stuff
|
|
case 2: ct.color = RGB(225-(help.glow/2), 75, 30); break;
|
|
case 3: //Trinket
|
|
if (!trinketcolset) {
|
|
trinketr = 200 - (Math.random() * 64);
|
|
trinketg = 200 - (Math.random() * 128);
|
|
trinketb = 164 + (Math.random() * 60);
|
|
trinketcolset = true;
|
|
}
|
|
ct.color = RGB(trinketr, trinketg, trinketb);
|
|
break;
|
|
case 4: //Inactive savepoint
|
|
temp = (help.glow/2) + (Math.random() * 8);
|
|
ct.color = RGB(80 + temp, 80 + temp, 80 + temp);
|
|
break;
|
|
case 5: //Active savepoint
|
|
ct.color = RGB(164+(Math.random()*64),164+(Math.random()*64), 255-(Math.random()*64))
|
|
break;
|
|
case 6: //Enemy : Red
|
|
ct.color = RGB(250 - help.glow/2, 60- help.glow/2, 60 - help.glow/2);
|
|
break;
|
|
case 7: //Enemy : Green
|
|
ct.color = RGB(100 - help.glow/2 - (Math.random()*30), 250 - help.glow/2, 100 - help.glow/2 - (Math.random()*30));
|
|
break;
|
|
case 8: //Enemy : Purple
|
|
ct.color = RGB(250 - help.glow/2, 20, 128 - help.glow/2 + (Math.random()*30));
|
|
break;
|
|
case 9: //Enemy : Yellow
|
|
ct.color = RGB(250 - help.glow/2, 250 - help.glow/2, 20);
|
|
break;
|
|
case 10: //Warp point (white)
|
|
ct.color = RGB(255 - (Math.random() * 64), 255 - (Math.random() * 64), 255 - (Math.random() * 64));
|
|
break;
|
|
case 11: //Enemy : Cyan
|
|
ct.color = RGB(20, 250 - help.glow/2, 250 - help.glow/2);
|
|
break;
|
|
case 12: //Enemy : Blue
|
|
ct.color = RGB(90- help.glow/2, 90 - help.glow/2, 250 - help.glow/2);
|
|
break;
|
|
//Crew Members
|
|
//green
|
|
case 13: ct.color = RGB(120- help.glow/4 - (Math.random()*20), 220 - help.glow/4, 120- help.glow/4); break;
|
|
//Yellow
|
|
case 14: ct.color = RGB(220- help.glow/4 - (Math.random()*20), 210 - help.glow/4, 120- help.glow/4); break;
|
|
//pink
|
|
case 15: ct.color = RGB(255 - help.glow/8, 70 - help.glow/4, 70 - help.glow / 4); break;
|
|
//Blue
|
|
case 16: ct.color = RGB(75, 75, 255- help.glow/4 - (Math.random()*20)); break;
|
|
|
|
|
|
case 17: //Enemy : Orange
|
|
ct.color = RGB(250 - help.glow/2, 130 - help.glow/2, 20);
|
|
break;
|
|
case 18: //Enemy : Gray
|
|
ct.color = RGB(130- help.glow/2, 130 - help.glow/2, 130 - help.glow/2);
|
|
break;
|
|
case 19: //Enemy : Dark gray
|
|
ct.color = RGB(60- help.glow/8, 60 - help.glow/8, 60 - help.glow/8);
|
|
break;
|
|
//Purple
|
|
case 20: ct.color = RGB(220 - help.glow / 4 - (Math.random() * 20), 120 - help.glow / 4, 210 - help.glow / 4); break;
|
|
|
|
case 21: //Enemy : Light Gray
|
|
ct.color = RGB(180- help.glow/2, 180 - help.glow/2, 180 - help.glow/2);
|
|
break;
|
|
case 22: //Enemy : Indicator Gray
|
|
ct.color = RGB(230- help.glow/2, 230- help.glow/2, 230- help.glow/2);
|
|
break;
|
|
case 23: //Enemy : Indicator Gray
|
|
ct.color = RGB(255- help.glow/2 - (Math.random() * 40) , 255- help.glow/2 - (Math.random() * 40), 255- help.glow/2 - (Math.random() * 40));
|
|
break;
|
|
|
|
//Trophies
|
|
//cyan
|
|
case 30: ct.color = RGBf(160, 200, 220); break;
|
|
//Purple
|
|
case 31: ct.color = RGBf(220, 120, 210); break;
|
|
//Yellow
|
|
case 32: ct.color = RGBf(220, 210, 120); break;
|
|
//red
|
|
case 33: ct.color = RGBf(255, 70, 70); break;
|
|
//green
|
|
case 34: ct.color = RGBf(120, 220, 120); break;
|
|
//Blue
|
|
case 35: ct.color = RGBf(75, 75, 255); break;
|
|
//Gold
|
|
case 36: ct.color = RGB(180, 120, 20); break;
|
|
case 37: //Trinket
|
|
if (!trinketcolset) {
|
|
trinketr = 200 - (Math.random() * 64);
|
|
trinketg = 200 - (Math.random() * 128);
|
|
trinketb = 164 + (Math.random() * 60);
|
|
trinketcolset = true;
|
|
}
|
|
ct.color = RGBf(trinketr, trinketg, trinketb);
|
|
break;
|
|
//Silver
|
|
case 38: ct.color = RGBf(196, 196, 196); break;
|
|
//Bronze
|
|
case 39: ct.color = RGBf(128, 64, 10); break;
|
|
//Awesome
|
|
case 40: //Teleporter in action!
|
|
temp = Math.random() * 150;
|
|
if(temp<33){
|
|
ct.color = RGBf(255 - (Math.random() * 64), 64 + (Math.random() * 64), 64 + (Math.random() * 64));
|
|
}else if (temp < 66) {
|
|
ct.color = RGBf(64 + (Math.random() * 64), 255 - (Math.random() * 64), 64 + (Math.random() * 64));
|
|
}else if (temp < 100) {
|
|
ct.color = RGBf(64 + (Math.random() * 64), 64 + (Math.random() * 64), 255 - (Math.random() * 64));
|
|
}else {
|
|
ct.color = RGBf(164+(Math.random()*64),164+(Math.random()*64), 255-(Math.random()*64))
|
|
}
|
|
break;
|
|
|
|
case 100: //Inactive Teleporter
|
|
temp = (help.glow/2) + (Math.random() * 8);
|
|
ct.color = RGB(42 + temp, 42 + temp, 42 + temp);
|
|
break;
|
|
case 101: //Active Teleporter
|
|
ct.color = RGB(164+(Math.random()*64),164+(Math.random()*64), 255-(Math.random()*64))
|
|
break;
|
|
case 102: //Teleporter in action!
|
|
temp = Math.random() * 150;
|
|
if(temp<33){
|
|
ct.color = RGB(255 - (Math.random() * 64), 64 + (Math.random() * 64), 64 + (Math.random() * 64));
|
|
}else if (temp < 66) {
|
|
ct.color = RGB(64 + (Math.random() * 64), 255 - (Math.random() * 64), 64 + (Math.random() * 64));
|
|
}else if (temp < 100) {
|
|
ct.color = RGB(64 + (Math.random() * 64), 64 + (Math.random() * 64), 255 - (Math.random() * 64));
|
|
}else {
|
|
ct.color = RGB(164+(Math.random()*64),164+(Math.random()*64), 255-(Math.random()*64))
|
|
}
|
|
break;
|
|
|
|
default: ct.color = 0xFFFFFF; break;
|
|
}
|
|
}
|
|
|
|
public function setcolreal(t:int):void {
|
|
ct.color = t;
|
|
}
|
|
|
|
public function textbox_drawcoloredtile(x:int, y:int, t:int, r:int, g:int, b:int):void {
|
|
trace("dwgfx.textbox_drawcoloredtile() is not implemented yet");
|
|
}
|
|
|
|
public function drawcoloredtile(x:int, y:int, t:int, r:int, g:int, b:int):void {
|
|
tposition.identity();
|
|
tposition.translate(x, y);
|
|
|
|
tiles[t].color = RGB(r, g, b);
|
|
backbuffer.draw(tiles[t], tposition);
|
|
}
|
|
|
|
public function drawhuetile(x:int, y:int, t:int, c:int):void {
|
|
tposition.identity();
|
|
tposition.translate(x, y);
|
|
switch(c) {
|
|
case 0: tiles[t].color = RGB(250-(Math.random()*32), 250-(Math.random()*32), 10); break;
|
|
case 1: tiles[t].color = RGB(250-(Math.random()*32), 250-(Math.random()*32), 10); break;
|
|
|
|
default: tiles[t].color = RGB(250-(Math.random()*32), 250-(Math.random()*32), 10); break;
|
|
}
|
|
|
|
backbuffer.draw(tiles[t], tposition);
|
|
}
|
|
|
|
public function drawcrewman(x:int, y:int, t:int, act:Boolean, help:helpclass, noshift:Boolean=false):void {
|
|
if (!act) {
|
|
if (noshift) {
|
|
if (flipmode) { drawspritesetcol(x, y, 14, 19, help);
|
|
}else{ drawspritesetcol(x, y, 12, 19, help); }
|
|
}else{
|
|
if (flipmode) { drawspritesetcol(x - 8, y, 14, 19, help);
|
|
}else{ drawspritesetcol(x - 8, y, 12, 19, help); }
|
|
}
|
|
}else {
|
|
if (flipmode) crewframe += 6;
|
|
|
|
switch(t) {
|
|
case 0: drawspritesetcol(x, y, crewframe, 0, help); break;
|
|
case 1: drawspritesetcol(x, y, crewframe, 20, help); break;
|
|
case 2: drawspritesetcol(x, y, crewframe, 14, help); break;
|
|
case 3: drawspritesetcol(x, y, crewframe, 15, help); break;
|
|
case 4: drawspritesetcol(x, y, crewframe, 13, help); break;
|
|
case 5: drawspritesetcol(x, y, crewframe, 16, help); break;
|
|
}
|
|
|
|
if (flipmode) crewframe -= 6;
|
|
}
|
|
}
|
|
|
|
public function drawtrophytext(obj:entityclass, help:helpclass):void {
|
|
if (obj.trophytext < 15) {
|
|
temp = (196 * obj.trophytext) / 15; temp2 = (196 * obj.trophytext) / 15; temp3 = ((255 - help.glow) * obj.trophytext) / 15;
|
|
}else { temp = 196; temp2 = 196; temp3 = 255 - help.glow; }
|
|
switch(obj.trophytype) {
|
|
case 1:
|
|
print( -1, 6, "SPACE STATION 1 MASTERED", temp, temp2, temp3, true);
|
|
print( -1, 16, "Obtain a V Rank in this Time Trial", temp, temp2, temp3, true);
|
|
break;
|
|
case 2:
|
|
print( -1, 6, "LABORATORY MASTERED", temp, temp2, temp3, true);
|
|
print( -1, 16, "Obtain a V Rank in this Time Trial", temp, temp2, temp3, true);
|
|
break;
|
|
case 3:
|
|
print( -1, 6, "THE TOWER MASTERED", temp, temp2, temp3, true);
|
|
print( -1, 16, "Obtain a V Rank in this Time Trial", temp, temp2, temp3, true);
|
|
break;
|
|
case 4:
|
|
print( -1, 6, "SPACE STATION 2 MASTERED", temp, temp2, temp3, true);
|
|
print( -1, 16, "Obtain a V Rank in this Time Trial", temp, temp2, temp3, true);
|
|
break;
|
|
case 5:
|
|
print( -1, 6, "WARP ZONE MASTERED", temp, temp2, temp3, true);
|
|
print( -1, 16, "Obtain a V Rank in this Time Trial", temp, temp2, temp3, true);
|
|
break;
|
|
case 6:
|
|
print( -1, 6, "FINAL LEVEL MASTERED", temp, temp2, temp3, true);
|
|
print( -1, 16, "Obtain a V Rank in this Time Trial", temp, temp2, temp3, true);
|
|
break;
|
|
case 7:
|
|
print( -1, 6, "GAME COMPLETE", temp, temp2, temp3, true);
|
|
print( -1, 16, "Complete the game", temp, temp2, temp3, true);
|
|
break;
|
|
case 8:
|
|
print( -1, 6, "FLIP MODE COMPLETE", temp, temp2, temp3, true);
|
|
print( -1, 16, "Complete the game in flip mode", temp, temp2, temp3, true);
|
|
break;
|
|
case 9:
|
|
print( -1, 11, "Win with less than 50 deaths", temp, temp2, temp3, true);
|
|
break;
|
|
case 10:
|
|
print( -1, 11, "Win with less than 100 deaths", temp, temp2, temp3, true);
|
|
break;
|
|
case 11:
|
|
print( -1, 11, "Win with less than 250 deaths", temp, temp2, temp3, true);
|
|
break;
|
|
case 12:
|
|
print( -1, 11, "Win with less than 500 deaths", temp, temp2, temp3, true);
|
|
break;
|
|
case 13:
|
|
print( -1, 11, "Last 5 seconds on the Super Gravitron", temp, temp2, temp3, true);
|
|
break;
|
|
case 14:
|
|
print( -1, 11, "Last 10 seconds on the Super Gravitron", temp, temp2, temp3, true);
|
|
break;
|
|
case 15:
|
|
print( -1, 11, "Last 15 seconds on the Super Gravitron", temp, temp2, temp3, true);
|
|
break;
|
|
case 16:
|
|
print( -1, 11, "Last 20 seconds on the Super Gravitron", temp, temp2, temp3, true);
|
|
break;
|
|
case 17:
|
|
print( -1, 11, "Last 30 seconds on the Super Gravitron", temp, temp2, temp3, true);
|
|
break;
|
|
case 18:
|
|
print( -1, 11, "Last 1 minute on the Super Gravitron", temp, temp2, temp3, true);
|
|
break;
|
|
case 20:
|
|
print( -1, 6, "MASTER OF THE UNIVERSE", temp, temp2, temp3, true);
|
|
print( -1, 16, "Complete the game in no death mode", temp, temp2, temp3, true);
|
|
break;
|
|
}
|
|
}
|
|
|
|
public function drawsprite(x:int, y:int, t:int, r:int, g:int, b:int):void {
|
|
sprites[t].color = RGB(r, g, b);
|
|
tposition.identity();
|
|
tposition.translate(x, y);
|
|
backbuffer.draw(sprites[t], tposition);
|
|
}
|
|
|
|
public function textbox_drawsprite(x:int, y:int, t:int, r:int, g:int, b:int):void {
|
|
trace("dwgfx.textbox_drawsprite() is not implemented yet");
|
|
}
|
|
|
|
public function drawgravityline(t:int, obj:entityclass):void {
|
|
if (obj.entities[t].life == 0) {
|
|
switch(linestate) {
|
|
case 0: drawfillrect(line_rect.x, line_rect.y, line_rect.width, line_rect.height, 200 - 20, 200 - 20, 200 - 20); break;
|
|
case 1: drawfillrect(line_rect.x, line_rect.y, line_rect.width, line_rect.height, 225 - 30, 245 - 30, 245 - 30); break;
|
|
case 2: drawfillrect(line_rect.x, line_rect.y, line_rect.width, line_rect.height, 245 - 30, 245 - 30, 225 - 30); break;
|
|
case 3: drawfillrect(line_rect.x, line_rect.y, line_rect.width, line_rect.height, 164 - 10, 200 - 20, 200 - 20); break;
|
|
case 4: drawfillrect(line_rect.x, line_rect.y, line_rect.width, line_rect.height, 224 - 20, 255 - 30, 196 - 20); break;
|
|
case 5: drawfillrect(line_rect.x, line_rect.y, line_rect.width, line_rect.height, 205 - 20, 235 - 30, 196 - 20); break;
|
|
case 6: drawfillrect(line_rect.x, line_rect.y, line_rect.width, line_rect.height, 164 - 10, 164 - 10, 164 - 10); break;
|
|
case 7: drawfillrect(line_rect.x, line_rect.y, line_rect.width, line_rect.height, 225 - 30, 245 - 30, 205 - 20); break;
|
|
case 8: drawfillrect(line_rect.x, line_rect.y, line_rect.width, line_rect.height, 205 - 20, 255 - 30, 225 - 30); break;
|
|
case 9: drawfillrect(line_rect.x, line_rect.y, line_rect.width, line_rect.height, 245 - 30, 245 - 30, 245 - 30); break;
|
|
}
|
|
}else{
|
|
drawfillrect(line_rect.x, line_rect.y, line_rect.width, line_rect.height, 96, 96, 96);
|
|
}
|
|
}
|
|
|
|
public function drawentities(map:mapclass, obj:entityclass, help:helpclass):void {
|
|
//Update line colours!
|
|
if (linedelay <= 0) {
|
|
linestate++;
|
|
if (linestate >= 10) linestate = 0;
|
|
linedelay = 2;
|
|
}else {
|
|
linedelay--;
|
|
}
|
|
|
|
var j:int, k:int;
|
|
for (var i:int = obj.nentity - 1; i >= 0; i--) {
|
|
if (!obj.entities[i].invis && obj.entities[i].active) {
|
|
if (obj.entities[i].size == 0) { // Sprites
|
|
if (flipmode) {
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp), int(obj.entities[i].yp));
|
|
setcol(obj.entities[i].colour, help);
|
|
flipsprites[obj.entities[i].drawframe].color = ct.color;
|
|
backbuffer.draw(flipsprites[obj.entities[i].drawframe], tposition);
|
|
if (map.warpx) {
|
|
//screenwrapping!
|
|
if (tpoint.x < 0) {
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp) + 320, int(obj.entities[i].yp));
|
|
backbuffer.draw(flipsprites[obj.entities[i].drawframe], tposition);
|
|
}
|
|
if (tpoint.x > 300) {
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp) - 320, int(obj.entities[i].yp));
|
|
backbuffer.draw(flipsprites[obj.entities[i].drawframe], tposition);
|
|
}
|
|
}else if (map.warpy) {
|
|
if (tpoint.y < 0) {
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp), int(obj.entities[i].yp) + 230);
|
|
backbuffer.draw(flipsprites[obj.entities[i].drawframe], tposition);
|
|
}
|
|
if (tpoint.y > 210) {
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp), int(obj.entities[i].yp) - 230);
|
|
backbuffer.draw(flipsprites[obj.entities[i].drawframe], tposition);
|
|
}
|
|
}
|
|
}else {
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp), int(obj.entities[i].yp));
|
|
setcol(obj.entities[i].colour, help);
|
|
sprites[obj.entities[i].drawframe].color = ct.color;
|
|
backbuffer.draw(sprites[obj.entities[i].drawframe], tposition);
|
|
if (map.warpx) {
|
|
//screenwrapping!
|
|
if (tpoint.x < 0) {
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp) + 320, int(obj.entities[i].yp));
|
|
backbuffer.draw(sprites[obj.entities[i].drawframe], tposition);
|
|
}
|
|
if (tpoint.x > 300) {
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp) - 320, int(obj.entities[i].yp));
|
|
backbuffer.draw(sprites[obj.entities[i].drawframe], tposition);
|
|
}
|
|
}else if (map.warpy) {
|
|
if (tpoint.y < 0) {
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp), int(obj.entities[i].yp) + 230);
|
|
backbuffer.draw(sprites[obj.entities[i].drawframe], tposition);
|
|
}
|
|
if (tpoint.y > 210) {
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp), int(obj.entities[i].yp) - 230);
|
|
backbuffer.draw(sprites[obj.entities[i].drawframe], tposition);
|
|
}
|
|
}
|
|
}
|
|
}else if (obj.entities[i].size == 1) { // Tiles
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp), int(obj.entities[i].yp));
|
|
backbuffer.draw(tiles[obj.entities[i].drawframe], tposition);
|
|
}else if (obj.entities[i].size == 2) { // Special: Moving platform, 4 tiles
|
|
tposition.identity(); tposition.translate(int(obj.entities[i].xp), int(obj.entities[i].yp));
|
|
if (map.custommode) {
|
|
backbuffer.draw(entcolours[obj.entities[i].drawframe], tposition);
|
|
tposition.identity(); tposition.translate(int(obj.entities[i].xp) + 8, int(obj.entities[i].yp));
|
|
backbuffer.draw(entcolours[obj.entities[i].drawframe], tposition);
|
|
tposition.identity(); tposition.translate(int(obj.entities[i].xp) + 16, int(obj.entities[i].yp));
|
|
backbuffer.draw(entcolours[obj.entities[i].drawframe], tposition)
|
|
tposition.identity(); tposition.translate(int(obj.entities[i].xp) + 24, int(obj.entities[i].yp));
|
|
backbuffer.draw(entcolours[obj.entities[i].drawframe], tposition)
|
|
}else {
|
|
backbuffer.draw(tiles[obj.entities[i].drawframe], tposition);
|
|
tposition.identity(); tposition.translate(int(obj.entities[i].xp) + 8, int(obj.entities[i].yp));
|
|
backbuffer.draw(tiles[obj.entities[i].drawframe], tposition);
|
|
tposition.identity(); tposition.translate(int(obj.entities[i].xp) + 16, int(obj.entities[i].yp));
|
|
backbuffer.draw(tiles[obj.entities[i].drawframe], tposition)
|
|
tposition.identity(); tposition.translate(int(obj.entities[i].xp) + 24, int(obj.entities[i].yp));
|
|
backbuffer.draw(tiles[obj.entities[i].drawframe], tposition)
|
|
}
|
|
}else if (obj.entities[i].size == 3) { // Big chunky pixels!
|
|
prect.x = int(obj.entities[i].xp); prect.y = int(obj.entities[i].yp);
|
|
//A seperate index of colours, for simplicity
|
|
if (obj.entities[i].colour == 1) {
|
|
drawfillrect(prect.x, prect.y, prect.width, prect.height, 196 - (Math.random() * 64), 10, 10);
|
|
}else if (obj.entities[i].colour == 2) {
|
|
drawfillrect(prect.x, prect.y, prect.width, prect.height, 160 - help.glow / 2 - (Math.random() * 20), 200 - help.glow / 2, 220 - help.glow);
|
|
}
|
|
}else if (obj.entities[i].size == 4) { // Small pickups
|
|
drawhuetile(int(obj.entities[i].xp), int(obj.entities[i].yp), obj.entities[i].tile, obj.entities[i].colour);
|
|
}else if (obj.entities[i].size == 5) { //Horizontal Line
|
|
line_rect.x = int(obj.entities[i].xp); line_rect.y = int(obj.entities[i].yp);
|
|
line_rect.width = obj.entities[i].w; line_rect.height = 1;
|
|
drawgravityline(i, obj);
|
|
}else if (obj.entities[i].size == 6) { //Vertical Line
|
|
line_rect.x = int(obj.entities[i].xp); line_rect.y = int(obj.entities[i].yp);
|
|
line_rect.width = 1; line_rect.height = obj.entities[i].h;
|
|
drawgravityline(i, obj);
|
|
}else if (obj.entities[i].size == 7) { //Teleporter
|
|
drawtele(int(obj.entities[i].xp), int(obj.entities[i].yp), obj.entities[i].drawframe, obj.entities[i].colour, help);
|
|
}else if (obj.entities[i].size == 8) { // Special: Moving platform, 8 tiles
|
|
tposition.identity(); tposition.translate(int(obj.entities[i].xp), int(obj.entities[i].yp));
|
|
if (map.custommode) {
|
|
backbuffer.draw(entcolours[obj.entities[i].drawframe], tposition);
|
|
tposition.identity(); tposition.translate(int(obj.entities[i].xp + 8), int(obj.entities[i].yp));
|
|
backbuffer.draw(entcolours[obj.entities[i].drawframe], tposition);
|
|
tposition.identity(); tposition.translate(int(obj.entities[i].xp + 16), int(obj.entities[i].yp));
|
|
backbuffer.draw(entcolours[obj.entities[i].drawframe], tposition);
|
|
tposition.identity(); tposition.translate(int(obj.entities[i].xp + 24), int(obj.entities[i].yp));
|
|
backbuffer.draw(entcolours[obj.entities[i].drawframe], tposition);
|
|
tposition.identity(); tposition.translate(int(obj.entities[i].xp + 32), int(obj.entities[i].yp));
|
|
backbuffer.draw(entcolours[obj.entities[i].drawframe], tposition);
|
|
tposition.identity(); tposition.translate(int(obj.entities[i].xp + 40), int(obj.entities[i].yp));
|
|
backbuffer.draw(entcolours[obj.entities[i].drawframe], tposition);
|
|
tposition.identity(); tposition.translate(int(obj.entities[i].xp + 48), int(obj.entities[i].yp));
|
|
backbuffer.draw(entcolours[obj.entities[i].drawframe], tposition);
|
|
tposition.identity(); tposition.translate(int(obj.entities[i].xp + 56), int(obj.entities[i].yp));
|
|
backbuffer.draw(entcolours[obj.entities[i].drawframe], tposition);
|
|
}else{
|
|
backbuffer.draw(tiles[obj.entities[i].drawframe], tposition);
|
|
tposition.identity(); tposition.translate(int(obj.entities[i].xp + 8), int(obj.entities[i].yp));
|
|
backbuffer.draw(tiles[obj.entities[i].drawframe], tposition);
|
|
tposition.identity(); tposition.translate(int(obj.entities[i].xp + 16), int(obj.entities[i].yp));
|
|
backbuffer.draw(tiles[obj.entities[i].drawframe], tposition);
|
|
tposition.identity(); tposition.translate(int(obj.entities[i].xp + 24), int(obj.entities[i].yp));
|
|
backbuffer.draw(tiles[obj.entities[i].drawframe], tposition);
|
|
tposition.identity(); tposition.translate(int(obj.entities[i].xp + 32), int(obj.entities[i].yp));
|
|
backbuffer.draw(tiles[obj.entities[i].drawframe], tposition);
|
|
tposition.identity(); tposition.translate(int(obj.entities[i].xp + 40), int(obj.entities[i].yp));
|
|
backbuffer.draw(tiles[obj.entities[i].drawframe], tposition);
|
|
tposition.identity(); tposition.translate(int(obj.entities[i].xp + 48), int(obj.entities[i].yp));
|
|
backbuffer.draw(tiles[obj.entities[i].drawframe], tposition);
|
|
tposition.identity(); tposition.translate(int(obj.entities[i].xp + 56), int(obj.entities[i].yp));
|
|
backbuffer.draw(tiles[obj.entities[i].drawframe], tposition);
|
|
}
|
|
}else if (obj.entities[i].size == 9) { // Really Big Sprite! (2x2)
|
|
if (flipmode) {
|
|
setcol(obj.entities[i].colour, help);
|
|
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp), int(obj.entities[i].yp));
|
|
flipsprites[obj.entities[i].drawframe].color = ct.color;
|
|
backbuffer.draw(flipsprites[obj.entities[i].drawframe], tposition);
|
|
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp) + 32, int(obj.entities[i].yp));
|
|
flipsprites[obj.entities[i].drawframe + 1].color = ct.color;
|
|
backbuffer.draw(flipsprites[obj.entities[i].drawframe + 1], tposition);
|
|
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp), int(obj.entities[i].yp) + 32);
|
|
flipsprites[obj.entities[i].drawframe + 12].color = ct.color;
|
|
backbuffer.draw(flipsprites[obj.entities[i].drawframe + 12], tposition);
|
|
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp) + 32, int(obj.entities[i].yp) + 32);
|
|
flipsprites[obj.entities[i].drawframe + 13].color = ct.color;
|
|
backbuffer.draw(flipsprites[obj.entities[i].drawframe + 13], tposition);
|
|
}else{
|
|
setcol(obj.entities[i].colour, help);
|
|
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp), int(obj.entities[i].yp));
|
|
sprites[obj.entities[i].drawframe].color = ct.color;
|
|
backbuffer.draw(sprites[obj.entities[i].drawframe], tposition);
|
|
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp) + 32, int(obj.entities[i].yp));
|
|
sprites[obj.entities[i].drawframe + 1].color = ct.color;
|
|
backbuffer.draw(sprites[obj.entities[i].drawframe + 1], tposition);
|
|
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp), int(obj.entities[i].yp) + 32);
|
|
sprites[obj.entities[i].drawframe + 12].color = ct.color;
|
|
backbuffer.draw(sprites[obj.entities[i].drawframe + 12], tposition);
|
|
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp) + 32, int(obj.entities[i].yp) + 32);
|
|
sprites[obj.entities[i].drawframe + 13].color = ct.color;
|
|
backbuffer.draw(sprites[obj.entities[i].drawframe + 13], tposition);
|
|
}
|
|
}else if (obj.entities[i].size == 10) { // 2x1 Sprite
|
|
if (flipmode) {
|
|
setcol(obj.entities[i].colour, help);
|
|
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp), int(obj.entities[i].yp));
|
|
flipsprites[obj.entities[i].drawframe].color = ct.color;
|
|
backbuffer.draw(flipsprites[obj.entities[i].drawframe], tposition);
|
|
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp) + 32, int(obj.entities[i].yp));
|
|
flipsprites[obj.entities[i].drawframe + 1].color = ct.color;
|
|
backbuffer.draw(flipsprites[obj.entities[i].drawframe + 1], tposition);
|
|
}else{
|
|
setcol(obj.entities[i].colour, help);
|
|
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp), int(obj.entities[i].yp));
|
|
sprites[obj.entities[i].drawframe].color = ct.color;
|
|
backbuffer.draw(sprites[obj.entities[i].drawframe], tposition);
|
|
|
|
tposition.identity();
|
|
tposition.translate(int(obj.entities[i].xp) + 32, int(obj.entities[i].yp));
|
|
sprites[obj.entities[i].drawframe + 1].color = ct.color;
|
|
backbuffer.draw(sprites[obj.entities[i].drawframe + 1], tposition);
|
|
}
|
|
}else if (obj.entities[i].size == 11) { //The fucking elephant
|
|
setcol(obj.entities[i].colour, help);
|
|
images[3].color = ct.color;
|
|
drawimage(3, int(obj.entities[i].xp), int(obj.entities[i].yp));
|
|
}else if (obj.entities[i].size == 12) { // Regular sprites that don't wrap
|
|
if (flipmode) {
|
|
//forget this for a minute;
|
|
tpoint.x = int(obj.entities[i].xp); tpoint.y = int(obj.entities[i].yp);
|
|
setcol(obj.entities[i].colour, help);
|
|
flipsprites[obj.entities[i].drawframe].color = ct.color;
|
|
tposition.identity();
|
|
tposition.translate(tpoint.x, tpoint.y);
|
|
backbuffer.draw(flipsprites[obj.entities[i].drawframe], tposition);
|
|
|
|
//if we're outside the screen, we need to draw indicators
|
|
if (obj.entities[i].xp < -20 && obj.entities[i].vx > 0) {
|
|
if (obj.entities[i].xp < -100) {
|
|
tpoint.x = -5 + (int(( -obj.entities[i].xp) / 10));
|
|
}else{
|
|
tpoint.x = 5;
|
|
}
|
|
|
|
tpoint.y = tpoint.y+4;
|
|
setcol(23, help);
|
|
tiles[1167].color = ct.color;
|
|
tposition.identity();
|
|
tposition.translate(tpoint.x, tpoint.y);
|
|
|
|
backbuffer.draw(tiles[1167], tposition);
|
|
}else if (obj.entities[i].xp > 340 && obj.entities[i].vx < 0) {
|
|
if (obj.entities[i].xp > 420) {
|
|
tpoint.x = 320 - (int(( obj.entities[i].xp-320) / 10));
|
|
}else{
|
|
tpoint.x = 310;
|
|
}
|
|
|
|
tpoint.y = tpoint.y+4;
|
|
setcol(23, help);
|
|
tiles[1166].color = ct.color;
|
|
|
|
tposition.identity();
|
|
tposition.translate(tpoint.x, tpoint.y);
|
|
|
|
backbuffer.draw(tiles[1166], tposition);
|
|
}
|
|
}else{
|
|
tpoint.x = int(obj.entities[i].xp); tpoint.y = int(obj.entities[i].yp);
|
|
setcol(obj.entities[i].colour, help);
|
|
sprites[obj.entities[i].drawframe].color = ct.color;
|
|
tposition.identity();
|
|
tposition.translate(tpoint.x, tpoint.y);
|
|
backbuffer.draw(sprites[obj.entities[i].drawframe], tposition);
|
|
|
|
//if we're outside the screen, we need to draw indicators
|
|
|
|
if (obj.entities[i].xp < -20 && obj.entities[i].vx > 0) {
|
|
if (obj.entities[i].xp < -100) {
|
|
tpoint.x = -5 + (int(( -obj.entities[i].xp) / 10));
|
|
}else{
|
|
tpoint.x = 5;
|
|
}
|
|
|
|
tpoint.y = tpoint.y+4;
|
|
setcol(23, help);
|
|
tiles[1167].color = ct.color;
|
|
tposition.identity();
|
|
tposition.translate(tpoint.x, tpoint.y);
|
|
|
|
backbuffer.draw(tiles[1167], tposition);
|
|
}else if (obj.entities[i].xp > 340 && obj.entities[i].vx < 0) {
|
|
if (obj.entities[i].xp > 420) {
|
|
tpoint.x = 320 - (int(( obj.entities[i].xp-320) / 10));
|
|
}else{
|
|
tpoint.x = 310;
|
|
}
|
|
|
|
tpoint.y = tpoint.y+4;
|
|
setcol(23, help);
|
|
tiles[1166].color = ct.color;
|
|
|
|
tposition.identity();
|
|
tposition.translate(tpoint.x, tpoint.y);
|
|
|
|
backbuffer.draw(tiles[1166], tposition);
|
|
}
|
|
}
|
|
}else if (obj.entities[i].size == 13) { // Special for epilogue: huge hero!
|
|
if (flipmode) {
|
|
tposition.identity();
|
|
tposition.scale(6, 6);
|
|
tposition.translate(int(obj.entities[i].xp), int(obj.entities[i].yp));
|
|
|
|
setcol(obj.entities[i].colour, help);
|
|
flipsprites[obj.entities[i].drawframe].color = ct.color;
|
|
backbuffer.draw(flipsprites[obj.entities[i].drawframe], tposition);
|
|
}else {
|
|
tposition.identity();
|
|
tposition.scale(6, 6);
|
|
tposition.translate(int(obj.entities[i].xp), int(obj.entities[i].yp));
|
|
|
|
setcol(obj.entities[i].colour, help);
|
|
sprites[obj.entities[i].drawframe].color = ct.color;
|
|
backbuffer.draw(sprites[obj.entities[i].drawframe], tposition);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public function drawbuffertile(x:int, y:int, t:int):void {
|
|
trace("dwgfx.drawbuffertile() is not implemented yet");
|
|
}
|
|
|
|
public function drawforetile(x:int, y:int, t:int):void {
|
|
tposition.identity();
|
|
tposition.translate(x, y);
|
|
frontbuffer_meshbatch.addMesh(tiles[t], tposition);
|
|
}
|
|
|
|
public function drawforetile2(x:int, y:int, t:int):void {
|
|
tposition.identity();
|
|
tposition.translate(x, y);
|
|
frontbuffer_meshbatch.addMesh(tiles2[t], tposition);
|
|
}
|
|
|
|
public function drawforetile3(x:int, y:int, t:int, off:int):void {
|
|
tposition.identity();
|
|
tposition.translate(x, y);
|
|
frontbuffer_meshbatch.addMesh(tiles3[t+(off*30)], tposition);
|
|
}
|
|
|
|
public function drawtele(x:int, y:int, t:int, c:int, help:helpclass):void {
|
|
tele[0].color = RGB(16, 16, 16);
|
|
tposition.identity();
|
|
tposition.translate(x, y);
|
|
backbuffer.draw(tele[0], tposition);
|
|
|
|
setcol(c, help);
|
|
if (t > 9) t = 8; if (t < 0) t = 0;
|
|
tele[t].color = ct.color;
|
|
|
|
tposition.identity();
|
|
tposition.translate(x, y);
|
|
backbuffer.draw(tele[t], tposition);
|
|
}
|
|
|
|
public function drawtile(x:int, y:int, t:int):void {
|
|
tposition.identity();
|
|
tposition.translate(x, y);
|
|
backbuffer.draw(tiles[t], tposition);
|
|
}
|
|
|
|
public function drawtile2(x:int, y:int, t:int):void {
|
|
tposition.identity();
|
|
tposition.translate(x, y);
|
|
backbuffer.draw(tiles2[t], tposition);
|
|
}
|
|
|
|
public function drawtile3(x:int, y:int, t:int, off:int):void {
|
|
tposition.identity();
|
|
tposition.translate(x, y);
|
|
backbuffer.draw(tiles3[t + (off * 30)], tposition);
|
|
}
|
|
|
|
public function drawtile3_batch(x:int, y:int, t:int, off:int):void {
|
|
tposition.identity();
|
|
tposition.translate(x, y);
|
|
towerbufferforeground_meshbatch.addMesh(tiles3[t + (off * 30)], tposition);
|
|
}
|
|
|
|
public function drawtowertile3(x:int, y:int, t:int, off:int):void {
|
|
tposition.identity();
|
|
tposition.translate(x, y);
|
|
towerbufferbackground_meshbatch.addMesh(tiles3[t+(off*30)], tposition);
|
|
}
|
|
|
|
public function drawtowertile(x:int, y:int, t:int):void {
|
|
tposition.identity();
|
|
tposition.translate(x, y);
|
|
backbuffer.draw(tiles2[t], tposition);
|
|
}
|
|
|
|
public function drawmap(map:mapclass):void {
|
|
if (!foregrounddrawn) {
|
|
frontbuffer_meshbatch.clear();
|
|
if(map.tileset==0){
|
|
for (j = 0; j < 29+map.extrarow; j++) {
|
|
for (i = 0; i < 40; i++) {
|
|
if(map.contents[i + map.vmult[j]]>0) drawforetile(i * 8, j * 8, map.contents[i + map.vmult[j]]);
|
|
}
|
|
}
|
|
}else if (map.tileset == 1) {
|
|
for (j = 0; j < 29+map.extrarow; j++) {
|
|
for (i = 0; i < 40; i++) {
|
|
if(map.contents[i + map.vmult[j]]>0) drawforetile2(i * 8, j * 8, map.contents[i + map.vmult[j]]);
|
|
}
|
|
}
|
|
}else if (map.tileset == 2) {
|
|
for (j = 0; j < 29+map.extrarow; j++) {
|
|
for (i = 0; i < 40; i++) {
|
|
if(map.contents[i + map.vmult[j]]>0) drawforetile3(i * 8, j * 8, map.contents[i + map.vmult[j]],map.rcol);
|
|
}
|
|
}
|
|
}
|
|
foregrounddrawn = true;
|
|
}
|
|
|
|
backbuffer.draw(frontbuffer_meshbatch);
|
|
}
|
|
|
|
public function drawfinalmap(map:mapclass):void {
|
|
//Update colour cycling for final level
|
|
if (map.final_colormode) {
|
|
map.final_aniframedelay--;
|
|
if (map.final_aniframedelay == 0) foregrounddrawn = false;
|
|
if (map.final_aniframedelay <= 0) {
|
|
map.final_aniframedelay = 2;
|
|
map.final_aniframe++;
|
|
if (map.final_aniframe >= 4) map.final_aniframe = 0;
|
|
}
|
|
}
|
|
|
|
if (!foregrounddrawn) {
|
|
frontbuffer_meshbatch.clear();
|
|
if(map.tileset==0){
|
|
for (j = 0; j < 29 + map.extrarow; j++) {
|
|
for (i = 0; i < 40; i++) {
|
|
if(map.contents[i + map.vmult[j]]>0) drawforetile(i * 8, j * 8, map.finalat(i,j));
|
|
}
|
|
}
|
|
}else if (map.tileset == 1) {
|
|
for (j = 0; j < 29+map.extrarow; j++) {
|
|
for (i = 0; i < 40; i++) {
|
|
if(map.contents[i + map.vmult[j]]>0) drawforetile2(i * 8, j * 8, map.finalat(i,j));
|
|
}
|
|
}
|
|
}
|
|
foregrounddrawn=true;
|
|
}
|
|
|
|
backbuffer.draw(frontbuffer_meshbatch);
|
|
}
|
|
|
|
public function drawmaptileat(xp:int, yp:int, mapx:int, mapy:int, map:mapclass):void {
|
|
//Not used anymore, phew
|
|
trace("dwgfx.drawmaptileat() is not implemented yet");
|
|
}
|
|
|
|
public function drawminimap(game:gameclass, map:mapclass):void {
|
|
//Not used anymore, phew
|
|
trace("dwgfx.drawminimap() is not implemented yet");
|
|
}
|
|
|
|
public function drawrect(x:int, y:int, w:int, h:int, r:int, g:int, b:int):void {
|
|
//Draw the retangle indicated by that object
|
|
tquad.x = x; tquad.y = y;
|
|
tquad.width = w; tquad.height = 1;
|
|
tquad.color = RGB(r, g, b);
|
|
backbuffer.draw(tquad);
|
|
|
|
tquad.width = 1; tquad.height = h;
|
|
backbuffer.draw(tquad);
|
|
|
|
tquad.x = x + w - 1;
|
|
backbuffer.draw(tquad);
|
|
|
|
tquad.x = x; tquad.y = y + h - 1;
|
|
tquad.width = w; tquad.height = 1;
|
|
backbuffer.draw(tquad);
|
|
}
|
|
|
|
public function cls(c:int):void {
|
|
drawfillrect(0, 0, screenwidth, screenheight, c);
|
|
}
|
|
|
|
public function drawfillrect(x:int, y:int, w:int, h:int, r:int, g:int = -1, b:int = -1):void {
|
|
//Draw the retangle indicated by that object
|
|
tquad.x = x;
|
|
tquad.y = y;
|
|
tquad.width = w;
|
|
tquad.height = h;
|
|
if (b == -1) {
|
|
tquad.color = r;
|
|
}else{
|
|
tquad.color = RGB(r, g, b);
|
|
}
|
|
|
|
backbuffer.draw(tquad);
|
|
}
|
|
|
|
public function drawfillrect_onimage(img:RenderTexture, x:int, y:int, w:int, h:int, r:int, g:int = -1, b:int = -1):void {
|
|
//Draw the retangle indicated by that object
|
|
tquad.x = x;
|
|
tquad.y = y;
|
|
tquad.width = w;
|
|
tquad.height = h;
|
|
if (b == -1) {
|
|
tquad.color = r;
|
|
}else{
|
|
tquad.color = RGB(r, g, b);
|
|
}
|
|
|
|
img.draw(tquad);
|
|
}
|
|
|
|
public function printcrewname(x:int, y:int, t:int):void {
|
|
//Print the name of crew member t in the right colour
|
|
switch(t) {
|
|
case 0: print(x, y, "Viridian", 16, 240, 240); break;
|
|
case 1: print(x, y, "Violet", 240, 16, 240); break;
|
|
case 2: print(x, y, "Vitellary", 240, 240, 16); break;
|
|
case 3: print(x, y, "Vermilion", 240, 16, 16); break;
|
|
case 4: print(x, y, "Verdigris", 16, 240, 16); break;
|
|
case 5: print(x, y, "Victoria", 16, 16, 240); break;
|
|
}
|
|
}
|
|
|
|
public function printcrewnamestatus(x:int, y:int, t:int):void {
|
|
//Print the status of crew member t in the right colour
|
|
switch(t) {
|
|
case 0: print(x, y, "(that's you!)", 12, 140, 140); break;
|
|
case 1: print(x, y, "Rescued!", 140, 12, 140); break;
|
|
case 2: print(x, y, "Rescued!", 140, 140, 12); break;
|
|
case 3: print(x, y, "Rescued!", 140, 12, 12); break;
|
|
case 4: print(x, y, "Rescued!", 12, 140, 12); break;
|
|
case 5: print(x, y, "Rescued!", 12, 12, 140); break;
|
|
}
|
|
}
|
|
|
|
public function printcrewnamedark(x:int, y:int, t:int):void {
|
|
//Print the name of crew member t as above, but in black and white
|
|
switch(t) {
|
|
case 0: print(x, y, "Viridian", 128,128,128); break;
|
|
case 1: print(x, y, "Violet", 128,128,128); break;
|
|
case 2: print(x, y, "Vitellary", 128,128,128); break;
|
|
case 3: print(x, y, "Vermilion", 128,128,128); break;
|
|
case 4: print(x, y, "Verdigris", 128,128,128); break;
|
|
case 5: print(x, y, "Victoria", 128,128,128); break;
|
|
}
|
|
}
|
|
|
|
public function printmask(x:int, y:int, t:String, cen:Boolean = false):void {
|
|
trace("dwgfx.printmask() is not implemented yet");
|
|
}
|
|
|
|
public function textbox_print(x:int, y:int, t:String, r:int, g:int, b:int, cen:Boolean = false):void {
|
|
trace("dwgfx.textbox_print() is not implemented yet");
|
|
}
|
|
|
|
public function print(x:int, y:int, t:String, r:int, g:int, b:int, cen:Boolean = false):void {
|
|
if (r < 0) r = 0; if (g < 0) g = 0; if (b < 0) b = 0;
|
|
if (r > 255) r = 255; if (g > 255) g = 255; if (b > 255) b = 255;
|
|
if (cen) {
|
|
x = 0;
|
|
ttf.format.horizontalAlign = "center";
|
|
}else {
|
|
ttf.format.horizontalAlign = "left";
|
|
}
|
|
|
|
ttf.format.color = RGB(r, g, b);
|
|
ttf.text = t;
|
|
|
|
if (flipmode) {
|
|
tposition.identity();
|
|
tposition.scale(1, -1);
|
|
tposition.translate(x, y + 8);
|
|
backbuffer.draw(ttf, tposition);
|
|
}else{
|
|
tposition.identity();
|
|
tposition.translate(x, y);
|
|
backbuffer.draw(ttf, tposition);
|
|
}
|
|
}
|
|
|
|
public function rprint(x:int, y:int, t:String, r:int, g:int, b:int, cen:Boolean = false):void {
|
|
if (r < 0) r = 0; if (g < 0) g = 0; if (b < 0) b = 0;
|
|
if (r > 255) r = 255; if (g > 255) g = 255; if (b > 255) b = 255;
|
|
ttf.format.horizontalAlign = "right";
|
|
x = x - 320;
|
|
|
|
ttf.format.color = RGB(r, g, b);
|
|
ttf.text = t;
|
|
|
|
if (flipmode) {
|
|
tposition.identity();
|
|
tposition.scale(1, -1);
|
|
tposition.translate(x, y + 8);
|
|
backbuffer.draw(ttf, tposition);
|
|
}else {
|
|
tposition.identity();
|
|
tposition.translate(x, y);
|
|
backbuffer.draw(ttf, tposition);
|
|
}
|
|
}
|
|
|
|
public function printoff(x:int, y:int, t:String, r:int, g:int, b:int, cen:Boolean = false):void {
|
|
if (r < 0) r = 0; if (g < 0) g = 0; if (b < 0) b = 0;
|
|
if (r > 255) r = 255; if (g > 255) g = 255; if (b > 255) b = 255;
|
|
if (cen) {
|
|
ttf.format.horizontalAlign = "center";
|
|
}else {
|
|
ttf.format.horizontalAlign = "left";
|
|
}
|
|
|
|
ttf.format.color = RGB(r, g, b);
|
|
ttf.text = t;
|
|
|
|
if (flipmode) {
|
|
tposition.identity();
|
|
tposition.scale(1, -1);
|
|
tposition.translate(x, y + 8);
|
|
backbuffer.draw(ttf, tposition);
|
|
}else {
|
|
tposition.identity();
|
|
tposition.translate(x, y);
|
|
backbuffer.draw(ttf, tposition);
|
|
}
|
|
}
|
|
|
|
public function bprint(x:int, y:int, t:String, r:int, g:int, b:int, cen:Boolean = false):void {
|
|
//printmask(x, y, t, cen);
|
|
print(x, y - 1, t, 0, 0, 0, cen);
|
|
if (cen) {
|
|
printoff(-1, y, t, 0, 0, 0, cen); //kludge :i
|
|
printoff(1, y, t, 0, 0, 0, cen);
|
|
}else{
|
|
print(x-1, y, t, 0, 0, 0, cen);
|
|
print(x+1, y, t, 0, 0, 0, cen);
|
|
}
|
|
print(x, y+1, t, 0, 0, 0, cen);
|
|
|
|
print(x, y, t, r, g, b, cen);
|
|
}
|
|
|
|
public function printmasktemptile(x:int, y:int, t:String, cen:Boolean = false):void {
|
|
trace("dwgfx.printmasktemptile() is not implemented yet");
|
|
}
|
|
|
|
public function printtemptile(x:int, y:int, t:String, r:int, g:int, b:int, cen:Boolean = false):void {
|
|
trace("dwgfx.printtemptile() is not implemented yet");
|
|
}
|
|
|
|
public function onscreen(t:int):Boolean {
|
|
if (t >= -40 && t <= 280) return true;
|
|
return false;
|
|
}
|
|
|
|
public function bigrprint(x:int, y:int, t:String, r:int, g:int, b:int, cen:Boolean = false, sc:Number = 2):void {
|
|
if (r < 0) r = 0; if (g < 0) g = 0; if (b < 0) b = 0;
|
|
if (r > 255) r = 255; if (g > 255) g = 255; if (b > 255) b = 255;
|
|
ttf.format.horizontalAlign = "right";
|
|
x = x - 320;
|
|
|
|
ttf.format.color = RGB(r, g, b);
|
|
ttf.format.size = BitmapFont.NATIVE_SIZE * sc;
|
|
ttf.text = t;
|
|
|
|
if (flipmode) {
|
|
tposition.identity();
|
|
tposition.scale(1, -1);
|
|
tposition.translate(x, y + (8 * sc));
|
|
backbuffer.draw(ttf, tposition);
|
|
}else {
|
|
tposition.identity();
|
|
tposition.translate(x, y);
|
|
backbuffer.draw(ttf, tposition);
|
|
}
|
|
ttf.format.size = BitmapFont.NATIVE_SIZE;
|
|
}
|
|
|
|
public function bigprint(x:int, y:int, t:String, r:int, g:int, b:int, cen:Boolean = false, sc:Number = 2):void {
|
|
if (r < 0) r = 0; if (g < 0) g = 0; if (b < 0) b = 0;
|
|
if (r > 255) r = 255; if (g > 255) g = 255; if (b > 255) b = 255;
|
|
if (cen) {
|
|
x = 0;
|
|
ttf.format.horizontalAlign = "center";
|
|
}else {
|
|
ttf.format.horizontalAlign = "left";
|
|
}
|
|
|
|
ttf.format.color = RGB(r, g, b);
|
|
ttf.format.size = BitmapFont.NATIVE_SIZE * sc;
|
|
ttf.text = t;
|
|
|
|
if (flipmode) {
|
|
tposition.identity();
|
|
tposition.scale(1, -1);
|
|
tposition.translate(x, y + (8 * sc));
|
|
backbuffer.draw(ttf, tposition);
|
|
}else {
|
|
tposition.identity();
|
|
tposition.translate(x, y);
|
|
backbuffer.draw(ttf, tposition);
|
|
}
|
|
|
|
ttf.format.size = BitmapFont.NATIVE_SIZE;
|
|
}
|
|
|
|
|
|
public function len(t:String):int {
|
|
//For VVVVVV, we're using a fixed width font, so...
|
|
return t.length * 8;
|
|
}
|
|
|
|
public function flashlight():void {
|
|
drawfillrect(0, 0, 320, 240, 187, 187, 187);
|
|
}
|
|
|
|
public function screenshake():void {
|
|
screenmenubuffer.draw(smallscreen);
|
|
|
|
if (flipmode) {
|
|
tposition.identity();
|
|
tposition.scale(1, -1);
|
|
tposition.translate(int((Math.random() * 7) - 4), screenheight + int((Math.random() * 7) - 4));
|
|
drawfillrect(0, 0, screenwidth, screenheight, 0, 0, 0);
|
|
backbuffer.draw(screenmenubuffer_image, tposition);
|
|
}else{
|
|
tposition.identity();
|
|
tposition.translate(int((Math.random() * 7) - 4), int((Math.random() * 7) - 4));
|
|
|
|
backbuffer.draw(screenmenubuffer_image, tposition);
|
|
}
|
|
}
|
|
|
|
public function render():void {
|
|
if (flipmode) {
|
|
tposition.identity();
|
|
tposition.scale(1, -1);
|
|
tposition.translate(0, screenheight);
|
|
|
|
screenmenubuffer.drawBundled(function():void {
|
|
screenmenubuffer.draw(smallscreen);
|
|
});
|
|
|
|
backbuffer.draw(screenmenubuffer_image, tposition);
|
|
}
|
|
}
|
|
|
|
public function clear_menubuffer():void {
|
|
tquad.x = 0; tquad.y = 0;
|
|
tquad.width = screenwidth;
|
|
tquad.height = screenheight;
|
|
tquad.color = RGB(0, 0, 0);
|
|
|
|
menubuffer.drawBundled(function():void {
|
|
menubuffer.draw(tquad);
|
|
});
|
|
screenmenubuffer.drawBundled(function():void {
|
|
screenmenubuffer.draw(tquad);
|
|
});
|
|
}
|
|
|
|
public function setup_menubuffer():void {
|
|
menubuffer.draw(smallscreen);
|
|
}
|
|
|
|
public function menuoffrender():void {
|
|
//The backbuffer currently contains the menu, so we save this...
|
|
screenmenubuffer.draw(smallscreen);
|
|
|
|
//Then we draw the old in-game screen instead
|
|
backbuffer.draw(menubuffer_image);
|
|
|
|
//Finally, we draw the menu back on top of this, offset.
|
|
if (flipmode) {
|
|
tposition.identity();
|
|
tposition.scale(1, -1);
|
|
tposition.translate(0, screenheight + menuoffset);
|
|
backbuffer.draw(screenmenubuffer_image, tposition);
|
|
}else {
|
|
tposition.identity();
|
|
tposition.translate(0, menuoffset);
|
|
backbuffer.draw(screenmenubuffer_image, tposition);
|
|
}
|
|
}
|
|
|
|
public var tquad:Quad;
|
|
public var ttf:TextField;
|
|
public var tposition:Matrix;
|
|
public var starlingassets:AssetManager;
|
|
public var starstage:Stage
|
|
|
|
public var backgrounds:Vector.<Image> = new Vector.<Image>;
|
|
public var images:Vector.<Image> = new Vector.<Image>;
|
|
public var playerlevelimages:Vector.<Image> = new Vector.<Image>;
|
|
public var mobileimages:Vector.<Image> = new Vector.<Image>;
|
|
public var tele:Vector.<Image> = new Vector.<Image>;
|
|
public var tiles:Vector.<Image> = new Vector.<Image>;
|
|
public var tiles2:Vector.<Image> = new Vector.<Image>;
|
|
public var tiles3:Vector.<Image> = new Vector.<Image>;
|
|
public var sprites:Vector.<Image> = new Vector.<Image>;
|
|
public var flipsprites:Vector.<Image> = new Vector.<Image>;
|
|
public var sprites_bitmap:Vector.<BitmapData> = new Vector.<BitmapData>;
|
|
public var flipsprites_bitmap:Vector.<BitmapData> = new Vector.<BitmapData>;
|
|
public var entcolours:Vector.<Image> = new Vector.<Image>;
|
|
public var customminimap:RenderTexture;
|
|
|
|
public var cur:int;
|
|
public var ct:ColorTransform;
|
|
public var tiles_rect:Rectangle;
|
|
public var sprites_rect:Rectangle;
|
|
public var bfont_rect:Rectangle;
|
|
public var bfontmask_rect:Rectangle;
|
|
public var images_rect:Rectangle;
|
|
public var tl:Point; //The point at (0,0)
|
|
public var bg_rect:Rectangle, prect:Rectangle;
|
|
public var line_rect:Rectangle;
|
|
|
|
public var temp:int;
|
|
public var temp2:int;
|
|
public var temp3:int;
|
|
public var tempstring:String;
|
|
public var alphamult:uint;
|
|
public var stemp:String;
|
|
public var i:int, j:int, k:int, m:int;
|
|
public var tpoint:Point, trect:Rectangle;
|
|
public var madrect:Rectangle, madpoint:Point;
|
|
|
|
public var temptile:RenderTexture;
|
|
public var tempsprite:RenderTexture;
|
|
public var footerrect:Rectangle;
|
|
|
|
//Actual backgrounds
|
|
public var backbuffer:RenderTexture;
|
|
public var frontbuffer_meshbatch:MeshBatch;
|
|
public var menubuffer:RenderTexture;
|
|
public var menubuffer_image:Image;
|
|
public var screenmenubuffer:RenderTexture;
|
|
public var screenmenubuffer_image:Image;
|
|
public var towerbufferforeground_meshbatch:MeshBatch;
|
|
public var towerbufferbackground_meshbatch:MeshBatch;
|
|
public var towerbufferstatic_meshbatch:MeshBatch;
|
|
public var warpzonehorizontal_meshbatch:MeshBatch;
|
|
public var warpzonevertical_meshbatch:MeshBatch;
|
|
public var screen:Image;
|
|
public var smallscreen:Image;
|
|
public var updatebackground:Boolean;
|
|
|
|
//Textbox Stuff
|
|
public var ntextbox:int;
|
|
public var textbox:Vector.<textboxclass> = new Vector.<textboxclass>;
|
|
//Cutscene bars
|
|
public var showcutscenebars:Boolean;
|
|
public var cutscenebarspos:int;
|
|
//Background Stuff
|
|
public var stars:Vector.<Rectangle> = new Vector.<Rectangle>;
|
|
public var starsspeed:Vector.<int> = new Vector.<int>;
|
|
|
|
//special for weird lab rooms
|
|
public var spcol:int, spcoldel:int;
|
|
//Menu stuff
|
|
public var crewframe:int, crewframedelay:int;
|
|
public var menuoffset:int, resumegamemode:Boolean;
|
|
//More Background Stuff
|
|
public var backboxes:Vector.<Rectangle> = new Vector.<Rectangle>;
|
|
public var backboxvx:Vector.<int> = new Vector.<int>;
|
|
public var backboxvy:Vector.<int> = new Vector.<int>;
|
|
public var backboxint:Vector.<Number> = new Vector.<Number>;
|
|
public var bcol:int, bcol2:int, rcol:int;
|
|
public var backboxrect:Rectangle;
|
|
public var linestate:int, linedelay:int;
|
|
public var backoffset:int, backgrounddrawn:Boolean;
|
|
public var foregrounddrawn:Boolean;
|
|
|
|
public var warpskip:int;
|
|
public var warpfcol:int, warpbcol:int;
|
|
public var warprect:Rectangle;
|
|
//Fade effect
|
|
public var fademode:int;
|
|
public var fadeamount:int;
|
|
public var fadebars:Vector.<int> = new Vector.<int>;
|
|
//Single trinket colour
|
|
public var trinketcolset:Boolean, trinketr:int, trinketg:int, trinketb:int;
|
|
//Flipmode Stuff
|
|
public var flipmode:Boolean, setflipmode:Boolean;
|
|
public var flipmatrix:Matrix = new Matrix();
|
|
public var flipfontmatrix:Matrix = new Matrix();
|
|
public var flipfontmatrix2:Matrix = new Matrix();
|
|
|
|
//Mobile stuff
|
|
public var screensizemultiplier:Number;
|
|
|
|
public var screenoffx:int, screenoffy:int;
|
|
|
|
public var buttonsready:Boolean = false;
|
|
public var button_texture:Vector.<RenderTexture> = new Vector.<RenderTexture>;
|
|
public var button_image:Vector.<Image> = new Vector.<Image>;
|
|
public var button_image_width:Vector.<int> = new Vector.<int>;
|
|
public var button_image_height:Vector.<int> = new Vector.<int>;
|
|
public var buttonactive:Vector.<Boolean> = new Vector.<Boolean>;
|
|
public var buttonhighlight:Vector.<int> = new Vector.<int>;
|
|
|
|
public var buttonpos:Vector.<Point> = new Vector.<Point>;
|
|
public var currentbuttontype:Vector.<int> = new Vector.<int>;
|
|
public var newbuttontype:Vector.<int> = new Vector.<int>;
|
|
public var buttonstate:Vector.<int> = new Vector.<int>;
|
|
public var buttonlerp:Vector.<int> = new Vector.<int>;
|
|
public var buttonframe:Vector.<int> = new Vector.<int>;
|
|
public var buttonsize:int, buttonyspacing:int, buttonxspacing:int, buttonydiff:int;
|
|
|
|
public var b_gap:int = 40, b_size:int = 26;
|
|
public var devicex:int, devicey:int;
|
|
|
|
[Embed(source = "../data/bitmapsprites.png")]
|
|
public static const img_bitmapsprites:Class;
|
|
|
|
[Embed(source = "../data/bitmapflipsprites.png")]
|
|
public static const img_bitmapflipsprites:Class;
|
|
}
|
|
} |