package com.lloydm.geosword;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.util.Random;
import android.content.res.AssetManager;
import android.graphics.Bitmap;
import android.util.Log;
import com.threed.jpct.Camera;
import com.threed.jpct.FrameBuffer;
import com.threed.jpct.GLSLShader;
import com.threed.jpct.Logger;
import com.threed.jpct.Matrix;
import com.threed.jpct.Object3D;
import com.threed.jpct.SimpleVector;
import com.threed.jpct.Texture;
import com.threed.jpct.TextureManager;
import com.threed.jpct.World;
import com.lloydm.geosword.common.CameraKeyFrame;
import com.lloydm.geosword.common.Config;
import com.lloydm.geosword.common.HardPoint;
import com.lloydm.geosword.common.Weapon;
import com.lloydm.geosword.common.KeyFrame;
import com.lloydm.geosword.common.KeyFrameData;
import com.lloydm.geosword.common.Ship;
import com.lloydm.geosword.PilotChatter;
public class Level3
{
// shader version.....
// also uses new ship models.
// each iteration of "level" class is an update......
// also now loads replay from file...while testing....still very early.....
private final static String TAG = "com.lloydm.geosword.Level3";
private final static String TIMERTAG = "com.lloydm.geosword.Timing";
public final static SimpleVector ROTATE3DS = new SimpleVector(0, -1, 0);
public final static SimpleVector laservert1 = new SimpleVector(-1.0f, 0, 0);
public final static SimpleVector laservert2 = new SimpleVector(1.0f, 0, 0);
public final static SimpleVector laservert3 = new SimpleVector(1.0f, 0, 15f);
public final static SimpleVector laservert4 = new SimpleVector(-1.0f, 0, 15f);
public final static SimpleVector beamvert1 = new SimpleVector(-20.5f, 0, 0);
public final static SimpleVector beamvert2 = new SimpleVector(20.5f, 0, 0);
public final static SimpleVector beamvert3 = new SimpleVector(20.5f, 0, 2000f);
public final static SimpleVector beamvert4 = new SimpleVector(-20.5f, 0, 2000f);
public final static SimpleVector beamvert5 = new SimpleVector(0, -20.5f, 0);
public final static SimpleVector beamvert6 = new SimpleVector(0, 20.5f, 0);
public final static SimpleVector beamvert7 = new SimpleVector(0, 20.5f, 2000f);
public final static SimpleVector beamvert8 = new SimpleVector(0f, -20.5f, 2000f);
public Texture cachetex = null;
public volatile int skipnum = 0;
public PilotChatter pchatter = null;
public volatile boolean musicflag = true;
public volatile boolean failexit = false;
public volatile boolean jumpoutimmediately = false;
public volatile boolean safetoexit = false;
// teams are:
// red, blue, green, yellow, white, black, purple, orange
public final static float TEAMRED[] = new float[] { 3f, 2.95f, 2.95f, 1.0f };
// red
public final static float TEAMBLUE[] = new float[] { 2.95f, 2.95f, 3f, 1.0f };
// blue
public final static float TEAMGREEN[] = new float[] { 2.95f, 3f, 2.95f, 1.0f };
// green
public final static float TEAMYELLOW[] = new float[] { 3f, 3f, 2.95f, 1.0f };
// yellow
public final static float TEAMWHITE[] = new float[] { 3f, 3f, 3f, 1.0f };
// white
public final static float TEAMBLACK[] = new float[] { 2.7f, 2.7f, 2.7f, 1.0f };
// black
public final static float TEAMPURPLE[] = new float[] { 3f, 2.95f, 3f, 1.0f };
// purple
public final static float TEAMORANGE[] = new float[] { 3f, 2.98f, 2.93f, 1.0f };
// orange
public final static float TEAMBLANK[] = new float[] { 1, 1, 1, 1 };
// blank
public final static int MAXRAND = 1000;
public final static int MAXESPRITES = 200;
public final static float ESPRITESIZE = 120;
private static int LOWSPECDIV = 1;
// new simple method for explosions.....
public Texture explosiontextures[] = null;
public Object3D esprites[] = null;
public int espriteframe[] = null;
public Matrix espritetexmatrix[] = null;
//new simple method for engine trails for fighters and bombers......
public final static int MAXENGSPRITES = (32)*2; //just do 32 x 2 and leave some of them blank.....wasted okay.....
public final static float ENGSPRITESIZE = 8;
public Texture enginetrailtextures[] = null;
public Object3D enginesprites[] = null;
public int enginespriteframe[] = null;
public Matrix enginespritetexmatrix[] = null;
public float erand[] = null;
// hud elements (health for ships....)
public Texture teamhptextures[] = null;
public Object3D teamhpsprites[] = null;
public Matrix teamhptexmatrix[] = null;
public float teamhpucoord[] = null;
public float teamhpvcoord[] = null;
public volatile int ateami = -1;
public volatile int dteami = -1;
public float teamphpx[] = null; // x coordinates....
// these are set in TestActivity AND only in TestActivity....
// they are only READ in here......
public volatile boolean setframe = false;
public boolean settingframe = false;
public volatile boolean showstats = false;
public volatile float setframex = -1f;
public volatile float setframey = -1f;
public int fwidth = -1;
public int fheight = -1;
public float timepercent = -1;
public int setframenumber = -1;
public int currentframe;
public int newframe = -1;
public int catchupframe = -1;
public boolean viewmode = false;
public volatile boolean levelloaded = false;
public volatile boolean loading = false;
public volatile int loadvalue = 0;
public volatile int lprog = 0;
private boolean gpuready = false;
private int gpureadycount = 0;
public KeyFrame[] keyframe = new KeyFrame[8000];
private CameraKeyFrame[] cameraframe = new CameraKeyFrame[8000];
public int[] irandkeys = new int[8000];
public int maxframes;
public int splitindex = -1;
public Mesh[] mesh;
public Object3D loadingscreen = null;
public LaserBeam[] laserbeams = new LaserBeam[1000];
public Ship[] ships = new Ship[32];
public SpaceDebris[] spacedebris;
// public Explosion explosions = null;
public World world;
public Camera camera;
public FrameBuffer fbuffer;
public AssetManager assets;
public GLSLShader[] shaders;
public String rfile = null;
public int irand;
public Random rand;
// temp variables changed from local to class members....basically so we
// don't keep creating stuff....
public SimpleVector pos, adjust, target, oldt, spawnpos, screenvec;
public Matrix adjustmatrix;
public float angle1, angle2;
public boolean tmpboolean = false, smoking = false,
massiveexplosion = false;
public int size, i, j, k;
public int tmpi;
public float camx = 0, camy = 0, camz = 0, camdx = 0, camdy = 0, camdz = 1;
public float mdx = 0, mdy = 0, mdz = 0, mlen = 0;
public float bvx = 0, bvy = 0, bvz = 0, blen = 0;
public Level3(final int levelnumber, final World world, AssetManager assets, final GLSLShader[] shaders, final String replayfile, final boolean viewmode, final boolean musicflag)
{
if (loading)
{
return;
}
this.viewmode = viewmode;
this.assets = assets;
this.shaders = shaders;
this.rfile = replayfile;
this.musicflag = musicflag;
if (Config.ISLOWSPECDEVICE)
{
LOWSPECDIV = 2;
}
Log.i(TAG, "Rfile in Level3:" + this.rfile);
new Thread(new Runnable()
{
@Override
public void run()
{
failexit = false;
Log.i(TIMERTAG, "TIME:(START LOAD):" + System.currentTimeMillis());
loading = true;
levelloaded = false;
loadvalue = 25;
logmemoryusage();
lprog = 0;
loadlevel(world);
logmemoryusage();
loadvalue = 50;
levelloaded = true;
loading = false;
lprog = 1;
for (i = 0; i < 8000; i++)
{
irandkeys[i] = -1;
}
Log.i(TIMERTAG, "TIME:(END LOAD):" + System.currentTimeMillis());
if (jumpoutimmediately)
{
safetoexit = true;
}
System.gc();
}
}).start();
}
public void update()
{
if (loading)
{
return;
}
if (rand == null)
{
rand = new Random();
rand.setSeed(System.currentTimeMillis());
}
if (erand == null)
{
erand = new float[MAXRAND / LOWSPECDIV];
for (i = 0; i < MAXRAND / LOWSPECDIV; i++)
{
erand[i] = (rand.nextFloat() - 0.5f) * 2.0f;
}
if (lprog == 1)
{
lprog = 2;
}
}
if (currentframe < 8000 && currentframe >= 0)
{
irandkeys[currentframe] = irand;
}
if (currentframe == 1)
{
Log.i(TIMERTAG, "TIME:(GAME SHOULD HAVE STARTED FRAME:1:" + System.currentTimeMillis());
if (lprog < 99)
{
lprog = 99;
}
}
if (currentframe == 4000)
{
Log.i(TAG, "TIME:(AT FRAME 4000):" + System.currentTimeMillis());
}
if (currentframe == 0)
{
Log.d(TAG, "Check GC from here");
for (i = 0; i < 32; i++)
{
if (ships[i] == null)
{
continue;
}
if (ships[i].shiptype < 3)
{
// ships[i].mesh[0].setRenderHook(new BeamSplitRenderHook());
// we need to make two copies of the original mesh....
// which are hidden at all times....
// currently going to split them down the middle.....see if it works.....it may.....
// do this after work most likely....
/*
* if (ships[i].meshhalfA == null) { // ships[i].meshhalfA = ships[i].mesh[0].cloneObject(); // ships[i].meshhalfA.setTransparency(255); //
* ships[i].meshhalfA.setTransparencyMode(Object3D.TRANSPARENCY_MODE_DEFAULT);
*
* } if (ships[i].meshhalfB == null) { // ships[i].meshhalfB = ships[i].mesh[0].cloneObject(); // ships[i].meshhalfB.setTransparency(255); //
* ships[i].meshhalfB.setTransparencyMode(Object3D.TRANSPARENCY_MODE_DEFAULT); } if (!gpuready) { if (ships[i].aa != null) { Log.i(TAG, "setting shader7");
* ships[i].aa.setCurrentShader(this.shaders[7]); ships[i].aa.myshader = this.shaders[7]; ships[i].meshhalfA.setRenderHook(ships[i].aa);
* ships[i].meshhalfA.setShader(this.shaders[7]);
*
* } if (ships[i].bb != null) { Log.i(TAG, "setting shader7"); ships[i].bb.setCurrentShader(this.shaders[7]); ships[i].bb.myshader = this.shaders[7];
* ships[i].meshhalfB.setRenderHook(ships[i].bb); ships[i].meshhalfB.setShader(this.shaders[7]); } }
*/
ships[i].hh = new HighlightRenderHook();
ships[i].hh.setCurrentShader(this.shaders[2]);
ships[i].hh.myshader = this.shaders[2];
ships[i].hh.highlighton = false;
ships[i].hh.ff = new float[4];
ships[i].mesh[0].setRenderHook(ships[i].hh);
ships[i].mesh[0].setShader(this.shaders[2]);
}
else
{ // small ships get different shaders (slightly no bump mapping
// but keep specular)
ships[i].hh = new HighlightRenderHook();
ships[i].hh.setCurrentShader(this.shaders[2]);
ships[i].hh.myshader = this.shaders[2];
ships[i].hh.highlighton = false;
ships[i].hh.ff = new float[4];
ships[i].mesh[0].setRenderHook(ships[i].hh);
ships[i].mesh[0].setShader(this.shaders[2]);
}
}
Log.d(TAG, "Ship Shader set");
}
if (maxframes == 0)
{
maxframes = keyframe.length;
}
// check if gpuready.....ie do caching here.......
if (gpuready == false)
{
if (lprog < 5)
{
lprog = 5;
}
loadvalue = 65;
gpureadycount++;
// set all ships to visible....
if (camera != null)
{
if (pos == null)
{
pos = new SimpleVector(0, 0, 0);
}
if (spawnpos == null)
{
spawnpos = new SimpleVector(0, 0, 0);
}
pos.x = 0;
pos.y = 0;
pos.z = 0;
spawnpos.x = 0;
spawnpos.y = 0;
spawnpos.z = 500;
camera.setPosition(pos);
camera.lookAt(spawnpos);
}
for (i = 0; i < 32; i++)
{
if (ships[i] != null)
{
if (ships[i].mesh != null)
{
if (ships[i].mesh[0] != null)
{
ships[i].mesh[0].setVisibility(true);
if (ships[i].wmatrix == null)
{
ships[i].wmatrix = ships[i].pivot.getWorldTransformation();
}
else
{
ships[i].wmatrix = ships[i].pivot.getWorldTransformation(ships[i].wmatrix);
}
if (pos == null)
{
pos = ships[i].wmatrix.getTranslation();
}
pos = ships[i].wmatrix.getTranslation(pos);
pos.scalarMul(-1);
if (!viewmode)
{
ships[i].pivot.translate(pos);
ships[i].pivot.translate(0, 0, 500);
}
}
/*
* if (ships[i].meshhalfA != null) { ships[i].meshhalfA.setVisibility(true); } if (ships[i].meshhalfB != null) { ships[i].meshhalfB.setVisibility(true); }
*/
}
}
}
if (lprog < 6)
{
lprog = 6;
}
for (i = 0; i < 32; i++)
{
if (teamhpsprites != null)
{
if (teamhpsprites[i] != null)
{
teamhpsprites[i].setVisibility(true);
if (adjustmatrix == null)
{
adjustmatrix = teamhpsprites[i].getWorldTransformation();
}
else
{
adjustmatrix = teamhpsprites[i].getWorldTransformation(adjustmatrix);
}
if (oldt == null)
{
oldt = adjustmatrix.getTranslation();
}
else
{
oldt = adjustmatrix.getTranslation(oldt);
}
oldt.scalarMul(-1f);
}
}
}
if (lprog < 7)
{
lprog = 7;
}
for (i = 0; i < MAXESPRITES / LOWSPECDIV; i++)
{
if (esprites != null)
{
if (esprites[i] != null)
{
esprites[i].setVisibility(true);
if (adjustmatrix == null)
{
adjustmatrix = esprites[i].getWorldTransformation();
}
else
{
adjustmatrix = esprites[i].getWorldTransformation(adjustmatrix);
}
if (oldt == null)
{
oldt = adjustmatrix.getTranslation();
}
else
{
oldt = adjustmatrix.getTranslation(oldt);
}
oldt.scalarMul(-1f);
esprites[i].translate(oldt);
esprites[i].setScale(1.0f);
esprites[i].translate(0, 0, 500);
}
}
}
for(i=0;i<MAXENGSPRITES;i++)
{
if(enginesprites!=null)
{
if(enginesprites[i]!=null)
{
enginesprites[i].setVisibility(true);
if(adjustmatrix == null)
{
adjustmatrix = enginesprites[i].getWorldTransformation();
}
else
{
adjustmatrix = enginesprites[i].getWorldTransformation(adjustmatrix);
}
if(oldt == null)
{
oldt = adjustmatrix.getTranslation();
}
else
{
oldt = adjustmatrix.getTranslation(oldt);
}
oldt.scalarMul(-1f);
enginesprites[i].translate(oldt);
enginesprites[i].setScale(1.0f);
enginesprites[i].translate(0,0,500);
}
}
}
if (lprog < 8)
{
lprog = 8;
}
gpureadycount++;
if (gpureadycount > 20)
{
// hide everything again.......
if (!viewmode)
{
for (i = 0; i < 32; i++)
{
if (ships[i] != null)
{
if (ships[i].mesh != null)
{
if (ships[i].mesh[0] != null)
{
ships[i].mesh[0].setVisibility(false);
}
/*
* if (ships[i].meshhalfA != null) { ships[i].meshhalfA.setVisibility(false); } if (ships[i].meshhalfB != null) { ships[i].meshhalfB.setVisibility(false); }
*/
}
}
}
}
for (i = 0; i < 32; i++)
{
if (teamhpsprites != null)
{
if (teamhpsprites[i] != null)
{
teamhpsprites[i].setVisibility(false);
}
}
}
for (i = 0; i < MAXESPRITES / LOWSPECDIV; i++)
{
if (esprites != null)
{
if (esprites[i] != null)
{
esprites[i].setVisibility(false);
}
}
}
for(i = 0;i<MAXENGSPRITES;i++)
{
if(enginesprites!=null)
{
if(enginesprites[i]!=null)
{
enginesprites[i].setVisibility(false);
}
}
}
if (loadingscreen != null)
{
gpuready = true;
Log.d(TAG, "gpu now ready");
logmemoryusage();
loadvalue = 95;
loadingscreen.setVisibility(false);
}
if (viewmode)
{
gpuready = true;
Log.d(TAG, "gpu now ready");
logmemoryusage();
}
}
if (lprog < 12)
{
lprog = 12;
}
return;
}
// gpu is ready......
// this section is for updating the replay time position (seeking pos)
// based on user interaction with slider
if (setframe == true && settingframe == false)
{
if (setframex > 0) // && setframey>0)
{
// height of screen is?
if (fbuffer != null)
{
if (fwidth == -1)
{
fwidth = fbuffer.getWidth();
}
if (fheight == -1)
{
fheight = fbuffer.getHeight();
}
if (fwidth != -1 && fheight != -1)
{
// check relative position of touchx.y
// we will have a slider showing eventually but for now
// simply do the calcs.....
// if(setframey > 0.8f*fheight)
{
// if(setframex>0.05f*fwidth &&
// setframex<0.95f*fwidth)
{
// this is where slider is.....
if (fwidth > 0f)
{
settingframe = true;
timepercent = (setframex / 8002f); // (setframex
// -
// 0.05f*fwidth)/
// (0.9f*fwidth);
newframe = (int) ((float) maxframes * timepercent) - 150;
// reset all bullets and esprites...effects
// etc.....
for (j = 0; j < 1000; j++)
{
if (laserbeams[j] != null)
{
if (laserbeams[j].lifetime > 0)
{
laserbeams[j].lifetime = 0;
// if (laserbeams[j].isbeam)
// {
laserbeams[j].beammesh.setVisibility(false);
// }
// else
// {
laserbeams[j].mesh.setVisibility(false);
// }
}
else
{
laserbeams[j].beammesh.setVisibility(false);
laserbeams[j].mesh.setVisibility(false);
}
}
else
{
break;
}
}
for (j = 0; j < 65; j++)
{
if (esprites != null)
{
k = 0;
for (i = 0; i < MAXESPRITES / LOWSPECDIV; i++)
{
if (esprites[i] != null)
{
esprites[i].setVisibility(false);
if (espriteframe[i] == -1)
{
continue;
}
k = 1;
// change texture coords of
// the sprite.....
if (espriteframe[i] >= 64)
{
espriteframe[i] = -1;
espritetexmatrix[i].translate(-0.875f, -0.875f, 0f);
esprites[i].setTextureMatrix(espritetexmatrix[i]);
esprites[i].touch();
}
else
{
if (espriteframe[i] % 8 == 0)
{
if (espriteframe[i] != 0)
{
espritetexmatrix[i].translate(-0.875f, 0.125f, 0f);
esprites[i].setTextureMatrix(espritetexmatrix[i]);
esprites[i].touch();
}
}
else
{
espritetexmatrix[i].translate(0.125f, 0f, 0f);
esprites[i].setTextureMatrix(espritetexmatrix[i]);
esprites[i].touch();
}
espriteframe[i]++;
}
}
}
if (k == 0)
{
break;
}
}
}
if (newframe < 0)
{
newframe = 0;
}
if (newframe > maxframes - 1)
{
newframe = maxframes - 1;
}
// may or may not work..should though....
if (newframe >= 0 && newframe < 8000)
{
if (irandkeys[newframe] != -1)
{
irand = irandkeys[newframe];
}
}
catchupframe = newframe - 200;
for (currentframe = catchupframe; currentframe < newframe; currentframe++)
{
// only things we really care about are
// the explosions and lasers....
// nothing else makes any difference
// whatsoever......
// we also care about the split meshes....
if (currentframe > 0 && currentframe < maxframes)
{
if (irandkeys[currentframe] == -1)
{
irandkeys[currentframe] = irand;
}
// /////////////////////////////DUPLICATE
// OF BELOW CODE
for (i = 0; i < 32; i++)
{
if (showstats)
{
ships[i].hh.highlighton = true;
if (ships[i].team == 1)
{
ships[i].hh.ff[0] = 2f;
ships[i].hh.ff[1] = 0f;
ships[i].hh.ff[2] = 0f;
}
if (ships[i].team == 2)
{
ships[i].hh.ff[2] = 2f;
ships[i].hh.ff[1] = 2f;
ships[i].hh.ff[0] = 0f;
}
if (ships[i].team == 3)
{
ships[i].hh.ff[0] = 2f;
ships[i].hh.ff[1] = 2f;
ships[i].hh.ff[2] = 0f;
}
if (ships[i].team == 4)
{
ships[i].hh.ff[1] = 2f;
ships[i].hh.ff[0] = 0f;
ships[i].hh.ff[2] = 0f;
}
if (ships[i].team == 5)
{
ships[i].hh.ff[0] = 2f;
ships[i].hh.ff[1] = 0f;
ships[i].hh.ff[2] = 2f;
}
ships[i].hh.ff[3] = (float) keyframe[currentframe].shipdata[i].hp / (float) ships[i].fullhp;
}
else
{
ships[i].hh.highlighton = false;
}
tmpboolean = false;
smoking = false;
massiveexplosion = false;
if (currentframe + 50 < maxframes && ships[i].shiptype < 3)
{
if (keyframe[currentframe + 50].shipdata[i].hp <= 0 && keyframe[currentframe].shipdata[i].hp < ships[i].fullhp && keyframe[currentframe].shipdata[i].hp > 0 && keyframe[currentframe + 50].shipdata[i].hp > -10000 && ships[i].splitframe <= 0)
{
if (currentframe % 10 == 0)
{
tmpboolean = true;
}
}
if (currentframe - ships[i].splitframe < 50 && currentframe - ships[i].splitframe > -25 && currentframe % 10 == 0 && ships[i].splitframe > 0)
{
tmpboolean = true;
}
// added
if (keyframe[currentframe + 10].shipdata[i].hp <= 0 && keyframe[currentframe + 9].shipdata[i].hp > 0)
{
massiveexplosion = true;
}
}
if (currentframe + 200 < maxframes && ships[i].shiptype > 2 && keyframe[currentframe].shipdata[i].hp > 0 && keyframe[currentframe].shipdata[i].hp < ships[i].fullhp)
{
if (currentframe % 3 == 0 && keyframe[currentframe + 200].shipdata[i].hp <= 0)
{
smoking = true;
tmpboolean = true;
}
}
if (currentframe + 50 < maxframes && ships[i].shiptype > 2)
{
if (keyframe[currentframe + 10].shipdata[i].hp <= 0 && keyframe[currentframe + 9].shipdata[i].hp > 0)
{
massiveexplosion = true;
}
}
angle2 = 1;
if (currentframe + 16 < maxframes)
{
if (keyframe[currentframe + 14].shipdata[i].hp > 0 && keyframe[currentframe + 15].shipdata[i].hp <= 0)
{
tmpboolean = true;
angle2 = 0;
}
}
if (keyframe[currentframe].shipdata[i].hp != keyframe[currentframe - 1].shipdata[i].hp || tmpboolean || massiveexplosion)
{
// put explosion....
// simply update the
// position of the relevant
// esprite.....find one that
// has a -1 value....
if (esprites != null && ((currentframe % 2 == 0 && ships[i].shiptype > 2) || (angle2 == 0) || (currentframe % 6 == 0 && ships[i].shiptype < 3) || massiveexplosion))
{
for (j = 0; j < MAXESPRITES / LOWSPECDIV; j++)
{
if (espriteframe[j] == -1)
{
espriteframe[j] = 0;
if (adjustmatrix == null)
{
adjustmatrix = esprites[j].getWorldTransformation();
}
else
{
adjustmatrix = esprites[j].getWorldTransformation(adjustmatrix);
}
if (oldt == null)
{
oldt = adjustmatrix.getTranslation();
}
else
{
oldt = adjustmatrix.getTranslation(oldt);
}
oldt.scalarMul(-1f);
esprites[j].translate(oldt);
esprites[j].setScale(1.0f);
// scale it up
// at this point
// based on size
// type.....
if (smoking)
{
esprites[j].setScale(0.1f); // smoke
// trails......really
// small....
}
else
{
if (massiveexplosion)
{
esprites[j].setScale(2.5f + (ships[i].sizetype * 0.2f));
}
else
{
if (currentframe + 30 < maxframes)
{
if (keyframe[currentframe + 30].shipdata[i].hp <= 0 && keyframe[currentframe + 30].shipdata[i].hp > -10000)
{
esprites[j].setScale(1.0f + (ships[i].sizetype * 0.05f));
}
else
{
if (keyframe[currentframe + 7].shipdata[i].hp == -10000)
{
esprites[j].setScale(0.5f + (ships[i].sizetype * 0.1f));
}
}
}
}
}
irand++;
irand %= MAXRAND / LOWSPECDIV;
if (!massiveexplosion)
{
if (Math.abs(ships[i].splitframe - currentframe) < 150)
{
// set scale to be quite small actually....
// and also set the angle1 to really small too
esprites[j].setScale(0.6f);
angle1 = 0.1f;
}
else
{
angle1 = 1.0f;
}
esprites[j].translate(keyframe[currentframe].shipdata[i].x, keyframe[currentframe].shipdata[i].y, keyframe[currentframe].shipdata[i].z);
esprites[j].translate(angle1 * 5.5f * (ships[i].sizetype + 1) * erand[irand], 0, 0);
irand++;
irand %= MAXRAND / LOWSPECDIV;
esprites[j].translate(0, angle1 * 5.5f * (1 + ships[i].sizetype) * erand[irand], 0);
irand++;
irand %= MAXRAND / LOWSPECDIV;
esprites[j].translate(0, 0, angle1 * 5.5f * (ships[i].sizetype + 1) * erand[irand]);
}
else
{
esprites[j].translate(keyframe[currentframe].shipdata[i].x, keyframe[currentframe].shipdata[i].y, keyframe[currentframe].shipdata[i].z);
}
break;
}
}
}
}
size = keyframe[currentframe].shipdata[i].firingframe.length;
for (k = 0; k < size; k++)
{
if (keyframe[currentframe].shipdata[i].firingframe[k] > 0)
{
for (j = 0; j < 1000; j++)
{
if (laserbeams[j] == null)
{
if (pos == null)
{
pos = new SimpleVector(0, 0, 0);
}
if (adjust == null)
{
adjust = new SimpleVector(0, 0, 1);
}
if (adjustmatrix == null)
{
adjustmatrix = adjust.getRotationMatrix();
}
if (target == null)
{
target = new SimpleVector(0, 0, 1);
}
laserbeams[j] = new LaserBeam();
laserbeams[j].mesh = new Object3D(2);
// create
// mesh....
laserbeams[j].mesh.setCulling(false);
laserbeams[j].mesh.addTriangle(laservert1, 0f, 0f, laservert2, 1f, 0f, laservert3, 1f, 1f);
laserbeams[j].mesh.addTriangle(laservert3, 1f, 1f, laservert4, 0f, 1f, laservert1, 0f, 0f);
laserbeams[j].beammesh = new Object3D(4);
laserbeams[j].beammesh.setCulling(false);
laserbeams[j].beammesh.addTriangle(beamvert1, 0f, 0f, beamvert2, 1f, 0f, beamvert3, 1f, 1f);
laserbeams[j].beammesh.addTriangle(beamvert3, 1f, 1f, beamvert4, 0f, 1f, beamvert1, 0f, 0f);
laserbeams[j].beammesh.addTriangle(beamvert5, 0f, 0f, beamvert6, 1f, 0f, beamvert7, 1f, 1f);
laserbeams[j].beammesh.addTriangle(beamvert7, 1f, 1f, beamvert8, 0f, 1f, beamvert5, 0f, 0f);
laserbeams[j].scale = 1.0f;
if (ships[i].hardpoints[k].weapon.weapontype == 4) // plasma
{
// laserbeams[j].beammesh.setTexture("plasma");
// laserbeams[j].mesh.setTexture("plasma");
laserbeams[j].scale = 4.0f;
if (ships[i].shiptype < 3)
{
laserbeams[j].scale = 8.0f;
}
}
if (ships[i].hardpoints[k].weapon.weapontype == 5) // tractor
{
// laserbeams[j].beammesh.setTexture("bluebeam");
// laserbeams[j].mesh.setTexture("bluebeam");
}
if (ships[i].hardpoints[k].weapon.weapontype == 6) // disruptor
{
// laserbeams[j].beammesh.setTexture("lgbeam"); // need
// to
// add
// laserbeams[j].mesh.setTexture("lgbeam");
if (ships[i].shiptype < 3 && ships[i].hardpoints[k].weapon.isbeam == false)
{
laserbeams[j].scale = 6.0f;
}
}
if (ships[i].hardpoints[k].weapon.weapontype == 7 || ships[i].hardpoints[k].weapon.weapontype == 3) // swarmer
{
// laserbeams[j].beammesh.setTexture("yellowbeam"); // need
// to
// add
// laserbeams[j].mesh.setTexture("yellowbeam"); // need
// to
// add
if (ships[i].shiptype < 3)
{
laserbeams[j].scale = 6.0f;
}
}
if (ships[i].hardpoints[k].weapon.weapontype == 1) // standard
// laser
{
if (ships[i].shiptype < 3)
{
// laserbeams[j].mesh.setTexture("bluebeam");
laserbeams[j].scale = 4.0f;
}
else
{
// laserbeams[j].mesh.setTexture("greenbeam");
}
}
if (ships[i].hardpoints[k].weapon.weapontype == 2) // standard
// beam
{
// laserbeams[j].beammesh.setTexture("purplebeam");
}
// laserbeams[j].beammesh.setTexture("purplebeam");
if (ships[i].team == 1)
{
laserbeams[j].mesh.setTexture("redbeam");
laserbeams[j].beammesh.setTexture("redbeam");
}
if (ships[i].team == 2)
{
laserbeams[j].mesh.setTexture("bluebeam");
laserbeams[j].beammesh.setTexture("bluebeam");
}
if (ships[i].team == 3)
{
laserbeams[j].mesh.setTexture("yellowbeam");
laserbeams[j].beammesh.setTexture("yellowbeam");
}
if (ships[i].team == 4)
{
laserbeams[j].mesh.setTexture("greenbeam");
laserbeams[j].beammesh.setTexture("greenbeam");
}
if (ships[i].team == 5)
{
laserbeams[j].mesh.setTexture("purplebeam");
laserbeams[j].beammesh.setTexture("purplebeam");
}
laserbeams[j].owninghardpointid = k;
/*
* if(ships[i]. hardpoints [k]. weapon.ismissile ) { //laserbeams [j ].mesh.setTexture ("redbeam"); } if(ships[i]. hardpoints [k].
* weapon.ismissile ==false && ships [i].hardpoints [ k].weapon.isbeam ==false) { // laserbeams [j]. mesh.setTexture ( "greenbeam"); }
*/
laserbeams[j].mesh.setTransparency(255);
laserbeams[j].mesh.setTransparencyMode(Object3D.TRANSPARENCY_MODE_ADD);
laserbeams[j].beammesh.setTransparency(255);
laserbeams[j].beammesh.setTransparencyMode(Object3D.TRANSPARENCY_MODE_ADD);
// apply the
// relevant
// shader......
// in this case
// the basic
// shader will
// do.....
Log.d(TAG, "LaserBeam Shader Preparing");
laserbeams[j].mesh.setShader(this.shaders[1]);
laserbeams[j].beammesh.setShader(this.shaders[1]);
Log.d(TAG, "LaserBeam Shader Set");
laserbeams[j].mesh.build();
laserbeams[j].mesh.strip();
laserbeams[j].beammesh.build();
laserbeams[j].beammesh.strip();
world.addObject(laserbeams[j].mesh);
world.addObject(laserbeams[j].beammesh);
laserbeams[j].mesh.setOrigin(SimpleVector.ORIGIN);
laserbeams[j].beammesh.setOrigin(SimpleVector.ORIGIN);
laserbeams[j].movement = new SimpleVector(0, 0, 1);
pos.x = keyframe[currentframe].shipdata[i].fx[k];// x
// +
// pos.x;
pos.y = keyframe[currentframe].shipdata[i].fy[k];// y
// +
// pos.y;
pos.z = keyframe[currentframe].shipdata[i].fz[k];// z
// +
// pos.z;
laserbeams[j].mesh.translate(pos);
laserbeams[j].beammesh.translate(pos);
if (laserbeams[j].wmatrix == null)
{
laserbeams[j].wmatrix = laserbeams[j].mesh.getWorldTransformation();
}
else
{
laserbeams[j].wmatrix = laserbeams[j].mesh.getWorldTransformation(laserbeams[j].wmatrix);
}
if (laserbeams[j].wmatrixB == null)
{
laserbeams[j].wmatrixB = laserbeams[j].beammesh.getWorldTransformation();
}
else
{
laserbeams[j].wmatrixB = laserbeams[j].beammesh.getWorldTransformation(laserbeams[j].wmatrixB);
}
laserbeams[j].targetshipid = keyframe[currentframe].shipdata[i].firingframe[k] - 1;// -1;
// //for
// now...
if (laserbeams[j].isbeam && laserbeams[j].targetshipid >= 0 && laserbeams[j].targetshipid < 32)
{
laserbeams[j].movement.x = keyframe[currentframe].shipdata[laserbeams[j].targetshipid].x - keyframe[currentframe].shipdata[i].fx[k];
laserbeams[j].movement.y = keyframe[currentframe].shipdata[laserbeams[j].targetshipid].y - keyframe[currentframe].shipdata[i].fy[k];
laserbeams[j].movement.z = keyframe[currentframe].shipdata[laserbeams[j].targetshipid].z - keyframe[currentframe].shipdata[i].fz[k];
// what we actually want to do.....is shift the beam from bottom to top through the enemy ship....
// which will help the laser cutting when we split the mesh.....
// perpendicular vector to laserbeam movement......
// find a vector such that the dot product is 0....
angle1 = 0f;
if (ships[laserbeams[j].targetshipid].splitframe > 0)
{
if (Math.abs(currentframe - ships[laserbeams[j].targetshipid].splitframe) < 25)
{
angle1 = 6f * (float) (currentframe - ships[laserbeams[j].targetshipid].splitframe);
}
if (Math.abs(laserbeams[j].movement.x) > Math.abs(laserbeams[j].movement.y))
{
// x is biggest so far
if (Math.abs(laserbeams[j].movement.x) > Math.abs(laserbeams[j].movement.z))
{
// x is definitely the biggest
if (Math.abs(laserbeams[j].movement.z) < 0.01f && Math.abs(laserbeams[j].movement.y) < 0.01f)
{
// we are moving along x axis
// shift movement y up/down by appropriate amount....
laserbeams[j].movement.y += angle1;
}
else
{
// find perpendicular....
// dot = ix * jx + iy * jy + iz * jz = 0
// set jx = 0 so...
// iy*jy = - iz*jz
//
if (Math.abs(laserbeams[j].movement.z) < 0.01f)
{
// perpendicular is going to be in the z direction....
laserbeams[j].movement.z += angle1;
}
else
{
angle2 = (float) Math.sqrt(laserbeams[j].movement.x * laserbeams[j].movement.x + laserbeams[j].movement.y * laserbeams[j].movement.y + laserbeams[j].movement.z * laserbeams[j].movement.z);
if (angle2 > 0)
{
laserbeams[j].movement.z += angle1 * (laserbeams[j].movement.y / angle2);
laserbeams[j].movement.y += angle1 * (laserbeams[j].movement.z / angle2);
}
}
}
}
else
{
// z is the biggest
if (Math.abs(laserbeams[j].movement.x) < 0.01f && Math.abs(laserbeams[j].movement.y) < 0.01f)
{
// we are moving along z axis
laserbeams[j].movement.y += angle1;
}
else
{
if (Math.abs(laserbeams[j].movement.y) < 0.01f)
{
// perpendicular is going to be in the x direction....
laserbeams[j].movement.x += angle1;
}
else
{
angle2 = (float) Math.sqrt(laserbeams[j].movement.x * laserbeams[j].movement.x + laserbeams[j].movement.y * laserbeams[j].movement.y + laserbeams[j].movement.z * laserbeams[j].movement.z);
if (angle2 > 0)
{
laserbeams[j].movement.x += angle1 * (laserbeams[j].movement.y / angle2);
laserbeams[j].movement.y += angle1 * (laserbeams[j].movement.z / angle2);
}
}
}
}
}
else
{
// y is biggest so far
if (Math.abs(laserbeams[j].movement.y) > Math.abs(laserbeams[j].movement.z))
{
// y is definitely the biggest
if (Math.abs(laserbeams[j].movement.z) < 0.01f && Math.abs(laserbeams[j].movement.x) < 0.01f)
{
// we are moving along y axis
laserbeams[j].movement.x += angle1;
}
else
{
if (Math.abs(laserbeams[j].movement.y) < 0.01f)
{
// perpendicular is going to be in the y direction....
laserbeams[j].movement.y += angle1;
}
else
{
angle2 = (float) Math.sqrt(laserbeams[j].movement.x * laserbeams[j].movement.x + laserbeams[j].movement.y * laserbeams[j].movement.y + laserbeams[j].movement.z * laserbeams[j].movement.z);
if (angle2 > 0)
{
laserbeams[j].movement.x += angle1 * (laserbeams[j].movement.y / angle2);
laserbeams[j].movement.y += angle1 * (laserbeams[j].movement.z / angle2);
}
}
}
}
else
{
// z is the biggest
if (Math.abs(laserbeams[j].movement.z) < 0.01f && Math.abs(laserbeams[j].movement.x) < 0.01f)
{
// we are moving along z axis
laserbeams[j].movement.x += angle1;
}
else
{
if (Math.abs(laserbeams[j].movement.z) < 0.01f)
{
// perpendicular is going to be in the z direction....
laserbeams[j].movement.z += angle1;
}
else
{
angle2 = (float) Math.sqrt(laserbeams[j].movement.x * laserbeams[j].movement.x + laserbeams[j].movement.y * laserbeams[j].movement.y + laserbeams[j].movement.z * laserbeams[j].movement.z);
if (angle2 > 0)
{
laserbeams[j].movement.x += angle1 * (laserbeams[j].movement.y / angle2);
laserbeams[j].movement.z += angle1 * (laserbeams[j].movement.z / angle2);
}
}
}
}
}
}
}
else
{
laserbeams[j].movement.x = keyframe[currentframe].shipdata[i].fux[k] * laserbeams[j].scale;
laserbeams[j].movement.y = keyframe[currentframe].shipdata[i].fuy[k] * laserbeams[j].scale;
laserbeams[j].movement.z = keyframe[currentframe].shipdata[i].fuz[k] * laserbeams[j].scale;
}
if (laserbeams[j].rmatrix == null)
{
laserbeams[j].rmatrix = laserbeams[j].mesh.getRotationMatrix();
laserbeams[j].rmatrix = laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrix);
}
else
{
laserbeams[j].rmatrix = laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrix);
}
if (laserbeams[j].rmatrixB == null)
{
laserbeams[j].rmatrixB = laserbeams[j].beammesh.getRotationMatrix();
laserbeams[j].rmatrixB = laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrixB);
}
else
{
laserbeams[j].rmatrixB = laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrixB);
}
laserbeams[j].mesh.setRotationMatrix(laserbeams[j].rmatrix);
laserbeams[j].beammesh.setRotationMatrix(laserbeams[j].rmatrixB);
laserbeams[j].team = keyframe[currentframe].shipteam[i];
laserbeams[j].lifetime = ships[i].hardpoints[k].weapon.baselifetime;
laserbeams[j].guidedturnrate = ships[i].hardpoints[k].weapon.guidedturnrate;
laserbeams[j].isguided = ships[i].hardpoints[k].weapon.isguided;
laserbeams[j].isbeam = ships[i].hardpoints[k].weapon.isbeam;
if (laserbeams[j].isbeam)
{
laserbeams[j].lifetime = 4; // beam will have a trail now...
if (laserbeams[j].targetshipid >= 0 && laserbeams[j].targetshipid < 32)
{
laserbeams[j].beammesh.setVisibility(true);
}
laserbeams[j].mesh.setVisibility(false);
}
else
{
laserbeams[j].beammesh.setVisibility(false);
laserbeams[j].mesh.setVisibility(true);
}
laserbeams[j].ismissile = ships[i].hardpoints[k].weapon.ismissile;
laserbeams[j].maxvel = ships[i].hardpoints[k].weapon.muzzlevel;
laserbeams[j].owningshipid = i;
laserbeams[j].owningshipteam = ships[i].team;
break;
}
// laserbeams[j].scale = 1f;
if (laserbeams[j].lifetime <= 0)
{
laserbeams[j].scale = 1.0f;
if (ships[i].hardpoints[k].weapon.weapontype == 4) // plasma
{
// laserbeams[j].beammesh.setTexture("plasma");
// laserbeams[j].mesh.setTexture("plasma");
laserbeams[j].scale = 4.0f;
if (ships[i].shiptype < 3)
{
laserbeams[j].scale = 8.0f;
}
}
if (ships[i].hardpoints[k].weapon.weapontype == 5) // tractor
{
// laserbeams[j].beammesh.setTexture("bluebeam");
// laserbeams[j].mesh.setTexture("bluebeam");
}
if (ships[i].hardpoints[k].weapon.weapontype == 6) // disruptor
{
// laserbeams[j].beammesh.setTexture("lgbeam"); // need
// to
// add
// laserbeams[j].mesh.setTexture("lgbeam");
if (ships[i].shiptype < 3 && ships[i].hardpoints[k].weapon.isbeam == false)
{
laserbeams[j].scale = 6.0f;
}
}
if (ships[i].hardpoints[k].weapon.weapontype == 7 || ships[i].hardpoints[k].weapon.weapontype == 3) // swarmer
{
// laserbeams[j].beammesh.setTexture("yellowbeam"); // need
// to
// add
// laserbeams[j].mesh.setTexture("yellowbeam"); // need
// to
// add
if (ships[i].shiptype < 3)
{
laserbeams[j].scale = 6.0f;
}
}
if (ships[i].hardpoints[k].weapon.weapontype == 1) // standard
// laser
{
if (ships[i].shiptype < 3)
{
// laserbeams[j].mesh.setTexture("bluebeam");
laserbeams[j].scale = 4.0f;
}
else
{
// laserbeams[j].mesh.setTexture("greenbeam");
}
}
if (ships[i].hardpoints[k].weapon.weapontype == 2) // standard
// beam
{
// laserbeams[j].beammesh.setTexture("purplebeam");
}
if (ships[i].team == 1)
{
laserbeams[j].mesh.setTexture("redbeam");
laserbeams[j].beammesh.setTexture("redbeam");
}
if (ships[i].team == 2)
{
laserbeams[j].mesh.setTexture("bluebeam");
laserbeams[j].beammesh.setTexture("bluebeam");
}
if (ships[i].team == 3)
{
laserbeams[j].mesh.setTexture("yellowbeam");
laserbeams[j].beammesh.setTexture("yellowbeam");
}
if (ships[i].team == 4)
{
laserbeams[j].mesh.setTexture("greenbeam");
laserbeams[j].beammesh.setTexture("greenbeam");
}
if (ships[i].team == 5)
{
laserbeams[j].mesh.setTexture("purplebeam");
laserbeams[j].beammesh.setTexture("purplebeam");
}
/*
*
* if(ships[i]. hardpoints [k]. weapon.ismissile ) { laserbeams [j]. mesh.setTexture ("redbeam"); } if(ships[i]. hardpoints [k].
* weapon.ismissile ==false && ships [i].hardpoints [ k].weapon.isbeam ==false) { laserbeams [j]. mesh.setTexture ( "greenbeam"); }
*/
laserbeams[j].team = keyframe[currentframe].shipteam[i];
laserbeams[j].owninghardpointid = k;
if (ships[i].hardpoints[k].weapon.isbeam)
{
laserbeams[j].isbeam = true;
if (laserbeams[j].wmatrixB == null)
{
laserbeams[j].wmatrixB = laserbeams[j].beammesh.getWorldTransformation();
}
else
{
laserbeams[j].wmatrixB = laserbeams[j].beammesh.getWorldTransformation(laserbeams[j].wmatrixB);
}
if (oldt == null)
{
oldt = laserbeams[j].wmatrixB.getTranslation();
}
else
{
oldt = laserbeams[j].wmatrixB.getTranslation(oldt);
}
oldt.scalarMul(-1f);
laserbeams[j].beammesh.translate(oldt);
}
else
{
laserbeams[j].isbeam = false;
if (laserbeams[j].wmatrix == null)
{
laserbeams[j].wmatrix = laserbeams[j].mesh.getWorldTransformation();
}
else
{
laserbeams[j].wmatrix = laserbeams[j].mesh.getWorldTransformation(laserbeams[j].wmatrix);
}
if (oldt == null)
{
oldt = laserbeams[j].wmatrix.getTranslation();
}
else
{
oldt = laserbeams[j].wmatrix.getTranslation(oldt);
}
oldt.scalarMul(-1f);
laserbeams[j].mesh.translate(oldt);
}
pos.x = keyframe[currentframe].shipdata[i].fx[k];// x
// +
// pos.x;
pos.y = keyframe[currentframe].shipdata[i].fy[k];// y
// +
// pos.y;
pos.z = keyframe[currentframe].shipdata[i].fz[k];// z
// +
// pos.z;
if (laserbeams[j].isbeam)
{
laserbeams[j].beammesh.translate(pos);
}
else
{
laserbeams[j].mesh.translate(pos);
}
laserbeams[j].targetshipid = keyframe[currentframe].shipdata[i].firingframe[k] - 1;// -1;
// //for
// now...
if (laserbeams[j].isbeam && laserbeams[j].targetshipid >= 0 && laserbeams[j].targetshipid < 32)
{
laserbeams[j].movement.x = keyframe[currentframe].shipdata[laserbeams[j].targetshipid].x - keyframe[currentframe].shipdata[i].fx[k];
laserbeams[j].movement.y = keyframe[currentframe].shipdata[laserbeams[j].targetshipid].y - keyframe[currentframe].shipdata[i].fy[k];
laserbeams[j].movement.z = keyframe[currentframe].shipdata[laserbeams[j].targetshipid].z - keyframe[currentframe].shipdata[i].fz[k];
// what we actually want to do.....is shift the beam from bottom to top through the enemy ship....
// which will help the laser cutting when we split the mesh.....
// perpendicular vector to laserbeam movement......
// find a vector such that the dot product is 0....
angle1 = 0f;
if (ships[laserbeams[j].targetshipid].splitframe > 0)
{
if (Math.abs(currentframe - ships[laserbeams[j].targetshipid].splitframe) < 25)
{
angle1 = 6f * (float) (currentframe - ships[laserbeams[j].targetshipid].splitframe);
}
if (Math.abs(laserbeams[j].movement.x) > Math.abs(laserbeams[j].movement.y))
{
// x is biggest so far
if (Math.abs(laserbeams[j].movement.x) > Math.abs(laserbeams[j].movement.z))
{
// x is definitely the biggest
if (Math.abs(laserbeams[j].movement.z) < 0.01f && Math.abs(laserbeams[j].movement.y) < 0.01f)
{
// we are moving along x axis
// shift movement y up/down by appropriate amount....
laserbeams[j].movement.y += angle1;
}
else
{
// find perpendicular....
// dot = ix * jx + iy * jy + iz * jz = 0
// set jx = 0 so...
// iy*jy = - iz*jz
//
if (Math.abs(laserbeams[j].movement.z) < 0.01f)
{
// perpendicular is going to be in the z direction....
laserbeams[j].movement.z += angle1;
}
else
{
angle2 = (float) Math.sqrt(laserbeams[j].movement.x * laserbeams[j].movement.x + laserbeams[j].movement.y * laserbeams[j].movement.y + laserbeams[j].movement.z * laserbeams[j].movement.z);
if (angle2 > 0)
{
laserbeams[j].movement.z += angle1 * (laserbeams[j].movement.y / angle2);
laserbeams[j].movement.y += angle1 * (laserbeams[j].movement.z / angle2);
}
}
}
}
else
{
// z is the biggest
if (Math.abs(laserbeams[j].movement.x) < 0.01f && Math.abs(laserbeams[j].movement.y) < 0.01f)
{
// we are moving along z axis
laserbeams[j].movement.y += angle1;
}
else
{
if (Math.abs(laserbeams[j].movement.y) < 0.01f)
{
// perpendicular is going to be in the x direction....
laserbeams[j].movement.x += angle1;
}
else
{
angle2 = (float) Math.sqrt(laserbeams[j].movement.x * laserbeams[j].movement.x + laserbeams[j].movement.y * laserbeams[j].movement.y + laserbeams[j].movement.z * laserbeams[j].movement.z);
if (angle2 > 0)
{
laserbeams[j].movement.x += angle1 * (laserbeams[j].movement.y / angle2);
laserbeams[j].movement.y += angle1 * (laserbeams[j].movement.z / angle2);
}
}
}
}
}
else
{
// y is biggest so far
if (Math.abs(laserbeams[j].movement.y) > Math.abs(laserbeams[j].movement.z))
{
// y is definitely the biggest
if (Math.abs(laserbeams[j].movement.z) < 0.01f && Math.abs(laserbeams[j].movement.x) < 0.01f)
{
// we are moving along y axis
laserbeams[j].movement.x += angle1;
}
else
{
if (Math.abs(laserbeams[j].movement.y) < 0.01f)
{
// perpendicular is going to be in the y direction....
laserbeams[j].movement.y += angle1;
}
else
{
angle2 = (float) Math.sqrt(laserbeams[j].movement.x * laserbeams[j].movement.x + laserbeams[j].movement.y * laserbeams[j].movement.y + laserbeams[j].movement.z * laserbeams[j].movement.z);
if (angle2 > 0)
{
laserbeams[j].movement.x += angle1 * (laserbeams[j].movement.y / angle2);
laserbeams[j].movement.y += angle1 * (laserbeams[j].movement.z / angle2);
}
}
}
}
else
{
// z is the biggest
if (Math.abs(laserbeams[j].movement.z) < 0.01f && Math.abs(laserbeams[j].movement.x) < 0.01f)
{
// we are moving along z axis
laserbeams[j].movement.x += angle1;
}
else
{
if (Math.abs(laserbeams[j].movement.z) < 0.01f)
{
// perpendicular is going to be in the z direction....
laserbeams[j].movement.z += angle1;
}
else
{
angle2 = (float) Math.sqrt(laserbeams[j].movement.x * laserbeams[j].movement.x + laserbeams[j].movement.y * laserbeams[j].movement.y + laserbeams[j].movement.z * laserbeams[j].movement.z);
if (angle2 > 0)
{
laserbeams[j].movement.x += angle1 * (laserbeams[j].movement.y / angle2);
laserbeams[j].movement.z += angle1 * (laserbeams[j].movement.z / angle2);
}
}
}
}
}
}
}
else
{
laserbeams[j].movement.x = keyframe[currentframe].shipdata[i].fux[k] * laserbeams[j].scale;
laserbeams[j].movement.y = keyframe[currentframe].shipdata[i].fuy[k] * laserbeams[j].scale;
laserbeams[j].movement.z = keyframe[currentframe].shipdata[i].fuz[k] * laserbeams[j].scale;
}
if (laserbeams[j].rmatrix == null)
{
laserbeams[j].rmatrix = laserbeams[j].mesh.getRotationMatrix();
laserbeams[j].rmatrix = laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrix);
}
else
{
laserbeams[j].rmatrix = laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrix);
}
if (laserbeams[j].rmatrixB == null)
{
laserbeams[j].rmatrixB = laserbeams[j].beammesh.getRotationMatrix();
laserbeams[j].rmatrixB = laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrixB);
}
else
{
laserbeams[j].rmatrixB = laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrixB);
}
laserbeams[j].mesh.setRotationMatrix(laserbeams[j].rmatrix);
laserbeams[j].beammesh.setRotationMatrix(laserbeams[j].rmatrixB);
if (laserbeams[j].isbeam)
{
if (laserbeams[j].targetshipid >= 0 && laserbeams[j].targetshipid < 32)
{
laserbeams[j].beammesh.setVisibility(true);
}
laserbeams[j].mesh.setVisibility(false);
laserbeams[j].lifetime = 4;
}
else
{
laserbeams[j].beammesh.setVisibility(false);
laserbeams[j].mesh.setVisibility(true);
laserbeams[j].lifetime = ships[i].hardpoints[k].weapon.baselifetime;
}
laserbeams[j].guidedturnrate = ships[i].hardpoints[k].weapon.guidedturnrate;
laserbeams[j].isguided = ships[i].hardpoints[k].weapon.isguided;
laserbeams[j].ismissile = ships[i].hardpoints[k].weapon.ismissile;
laserbeams[j].maxvel = ships[i].hardpoints[k].weapon.muzzlevel;
laserbeams[j].owningshipid = i;
laserbeams[j].owningshipteam = ships[i].team;
break;
}
}
}
}
}
}
for (j = 0; j < 1000; j++)
{
if (laserbeams[j] != null)
{
if (laserbeams[j].lifetime > 0)
{
laserbeams[j].lifetime--;
if (laserbeams[j].isguided == true && laserbeams[j].isbeam == false)
{
if (laserbeams[j].targetshipid >= 0 && laserbeams[j].targetshipid < 32)
{
// adjust vx,vy,vz
// accordingly.....
i = laserbeams[j].targetshipid;
if (ships[i] != null)
{
if (ships[i].hp > 0)
{
// okay so
// adjust
// ever so
// slightly.....
if (pos == null)
{
pos = new SimpleVector(0, 0, 1);
}
if (adjustmatrix == null)
{
adjustmatrix = laserbeams[j].mesh.getWorldTransformation();
}
else
{
adjustmatrix = laserbeams[j].mesh.getWorldTransformation(adjustmatrix);
}
pos = adjustmatrix.getTranslation(pos);
mdx = ships[i].x - pos.x;
mdy = ships[i].y - pos.y;
mdz = ships[i].z - pos.z;
mlen = (float) Math.sqrt(mdx * mdx + mdy * mdy + mdz * mdz);
if (mlen > 0)
{
mdx /= mlen;
mdy /= mlen;
mdz /= mlen;
bvx = laserbeams[j].movement.x;
bvy = laserbeams[j].movement.y;
bvz = laserbeams[j].movement.z;
blen = (float) Math.sqrt(bvx * bvx + bvy * bvy + bvz * bvz);
if (blen > 0)
{
bvx /= blen;
bvy /= blen;
bvz /= blen;
}
bvx += (mdx) * laserbeams[j].guidedturnrate;
bvy += (mdy) * laserbeams[j].guidedturnrate;
bvz += (mdz) * laserbeams[j].guidedturnrate;
blen = (float) Math.sqrt(bvx * bvx + bvy * bvy + bvz * bvz);
if (blen > 0)
{
bvx /= blen;
bvy /= blen;
bvz /= blen;
}
laserbeams[j].movement.x = bvx * laserbeams[j].maxvel * laserbeams[j].scale;
;
laserbeams[j].movement.y = bvy * laserbeams[j].maxvel * laserbeams[j].scale;
;
laserbeams[j].movement.z = bvz * laserbeams[j].maxvel * laserbeams[j].scale;
;
// need
// to
// rotate
// as
// well.....
if (laserbeams[j].rmatrix == null)
{
laserbeams[j].rmatrix = laserbeams[j].mesh.getRotationMatrix();
laserbeams[j].rmatrix = laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrix);
}
else
{
laserbeams[j].rmatrix = laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrix);
}
laserbeams[j].mesh.setRotationMatrix(laserbeams[j].rmatrix);
}
}
}
}
}
if (!laserbeams[j].isbeam)
{
laserbeams[j].mesh.translate(laserbeams[j].movement);
/*
* if (laserbeams[j].rmatrix == null) { laserbeams[j].rmatrix = laserbeams[j].mesh.getRotationMatrix(); } else { laserbeams[j].rmatrix =
* laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrix); } laserbeams[j].mesh.setRotationMatrix(laserbeams[j].rmatrix);
*/
}
else
{
/*
* if (laserbeams[j].rmatrixB == null) { laserbeams[j].rmatrixB = laserbeams[j].beammesh.getRotationMatrix(); } else { laserbeams[j].rmatrixB =
* laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrixB); } laserbeams[j].beammesh.setRotationMatrix(laserbeams[j].rmatrixB);
*/
}
if (laserbeams[j].lifetime <= 0)
{
// if (laserbeams[j].isbeam)
// {
laserbeams[j].beammesh.setVisibility(false);
// }
// else
// {
laserbeams[j].mesh.setVisibility(false);
// }
}
}
}
else
{
break;
}
}
if (esprites != null)
{
for (i = 0; i < MAXESPRITES / LOWSPECDIV; i++)
{
if (esprites[i] != null)
{
if (espriteframe[i] == -1)
{
continue;
}
if (espriteframe[i] == 0)
{
esprites[i].setVisibility(true);
// Log.i(TAG,"esprite should be visible now");
}
// have a slight pause
// between frames...probably
// too fast at the
// moment....
if (currentframe % 3 != 0)
{
continue;
}
// change texture coords of
// the sprite.....
if (espriteframe[i] >= 64)
{
esprites[i].setVisibility(false);
espriteframe[i] = -1;
espritetexmatrix[i].translate(-0.875f, -0.875f, 0f);
esprites[i].setTextureMatrix(espritetexmatrix[i]);
esprites[i].touch();
}
else
{
if (espriteframe[i] % 8 == 0)
{
if (espriteframe[i] != 0)
{
espritetexmatrix[i].translate(-0.875f, 0.125f, 0f);
esprites[i].setTextureMatrix(espritetexmatrix[i]);
esprites[i].touch();
}
}
else
{
espritetexmatrix[i].translate(0.125f, 0f, 0f);
esprites[i].setTextureMatrix(espritetexmatrix[i]);
esprites[i].touch();
}
espriteframe[i]++;
}
}
}
}
// ////////////////////////////DUPLICATE
// OF BELOW CODE
}
currentframe = newframe;
settingframe = false;
// end of time slider calculation...
}
}
}
}
}
}
}
if (currentframe >= 0 && currentframe < maxframes)
{
if (keyframe[currentframe].shipdata != null)
{
for (i = 0; i < 32; i++)
{
if (keyframe[currentframe].shipdata[i] != null)
{
// all we care about is positioning and rotating
// meshes....and making them disappear when hp <=0
if (showstats)
{
ships[i].hh.highlighton = true;
if (ships[i].team == 1)
{
ships[i].hh.ff[0] = 2f;
ships[i].hh.ff[1] = 0f;
ships[i].hh.ff[2] = 0f;
}
if (ships[i].team == 2)
{
ships[i].hh.ff[2] = 2f;
ships[i].hh.ff[1] = 2f;
ships[i].hh.ff[0] = 0f;
}
if (ships[i].team == 3)
{
ships[i].hh.ff[0] = 2f;
ships[i].hh.ff[1] = 2f;
ships[i].hh.ff[2] = 0f;
}
if (ships[i].team == 4)
{
ships[i].hh.ff[1] = 2f;
ships[i].hh.ff[0] = 0f;
ships[i].hh.ff[2] = 0f;
}
if (ships[i].team == 5)
{
ships[i].hh.ff[0] = 2f;
ships[i].hh.ff[1] = 0f;
ships[i].hh.ff[2] = 2f;
}
ships[i].hh.ff[3] = (float) keyframe[currentframe].shipdata[i].hp / (float) ships[i].fullhp;
}
else
{
ships[i].hh.highlighton = false;
}
if (keyframe[currentframe].shipdata[i].hp <= 0 && viewmode == false)
{
// oops should have had this ages ago.....
// ship should still keep on moving! even though destroyed...retains momentum etc....
// ships[i].pivot.translate(ships[i].vx, ships[i].vy, ships[i].vz);
ships[i].mesh[0].setVisibility(false);
/*
* if (ships[i].meshhalfA != null) { ships[i].meshhalfA.setVisibility(false); } if (ships[i].meshhalfB != null) { ships[i].meshhalfB.setVisibility(false); }
*/
// also hide the ship hud hp indicator...
// however if hp == -10000 then we want to show the mesh halves....and start the moving....
if (keyframe[currentframe].shipdata[i].hp == -10000 && (currentframe - ships[i].splitframe) < 600)
{
/*
* if (ships[i].meshhalfA != null) { ships[i].meshhalfA.setVisibility(true); } if (ships[i].meshhalfB != null) { ships[i].meshhalfB.setVisibility(true); }
*/
if (currentframe > 0)
{
/*
* if (ships[i].meshhalfA != null) // this will all change.... {
*
*
* if (ships[i].wmatrix == null) { ships[i].wmatrix = ships[i].pivot.getWorldTransformation(); } else { ships[i].wmatrix =
* ships[i].pivot.getWorldTransformation(ships[i].wmatrix); } if (pos == null) { pos = ships[i].wmatrix.getTranslation(); } pos =
* ships[i].wmatrix.getTranslation(pos); pos.scalarMul(-1); if (!viewmode) { // this puts the pivot back to the origin... ships[i].pivot.translate(pos);
*
* if (target == null) { target = new SimpleVector(0, 0, 0); }
*
* // and then reposition him.... ships[i].pivot.translate(keyframe[currentframe].shipdata[i].x, keyframe[currentframe].shipdata[i].y,
* keyframe[currentframe].shipdata[i].z); } pos = ships[i].meshhalfA.getTranslation(pos); pos.scalarMul(-1f); ships[i].meshhalfA.translate(pos);
* ships[i].meshhalfA.translate((float) (currentframe - ships[i].splitframe) * 0.3f * ships[i].aa.cuttingplane[1], (float) (currentframe - ships[i].splitframe) *
* 0.3f * ships[i].aa.cuttingplane[2], (float) (currentframe - ships[i].splitframe) * 0.3f * ships[i].aa.cuttingplane[0]);
*
* // also set the alpha of the vessel..... if (currentframe - ships[i].splitframe < 500 && currentframe - ships[i].splitframe > 0) { tmpi = (int) (512.0f * (1.0f -
* (float) (currentframe - ships[i].splitframe) / (501.0f))); if (tmpi > 255) { tmpi = 255; } if (tmpi < 1) { tmpi = 1; } //
* ships[i].meshhalfA.setTransparency(tmpi); } } if (ships[i].meshhalfB != null) { //
* ships[i].meshhalfB.translate(-0.1f*ships[i].bb.cuttingplane[1],-0.1f*ships[i].bb.cuttingplane[2],-0.1f*ships[i].bb.cuttingplane[0]);
*
* // translate back to origin. // then move according to aa/bb
*
* if (ships[i].wmatrix == null) { ships[i].wmatrix = ships[i].pivot.getWorldTransformation(); } else { ships[i].wmatrix =
* ships[i].pivot.getWorldTransformation(ships[i].wmatrix); } if (pos == null) { pos = ships[i].wmatrix.getTranslation(); } pos =
* ships[i].wmatrix.getTranslation(pos); pos.scalarMul(-1); if (!viewmode) { // this puts the pivot back to the origin... ships[i].pivot.translate(pos);
*
* if (target == null) { target = new SimpleVector(0, 0, 0); }
*
* // and then reposition him.... ships[i].pivot.translate(keyframe[currentframe].shipdata[i].x, keyframe[currentframe].shipdata[i].y,
* keyframe[currentframe].shipdata[i].z); } pos = ships[i].meshhalfB.getTranslation(pos); pos.scalarMul(-1f); ships[i].meshhalfB.translate(pos);
* ships[i].meshhalfB.translate((float) (currentframe - ships[i].splitframe) * 0.3f * ships[i].bb.cuttingplane[1], (float) (currentframe - ships[i].splitframe) *
* 0.3f * ships[i].bb.cuttingplane[2], (float) (currentframe - ships[i].splitframe) * 0.3f * ships[i].bb.cuttingplane[0]);
*
* if (currentframe - ships[i].splitframe < 500 && currentframe - ships[i].splitframe > 0) { tmpi = (int) (512.0f * (1.0f - (float) (currentframe -
* ships[i].splitframe) / (501.0f))); if (tmpi > 255) { tmpi = 255; } if (tmpi < 1) { tmpi = 1; } // ships[i].meshhalfB.setTransparency(tmpi); } }
*/
}
}
if (teamhpsprites != null)
{
if (teamhpsprites[i] != null)
{
teamhpsprites[i].setVisibility(false);
}
}
//engine sprites hide when hp dead = 0
if(enginesprites!=null)
{
if(enginesprites[i*2]!=null)
{
enginesprites[i*2].setVisibility(false);
}
if(enginesprites[i*2+1]!=null)
{
enginesprites[i*2+1].setVisibility(false);
}
}
}
else
{
ships[i].mesh[0].setVisibility(true);
/*
* if (ships[i].meshhalfA != null) { ships[i].meshhalfA.setVisibility(false); } if (ships[i].meshhalfB != null) { ships[i].meshhalfB.setVisibility(false); }
*/
// set the hp indicators.....
if (teamhpsprites != null && teamhptexmatrix != null && teamhpucoord != null && teamhpvcoord != null)
{
// update health hud info for each ship.....
teamhptexmatrix[i].translate(-teamhpucoord[i], -teamhpvcoord[i], 0);
angle1 = ((100 * keyframe[currentframe].shipdata[i].hp) / ships[i].fullhp);
if (angle1 < 25)
{
;
angle2 = 0.75f;
}
if (angle1 >= 25 && angle1 < 50)
{
angle2 = 0.5f;
}
if (angle1 >= 50 && angle1 < 75)
{
angle2 = 0.25f;
}
if (angle1 >= 75)
{
angle2 = 0f;
}
if (currentframe > 0)
{
if (keyframe[currentframe - 1].shipdata[i].hp != keyframe[currentframe].shipdata[i].hp)
{
if (angle2 > 0)
{
angle2 = 0.25f; // when taking
// damage flicker...
}
else
{
angle2 = 0; // when taking damage
// flicker...
}
teamhpsprites[i].setScale(1.1f); // grow
// 10%
// in
// size
// as
// well..
}
else
{
teamhpsprites[i].setScale(1f);
}
}
teamhpucoord[i] = angle2;
teamhpvcoord[i] = (ships[i].shiptype - 1) * 0.25f;
teamhptexmatrix[i].translate(angle2, (ships[i].shiptype - 1) * 0.25f, 0);
teamhpsprites[i].setTextureMatrix(teamhptexmatrix[i]);
teamhpsprites[i].touch();
if (keyframe[currentframe].shipdata[i].hp > 0)
{
teamhpsprites[i].setVisibility(true);
}
else
{
teamhpsprites[i].setVisibility(false);
}
}
if (viewmode) // not used at all now...currently.
{
if (((currentframe / 1000) % 8) == (i % 8) && i < 8)
{
ships[i].mesh[0].setVisibility(true);
Log.i(TAG, "Mesh visible:" + i);
}
else
{
ships[i].mesh[0].setVisibility(false);
Log.i(TAG, "Mesh invisible:" + i);
}
}
if (ships[i].wmatrix == null)
{
ships[i].wmatrix = ships[i].pivot.getWorldTransformation();
}
else
{
ships[i].wmatrix = ships[i].pivot.getWorldTransformation(ships[i].wmatrix);
}
if (pos == null)
{
pos = ships[i].wmatrix.getTranslation();
}
pos = ships[i].wmatrix.getTranslation(pos);
pos.scalarMul(-1);
if (!viewmode)
{
// this puts the pivot back to the origin...
ships[i].pivot.translate(pos);
if (target == null)
{
target = new SimpleVector(0, 0, 0);
}
// and then reposition him....
ships[i].pivot.translate(keyframe[currentframe].shipdata[i].x, keyframe[currentframe].shipdata[i].y, keyframe[currentframe].shipdata[i].z);
}
if (currentframe > 0)
{
pos.x = keyframe[currentframe].shipdata[i].x - keyframe[currentframe - 1].shipdata[i].x;
pos.y = keyframe[currentframe].shipdata[i].y - keyframe[currentframe - 1].shipdata[i].y;
pos.z = keyframe[currentframe].shipdata[i].z - keyframe[currentframe - 1].shipdata[i].z;
if (!viewmode)
{
ships[i].vx = pos.x;
ships[i].vy = pos.y;
ships[i].vz = pos.z;
}
else
{
pos.x = 0;
pos.y = 0;
pos.z = -1;
ships[i].vx = 0;
ships[i].vy = 0;
ships[i].vz = 0;
}
pos = pos.normalize(pos);
if (ships[i].rmatrix == null)
{
ships[i].rmatrix = pos.getRotationMatrix();
}
else
{
ships[i].rmatrix = pos.getRotationMatrix(ships[i].rmatrix);
}
ships[i].pivot.setRotationMatrix(ships[i].rmatrix);
//place engine trail behind fighters and bombers.....
//this is hardcoded for position based on the ship type.......
//has to be unfortunately at this stage of development......
//ENGINE TRAILS HERE
if(ships[i].shiptype > 2)
{
if((ships[i].shiptype==3 && ships[i].team==1) || ships[i].team==2 || ships[i].team==5 || (ships[i].team==3 && ships[i].shiptype==3 ))
{
//ships with 1 engine...
//engine sprite = i*2.....
enginesprites[i*2].setVisibility(true);
if(ships[i].epivot1!=null)
{
adjustmatrix = enginesprites[i*2].getWorldTransformation(adjustmatrix);
pos = adjustmatrix.getTranslation(pos);
pos.scalarMul(-1f);
enginesprites[i*2].translate(pos);
adjustmatrix = ships[i].epivot1.getWorldTransformation(adjustmatrix);
pos = adjustmatrix.getTranslation(pos);
enginesprites[i*2].translate(pos);
enginesprites[i*2].setRotationMatrix(ships[i].rmatrix);
}
//adjust engine sprites scale ever so slightly....
if (enginespriteframe[i*2] >= 16)
{
enginespriteframe[i*2] = 0;
enginespritetexmatrix[i*2].translate(-0.75f, -0.75f, 0f);
enginesprites[i*2].setTextureMatrix(enginespritetexmatrix[i*2]);
enginesprites[i*2].touch();
}
else
{
if (enginespriteframe[i*2] % 4 == 0)
{
if (enginespriteframe[i*2] != 0)
{
enginespritetexmatrix[i*2].translate(-0.75f, 0.25f, 0f);
enginesprites[i*2].setTextureMatrix(enginespritetexmatrix[i*2]);
enginesprites[i*2].touch();
}
}
else
{
enginespritetexmatrix[i*2].translate(0.25f, 0f, 0f);
enginesprites[i*2].setTextureMatrix(enginespritetexmatrix[i*2]);
enginesprites[i*2].touch();
}
enginespriteframe[i*2]++;
}
}
else
{
//ships with 2 engines...
//engine sprite = i*2 and i*2 + 1.....
//engines are lower down the y axis...
//engine sprite = i*2.....
for(j=0;j<2;j++)
{
enginesprites[i*2+j].setVisibility(true);
if(j==0)
{
if(ships[i].epivot1!=null)
{
adjustmatrix = enginesprites[i*2].getWorldTransformation(adjustmatrix);
pos = adjustmatrix.getTranslation(pos);
pos.scalarMul(-1f);
enginesprites[i*2].translate(pos);
adjustmatrix = ships[i].epivot1.getWorldTransformation(adjustmatrix);
pos = adjustmatrix.getTranslation(pos);
enginesprites[i*2].translate(pos);
enginesprites[i*2].setRotationMatrix(ships[i].rmatrix);
}
}
else
{
if(ships[i].epivot2!=null)
{
adjustmatrix = enginesprites[i*2+1].getWorldTransformation(adjustmatrix);
pos = adjustmatrix.getTranslation(pos);
pos.scalarMul(-1f);
enginesprites[i*2+1].translate(pos);
adjustmatrix = ships[i].epivot2.getWorldTransformation(adjustmatrix);
pos = adjustmatrix.getTranslation(pos);
enginesprites[i*2+1].translate(pos);
enginesprites[i*2+1].setRotationMatrix(ships[i].rmatrix);
}
}
if (enginespriteframe[i*2+j] >= 16)
{
enginespriteframe[i*2+j] = 0;
enginespritetexmatrix[i*2+j].translate(-0.75f, -0.75f, 0f);
enginesprites[i*2+j].setTextureMatrix(enginespritetexmatrix[i*2]);
enginesprites[i*2+j].touch();
}
else
{
if (enginespriteframe[i*2+j] % 4 == 0)
{
if (enginespriteframe[i*2+j] != 0)
{
enginespritetexmatrix[i*2+j].translate(-0.75f, 0.25f, 0f);
enginesprites[i*2+j].setTextureMatrix(enginespritetexmatrix[i*2+j]);
enginesprites[i*2+j].touch();
}
}
else
{
enginespritetexmatrix[i*2+j].translate(0.25f, 0f, 0f);
enginesprites[i*2+j].setTextureMatrix(enginespritetexmatrix[i*2+j]);
enginesprites[i*2+j].touch();
}
enginespriteframe[i*2+j]++;
}
}
}
}
tmpboolean = false;
smoking = false;
massiveexplosion = false;
if (currentframe + 50 < maxframes && ships[i].shiptype < 3)
{
if (keyframe[currentframe + 50].shipdata[i].hp <= 0 && keyframe[currentframe].shipdata[i].hp < ships[i].fullhp && keyframe[currentframe].shipdata[i].hp > 0 && keyframe[currentframe + 50].shipdata[i].hp > -10000 && ships[i].splitframe <= 0)
{
if (currentframe % 10 == 0)
{
tmpboolean = true;
}
if (currentframe - ships[i].splitframe < 50 && currentframe - ships[i].splitframe > -25 && currentframe % 10 == 0 && ships[i].splitframe > 0)
{
tmpboolean = true;
}
// added
if (keyframe[currentframe + 10].shipdata[i].hp <= 0 && keyframe[currentframe + 9].shipdata[i].hp > 0)
{
massiveexplosion = true;
}
}
}
if (currentframe + 200 < maxframes && ships[i].shiptype > 2 && keyframe[currentframe].shipdata[i].hp > 0 && keyframe[currentframe].shipdata[i].hp < ships[i].fullhp)
{
if (currentframe % 3 == 0 && keyframe[currentframe + 200].shipdata[i].hp <= 0)
{
smoking = true;
tmpboolean = true;
}
}
if (currentframe + 50 < maxframes && ships[i].shiptype > 2)
{
if (keyframe[currentframe + 10].shipdata[i].hp <= 0 && keyframe[currentframe + 9].shipdata[i].hp > 0)
{
massiveexplosion = true;
}
}
angle2 = 1;
if (currentframe + 16 < maxframes)
{
if (keyframe[currentframe + 14].shipdata[i].hp > 0 && keyframe[currentframe + 15].shipdata[i].hp <= 0)
{
tmpboolean = true;
angle2 = 0;
}
}
if (keyframe[currentframe].shipdata[i].hp != keyframe[currentframe - 1].shipdata[i].hp || tmpboolean || massiveexplosion)
{
// put explosion....
// simply update the position of the
// relevant esprite.....find one that has a
// -1 value....
if (esprites != null && ((currentframe % 2 == 0 && ships[i].shiptype > 2) || (angle2 == 0) || (currentframe % 6 == 0 && ships[i].shiptype < 3) || massiveexplosion))
{
for (j = 0; j < MAXESPRITES / LOWSPECDIV; j++)
{
if (espriteframe[j] == -1)
{
espriteframe[j] = 0;
Log.i(TAG, "Explosion created!");
// reposition the esprite.....
// find out where it currently
// is and move it!
// this will place it smack bang
// on the object...not what we
// really want.....
// it is okay for small objects
// like fighters and bombers but
// not big ships.....
if (adjustmatrix == null)
{
adjustmatrix = esprites[j].getWorldTransformation();
}
else
{
adjustmatrix = esprites[j].getWorldTransformation(adjustmatrix);
}
if (oldt == null)
{
oldt = adjustmatrix.getTranslation();
}
else
{
oldt = adjustmatrix.getTranslation(oldt);
}
oldt.scalarMul(-1f);
esprites[j].translate(oldt);
esprites[j].setScale(1.0f);
// scale it up at this point
// based on size type.....
if (smoking) // only small ships smoke
{
esprites[j].setScale(0.1f); // smoke
// trails......really
// small....
}
else
{
if (massiveexplosion)
{
esprites[j].setScale(2.5f + (ships[i].sizetype * 0.2f));
// sound fx
if (pchatter != null && musicflag != false)
{
// maximum is going to be about 4000 for a beam.....
angle1 = 1.0f - (Math.abs(camx - keyframe[currentframe].shipdata[i].x) + Math.abs(camy - keyframe[currentframe].shipdata[i].y) + Math.abs(camz - keyframe[currentframe].shipdata[i].z)) / 2000f;
if (angle1 < 0.01f)
{
angle1 = 0.01f;
}
if (angle1 > 1.0f)
{
angle1 = 1.0f;
}
pchatter.playfx(PilotChatter.fxtype_explosion, angle1, angle1);
}
}
else
{
if (currentframe + 30 < maxframes)
{
if (keyframe[currentframe + 30].shipdata[i].hp <= 0 && keyframe[currentframe + 30].shipdata[i].hp > -10000)
{
esprites[j].setScale(1.0f + (ships[i].sizetype * 0.05f));
}
else
{
if (keyframe[currentframe + 7].shipdata[i].hp == -10000)
{
esprites[j].setScale(0.5f + (ships[i].sizetype * 0.1f));
}
}
}
}
}
// random value wanted...without
// needing random generator....
irand++;
irand %= MAXRAND / LOWSPECDIV;
if (!massiveexplosion)
{
if (Math.abs(ships[i].splitframe - currentframe) < 150)
{
// set scale to be quite small actually....
// and also set the angle1 to really small too
esprites[j].setScale(0.6f);
angle1 = 0.1f;
}
else
{
angle1 = 1.0f;
}
esprites[j].translate(keyframe[currentframe].shipdata[i].x, keyframe[currentframe].shipdata[i].y, keyframe[currentframe].shipdata[i].z);
esprites[j].translate(angle1 * 5.5f * (ships[i].sizetype + 1) * erand[irand], 0, 0);
irand++;
irand %= MAXRAND / LOWSPECDIV;
esprites[j].translate(0, angle1 * 5.5f * (1 + ships[i].sizetype) * erand[irand], 0);
irand++;
irand %= MAXRAND / LOWSPECDIV;
esprites[j].translate(0, 0, angle1 * 5.5f * (ships[i].sizetype + 1) * erand[irand]);
}
else
{
esprites[j].translate(keyframe[currentframe].shipdata[i].x, keyframe[currentframe].shipdata[i].y, keyframe[currentframe].shipdata[i].z);
}
break;
}
}
}
}
}
tmpboolean = false;
size = keyframe[currentframe].shipdata[i].firingframe.length;
for (k = 0; k < size; k++)
{
if (keyframe[currentframe].shipdata[i].firingframe[k] > 0)
{
if ((currentframe % 10) == 0 && tmpboolean == false)
{
if (ships[i].hardpoints[k].weapon.isbeam)
{
// play the beam sound...
if (pchatter != null && (currentframe % 40) == 0 && musicflag != false)
{
// maximum is going to be about 4000 for a beam.....
angle1 = 1.0f - (Math.abs(camx - keyframe[currentframe].shipdata[i].x) + Math.abs(camy - keyframe[currentframe].shipdata[i].y) + Math.abs(camz - keyframe[currentframe].shipdata[i].z)) / 4000f;
if (angle1 < 0.01f)
{
angle1 = 0.01f;
}
if (angle1 > 1.0f)
{
angle1 = 1.0f;
}
pchatter.playfx(PilotChatter.fxtype_beam, angle1 * 0.01f, angle1 * 0.01f);
}
}
else
{
if (pchatter != null && musicflag != false)
{
angle1 = 1.0f - (Math.abs(camx - keyframe[currentframe].shipdata[i].x) + Math.abs(camy - keyframe[currentframe].shipdata[i].y) + Math.abs(camz - keyframe[currentframe].shipdata[i].z)) / 800f;
if (angle1 < 0.01f)
{
angle1 = 0.01f;
}
if (angle1 > 1.0f)
{
angle1 = 1.0f;
}
pchatter.playfx(PilotChatter.fxtype_laser, angle1 * 0.2f, angle1 * 0.2f);
}
}
tmpboolean = true;
}
for (j = 0; j < 1000; j++)
{
if (laserbeams[j] == null)
{
if (pos == null)
{
pos = new SimpleVector(0, 0, 0);
}
if (adjust == null)
{
adjust = new SimpleVector(0, 0, 1);
}
if (adjustmatrix == null)
{
adjustmatrix = adjust.getRotationMatrix();
}
if (target == null)
{
target = new SimpleVector(0, 0, 1);
}
laserbeams[j] = new LaserBeam();
laserbeams[j].mesh = new Object3D(2);
// create mesh....
laserbeams[j].mesh.setCulling(false);
laserbeams[j].mesh.addTriangle(laservert1, 0f, 0f, laservert2, 1f, 0f, laservert3, 1f, 1f);
laserbeams[j].mesh.addTriangle(laservert3, 1f, 1f, laservert4, 0f, 1f, laservert1, 0f, 0f);
laserbeams[j].beammesh = new Object3D(4);
laserbeams[j].beammesh.setCulling(false);
laserbeams[j].beammesh.addTriangle(beamvert1, 0f, 0f, beamvert2, 1f, 0f, beamvert3, 1f, 1f);
laserbeams[j].beammesh.addTriangle(beamvert3, 1f, 1f, beamvert4, 0f, 1f, beamvert1, 0f, 0f);
laserbeams[j].beammesh.addTriangle(beamvert5, 0f, 0f, beamvert6, 1f, 0f, beamvert7, 1f, 1f);
laserbeams[j].beammesh.addTriangle(beamvert7, 1f, 1f, beamvert8, 0f, 1f, beamvert5, 0f, 0f);
// laserbeams[j].beammesh.setTexture("purplebeam");
laserbeams[j].owninghardpointid = k;
// if(ships[i].hardpoints[k].weapon.ismissile)
// {
// laserbeams[j].mesh.setTexture("redbeam");
// }
// if(ships[i].hardpoints[k].weapon.ismissile==false
// &&
// ships[i].hardpoints[k].weapon.isbeam==false)
// {
// laserbeams[j].mesh.setTexture("greenbeam");
// }
laserbeams[j].scale = 1.0f;
if (ships[i].hardpoints[k].weapon.weapontype == 4) // plasma
{
// laserbeams[j].beammesh.setTexture("plasma");
// laserbeams[j].mesh.setTexture("plasma");
laserbeams[j].scale = 4.0f;
if (ships[i].shiptype < 3)
{
laserbeams[j].scale = 8.0f;
}
}
if (ships[i].hardpoints[k].weapon.weapontype == 5) // tractor
{
// laserbeams[j].beammesh.setTexture("bluebeam");
// laserbeams[j].mesh.setTexture("bluebeam");
}
if (ships[i].hardpoints[k].weapon.weapontype == 6) // disruptor
{
// laserbeams[j].beammesh.setTexture("lgbeam"); // need
// to
// add
// laserbeams[j].mesh.setTexture("lgbeam");
if (ships[i].shiptype < 3 && ships[i].hardpoints[k].weapon.isbeam == false)
{
laserbeams[j].scale = 6.0f;
}
}
if (ships[i].hardpoints[k].weapon.weapontype == 7 || ships[i].hardpoints[k].weapon.weapontype == 3) // swarmer
{
// laserbeams[j].beammesh.setTexture("yellowbeam"); // need
// to
// add
// laserbeams[j].mesh.setTexture("yellowbeam"); // need
// to
// add
if (ships[i].shiptype < 3)
{
laserbeams[j].scale = 6.0f;
}
}
if (ships[i].hardpoints[k].weapon.weapontype == 1) // standard
// laser
{
if (ships[i].shiptype < 3)
{
// laserbeams[j].mesh.setTexture("bluebeam");
laserbeams[j].scale = 4.0f;
}
else
{
// laserbeams[j].mesh.setTexture("greenbeam");
}
}
if (ships[i].hardpoints[k].weapon.weapontype == 2) // standard
// beam
{
// laserbeams[j].beammesh.setTexture("purplebeam");
}
if (ships[i].team == 1)
{
laserbeams[j].mesh.setTexture("redbeam");
laserbeams[j].beammesh.setTexture("redbeam");
}
if (ships[i].team == 2)
{
laserbeams[j].mesh.setTexture("bluebeam");
laserbeams[j].beammesh.setTexture("bluebeam");
}
if (ships[i].team == 3)
{
laserbeams[j].mesh.setTexture("yellowbeam");
laserbeams[j].beammesh.setTexture("yellowbeam");
}
if (ships[i].team == 4)
{
laserbeams[j].mesh.setTexture("greenbeam");
laserbeams[j].beammesh.setTexture("greenbeam");
}
if (ships[i].team == 5)
{
laserbeams[j].mesh.setTexture("purplebeam");
laserbeams[j].beammesh.setTexture("purplebeam");
}
laserbeams[j].mesh.setTransparency(255);
laserbeams[j].mesh.setTransparencyMode(Object3D.TRANSPARENCY_MODE_ADD);
laserbeams[j].beammesh.setTransparency(255);
laserbeams[j].beammesh.setTransparencyMode(Object3D.TRANSPARENCY_MODE_ADD);
// apply the relevant shader......
// in this case the basic shader
// will do.....
Log.d(TAG, "LaserBeam Shader Preparing");
laserbeams[j].mesh.setShader(this.shaders[1]);
laserbeams[j].beammesh.setShader(this.shaders[1]);
Log.d(TAG, "LaserBeam Shader Set");
laserbeams[j].mesh.build();
laserbeams[j].mesh.strip();
laserbeams[j].beammesh.build();
laserbeams[j].beammesh.strip();
// for beams we need to modfiy the
// mesh so need a
// vertexcontroller....
// also need to be able to put the
// mesh back as it was.....
// laserbeams[j].lmesh =
// laserbeams[j].mesh.getMesh();
// laserbeams[j].vctrl = new
// MyVertexController();
// laserbeams[j].lmesh.setVertexController(laserbeams[j].vctrl,
// false);
world.addObject(laserbeams[j].mesh);
world.addObject(laserbeams[j].beammesh);
laserbeams[j].mesh.setOrigin(SimpleVector.ORIGIN);
laserbeams[j].beammesh.setOrigin(SimpleVector.ORIGIN);
laserbeams[j].movement = new SimpleVector(0, 0, 1);
pos.x = keyframe[currentframe].shipdata[i].fx[k];// x
// +
// pos.x;
pos.y = keyframe[currentframe].shipdata[i].fy[k];// y
// +
// pos.y;
pos.z = keyframe[currentframe].shipdata[i].fz[k];// z
// +
// pos.z;
laserbeams[j].mesh.translate(pos);
laserbeams[j].beammesh.translate(pos);
if (laserbeams[j].wmatrix == null)
{
laserbeams[j].wmatrix = laserbeams[j].mesh.getWorldTransformation();
}
else
{
laserbeams[j].wmatrix = laserbeams[j].mesh.getWorldTransformation(laserbeams[j].wmatrix);
}
if (laserbeams[j].wmatrixB == null)
{
laserbeams[j].wmatrixB = laserbeams[j].beammesh.getWorldTransformation();
}
else
{
laserbeams[j].wmatrixB = laserbeams[j].beammesh.getWorldTransformation(laserbeams[j].wmatrixB);
}
laserbeams[j].targetshipid = keyframe[currentframe].shipdata[i].firingframe[k] - 1;// -1;
// //for
// now...
if (laserbeams[j].isbeam && laserbeams[j].targetshipid >= 0 && laserbeams[j].targetshipid < 32)
{
laserbeams[j].movement.x = keyframe[currentframe].shipdata[laserbeams[j].targetshipid].x - keyframe[currentframe].shipdata[i].fx[k];
laserbeams[j].movement.y = keyframe[currentframe].shipdata[laserbeams[j].targetshipid].y - keyframe[currentframe].shipdata[i].fy[k];
laserbeams[j].movement.z = keyframe[currentframe].shipdata[laserbeams[j].targetshipid].z - keyframe[currentframe].shipdata[i].fz[k];
// what we actually want to do.....is shift the beam from bottom to top through the enemy ship....
// which will help the laser cutting when we split the mesh.....
// perpendicular vector to laserbeam movement......
// find a vector such that the dot product is 0....
angle1 = 0f;
if (ships[laserbeams[j].targetshipid].splitframe > 0)
{
if (Math.abs(currentframe - ships[laserbeams[j].targetshipid].splitframe) < 25)
{
angle1 = 6f * (float) (currentframe - ships[laserbeams[j].targetshipid].splitframe);
}
if (Math.abs(laserbeams[j].movement.x) > Math.abs(laserbeams[j].movement.y))
{
// x is biggest so far
if (Math.abs(laserbeams[j].movement.x) > Math.abs(laserbeams[j].movement.z))
{
// x is definitely the biggest
if (Math.abs(laserbeams[j].movement.z) < 0.01f && Math.abs(laserbeams[j].movement.y) < 0.01f)
{
// we are moving along x axis
// shift movement y up/down by appropriate amount....
laserbeams[j].movement.y += angle1;
}
else
{
// find perpendicular....
// dot = ix * jx + iy * jy + iz * jz = 0
// set jx = 0 so...
// iy*jy = - iz*jz
//
if (Math.abs(laserbeams[j].movement.z) < 0.01f)
{
// perpendicular is going to be in the z direction....
laserbeams[j].movement.z += angle1;
}
else
{
angle2 = (float) Math.sqrt(laserbeams[j].movement.x * laserbeams[j].movement.x + laserbeams[j].movement.y * laserbeams[j].movement.y + laserbeams[j].movement.z * laserbeams[j].movement.z);
if (angle2 > 0)
{
laserbeams[j].movement.z += angle1 * (laserbeams[j].movement.y / angle2);
laserbeams[j].movement.y += angle1 * (laserbeams[j].movement.z / angle2);
}
}
}
}
else
{
// z is the biggest
if (Math.abs(laserbeams[j].movement.x) < 0.01f && Math.abs(laserbeams[j].movement.y) < 0.01f)
{
// we are moving along z axis
laserbeams[j].movement.y += angle1;
}
else
{
if (Math.abs(laserbeams[j].movement.y) < 0.01f)
{
// perpendicular is going to be in the x direction....
laserbeams[j].movement.x += angle1;
}
else
{
angle2 = (float) Math.sqrt(laserbeams[j].movement.x * laserbeams[j].movement.x + laserbeams[j].movement.y * laserbeams[j].movement.y + laserbeams[j].movement.z * laserbeams[j].movement.z);
if (angle2 > 0)
{
laserbeams[j].movement.x += angle1 * (laserbeams[j].movement.y / angle2);
laserbeams[j].movement.y += angle1 * (laserbeams[j].movement.z / angle2);
}
}
}
}
}
else
{
// y is biggest so far
if (Math.abs(laserbeams[j].movement.y) > Math.abs(laserbeams[j].movement.z))
{
// y is definitely the biggest
if (Math.abs(laserbeams[j].movement.z) < 0.01f && Math.abs(laserbeams[j].movement.x) < 0.01f)
{
// we are moving along y axis
laserbeams[j].movement.x += angle1;
}
else
{
if (Math.abs(laserbeams[j].movement.y) < 0.01f)
{
// perpendicular is going to be in the y direction....
laserbeams[j].movement.y += angle1;
}
else
{
angle2 = (float) Math.sqrt(laserbeams[j].movement.x * laserbeams[j].movement.x + laserbeams[j].movement.y * laserbeams[j].movement.y + laserbeams[j].movement.z * laserbeams[j].movement.z);
if (angle2 > 0)
{
laserbeams[j].movement.x += angle1 * (laserbeams[j].movement.y / angle2);
laserbeams[j].movement.y += angle1 * (laserbeams[j].movement.z / angle2);
}
}
}
}
else
{
// z is the biggest
if (Math.abs(laserbeams[j].movement.z) < 0.01f && Math.abs(laserbeams[j].movement.x) < 0.01f)
{
// we are moving along z axis
laserbeams[j].movement.x += angle1;
}
else
{
if (Math.abs(laserbeams[j].movement.z) < 0.01f)
{
// perpendicular is going to be in the z direction....
laserbeams[j].movement.z += angle1;
}
else
{
angle2 = (float) Math.sqrt(laserbeams[j].movement.x * laserbeams[j].movement.x + laserbeams[j].movement.y * laserbeams[j].movement.y + laserbeams[j].movement.z * laserbeams[j].movement.z);
if (angle2 > 0)
{
laserbeams[j].movement.x += angle1 * (laserbeams[j].movement.y / angle2);
laserbeams[j].movement.z += angle1 * (laserbeams[j].movement.z / angle2);
}
}
}
}
}
}
}
else
{
laserbeams[j].movement.x = keyframe[currentframe].shipdata[i].fux[k] * laserbeams[j].scale;
laserbeams[j].movement.y = keyframe[currentframe].shipdata[i].fuy[k] * laserbeams[j].scale;
laserbeams[j].movement.z = keyframe[currentframe].shipdata[i].fuz[k] * laserbeams[j].scale;
}
if (laserbeams[j].rmatrix == null)
{
laserbeams[j].rmatrix = laserbeams[j].mesh.getRotationMatrix();
laserbeams[j].rmatrix = laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrix);
}
else
{
laserbeams[j].rmatrix = laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrix);
}
if (laserbeams[j].rmatrixB == null)
{
laserbeams[j].rmatrixB = laserbeams[j].beammesh.getRotationMatrix();
laserbeams[j].rmatrixB = laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrixB);
}
else
{
laserbeams[j].rmatrixB = laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrixB);
}
laserbeams[j].mesh.setRotationMatrix(laserbeams[j].rmatrix);
laserbeams[j].beammesh.setRotationMatrix(laserbeams[j].rmatrixB);
laserbeams[j].team = keyframe[currentframe].shipteam[i];
laserbeams[j].lifetime = ships[i].hardpoints[k].weapon.baselifetime;
laserbeams[j].guidedturnrate = ships[i].hardpoints[k].weapon.guidedturnrate;
laserbeams[j].isguided = ships[i].hardpoints[k].weapon.isguided;
laserbeams[j].isbeam = ships[i].hardpoints[k].weapon.isbeam;
if (laserbeams[j].isbeam)
{
laserbeams[j].lifetime = 4;
if (laserbeams[j].targetshipid >= 0 && laserbeams[j].targetshipid < 32)
{
laserbeams[j].beammesh.setVisibility(true);
}
laserbeams[j].mesh.setVisibility(false);
// scale the beam.....not yet
// though......
}
else
{
laserbeams[j].beammesh.setVisibility(false);
laserbeams[j].mesh.setVisibility(true);
}
laserbeams[j].ismissile = ships[i].hardpoints[k].weapon.ismissile;
laserbeams[j].maxvel = ships[i].hardpoints[k].weapon.muzzlevel;
laserbeams[j].owningshipid = i;
laserbeams[j].owningshipteam = ships[i].team;
break;
}
if (laserbeams[j].lifetime <= 0)
{
// i would imagine you can change
// the texture on the fly no
// problem.....
// pretty dodgy if you can't.
/*
* if(ships[i].hardpoints[k].weapon. ismissile) { laserbeams[j].mesh.setTexture ("redbeam"); } if(ships[i].hardpoints [k].weapon.ismissile==false && ships
* [i].hardpoints[k].weapon.isbeam ==false) { laserbeams[j].mesh.setTexture ("greenbeam"); }
*/
laserbeams[j].scale = 1.0f;
if (ships[i].hardpoints[k].weapon.weapontype == 4) // plasma
{
// laserbeams[j].beammesh.setTexture("plasma");
// laserbeams[j].mesh.setTexture("plasma");
laserbeams[j].scale = 4.0f;
if (ships[i].shiptype < 3)
{
laserbeams[j].scale = 8.0f;
}
}
if (ships[i].hardpoints[k].weapon.weapontype == 5) // tractor
{
// laserbeams[j].beammesh.setTexture("bluebeam");
// laserbeams[j].mesh.setTexture("bluebeam");
}
if (ships[i].hardpoints[k].weapon.weapontype == 6) // disruptor
{
// laserbeams[j].beammesh.setTexture("lgbeam"); // need
// to
// add
// laserbeams[j].mesh.setTexture("lgbeam");
if (ships[i].shiptype < 3 && ships[i].hardpoints[k].weapon.isbeam == false)
{
laserbeams[j].scale = 6.0f;
}
}
if (ships[i].hardpoints[k].weapon.weapontype == 7 || ships[i].hardpoints[k].weapon.weapontype == 3) // swarmer
{
// laserbeams[j].beammesh.setTexture("yellowbeam"); // need
// to
// add
// laserbeams[j].mesh.setTexture("yellowbeam"); // need
// to
// add
if (ships[i].shiptype < 3)
{
laserbeams[j].scale = 6.0f;
}
}
if (ships[i].hardpoints[k].weapon.weapontype == 1) // standard
// laser
{
if (ships[i].shiptype < 3)
{
// laserbeams[j].mesh.setTexture("bluebeam");
laserbeams[j].scale = 4.0f;
}
else
{
// laserbeams[j].mesh.setTexture("greenbeam");
}
}
if (ships[i].hardpoints[k].weapon.weapontype == 2) // standard
// beam
{
// laserbeams[j].beammesh.setTexture("purplebeam");
}
if (ships[i].team == 1)
{
laserbeams[j].mesh.setTexture("redbeam");
laserbeams[j].beammesh.setTexture("redbeam");
}
if (ships[i].team == 2)
{
laserbeams[j].mesh.setTexture("bluebeam");
laserbeams[j].beammesh.setTexture("bluebeam");
}
if (ships[i].team == 3)
{
laserbeams[j].mesh.setTexture("yellowbeam");
laserbeams[j].beammesh.setTexture("yellowbeam");
}
if (ships[i].team == 4)
{
laserbeams[j].mesh.setTexture("greenbeam");
laserbeams[j].beammesh.setTexture("greenbeam");
}
if (ships[i].team == 5)
{
laserbeams[j].mesh.setTexture("purplebeam");
laserbeams[j].beammesh.setTexture("purplebeam");
}
laserbeams[j].team = keyframe[currentframe].shipteam[i];
laserbeams[j].owninghardpointid = k;
if (ships[i].hardpoints[k].weapon.isbeam)
{
laserbeams[j].isbeam = true;
if (laserbeams[j].wmatrixB == null)
{
laserbeams[j].wmatrixB = laserbeams[j].beammesh.getWorldTransformation();
}
else
{
laserbeams[j].wmatrixB = laserbeams[j].beammesh.getWorldTransformation(laserbeams[j].wmatrixB);
}
if (oldt == null)
{
oldt = laserbeams[j].wmatrixB.getTranslation();
}
else
{
oldt = laserbeams[j].wmatrixB.getTranslation(oldt);
}
oldt.scalarMul(-1f);
laserbeams[j].beammesh.translate(oldt);
}
else
{
laserbeams[j].isbeam = false;
if (laserbeams[j].wmatrix == null)
{
laserbeams[j].wmatrix = laserbeams[j].mesh.getWorldTransformation();
}
else
{
laserbeams[j].wmatrix = laserbeams[j].mesh.getWorldTransformation(laserbeams[j].wmatrix);
}
if (oldt == null)
{
oldt = laserbeams[j].wmatrix.getTranslation();
}
else
{
oldt = laserbeams[j].wmatrix.getTranslation(oldt);
}
oldt.scalarMul(-1f);
laserbeams[j].mesh.translate(oldt);
}
pos.x = keyframe[currentframe].shipdata[i].fx[k];// x
// +
// pos.x;
pos.y = keyframe[currentframe].shipdata[i].fy[k];// y
// +
// pos.y;
pos.z = keyframe[currentframe].shipdata[i].fz[k];// z
// +
// pos.z;
if (laserbeams[j].isbeam)
{
laserbeams[j].beammesh.translate(pos);
}
else
{
laserbeams[j].mesh.translate(pos);
}
laserbeams[j].targetshipid = keyframe[currentframe].shipdata[i].firingframe[k] - 1;// -1;
// //for
// now...
if (laserbeams[j].isbeam && laserbeams[j].targetshipid >= 0 && laserbeams[j].targetshipid < 32)
{
laserbeams[j].movement.x = keyframe[currentframe].shipdata[laserbeams[j].targetshipid].x - keyframe[currentframe].shipdata[i].fx[k];
laserbeams[j].movement.y = keyframe[currentframe].shipdata[laserbeams[j].targetshipid].y - keyframe[currentframe].shipdata[i].fy[k];
laserbeams[j].movement.z = keyframe[currentframe].shipdata[laserbeams[j].targetshipid].z - keyframe[currentframe].shipdata[i].fz[k];
// what we actually want to do.....is shift the beam from bottom to top through the enemy ship....
// which will help the laser cutting when we split the mesh.....
// perpendicular vector to laserbeam movement......
// find a vector such that the dot product is 0....
angle1 = 0f;
if (ships[laserbeams[j].targetshipid].splitframe > 0)
{
if (Math.abs(currentframe - ships[laserbeams[j].targetshipid].splitframe) < 25)
{
angle1 = 6f * (float) (currentframe - ships[laserbeams[j].targetshipid].splitframe);
}
if (Math.abs(laserbeams[j].movement.x) > Math.abs(laserbeams[j].movement.y))
{
// x is biggest so far
if (Math.abs(laserbeams[j].movement.x) > Math.abs(laserbeams[j].movement.z))
{
// x is definitely the biggest
if (Math.abs(laserbeams[j].movement.z) < 0.01f && Math.abs(laserbeams[j].movement.y) < 0.01f)
{
// we are moving along x axis
// shift movement y up/down by appropriate amount....
laserbeams[j].movement.y += angle1;
}
else
{
// find perpendicular....
// dot = ix * jx + iy * jy + iz * jz = 0
// set jx = 0 so...
// iy*jy = - iz*jz
//
if (Math.abs(laserbeams[j].movement.z) < 0.01f)
{
// perpendicular is going to be in the z direction....
laserbeams[j].movement.z += angle1;
}
else
{
angle2 = (float) Math.sqrt(laserbeams[j].movement.x * laserbeams[j].movement.x + laserbeams[j].movement.y * laserbeams[j].movement.y + laserbeams[j].movement.z * laserbeams[j].movement.z);
if (angle2 > 0)
{
laserbeams[j].movement.z += angle1 * (laserbeams[j].movement.y / angle2);
laserbeams[j].movement.y += angle1 * (laserbeams[j].movement.z / angle2);
}
}
}
}
else
{
// z is the biggest
if (Math.abs(laserbeams[j].movement.x) < 0.01f && Math.abs(laserbeams[j].movement.y) < 0.01f)
{
// we are moving along z axis
laserbeams[j].movement.y += angle1;
}
else
{
if (Math.abs(laserbeams[j].movement.y) < 0.01f)
{
// perpendicular is going to be in the x direction....
laserbeams[j].movement.x += angle1;
}
else
{
angle2 = (float) Math.sqrt(laserbeams[j].movement.x * laserbeams[j].movement.x + laserbeams[j].movement.y * laserbeams[j].movement.y + laserbeams[j].movement.z * laserbeams[j].movement.z);
if (angle2 > 0)
{
laserbeams[j].movement.x += angle1 * (laserbeams[j].movement.y / angle2);
laserbeams[j].movement.y += angle1 * (laserbeams[j].movement.z / angle2);
}
}
}
}
}
else
{
// y is biggest so far
if (Math.abs(laserbeams[j].movement.y) > Math.abs(laserbeams[j].movement.z))
{
// y is definitely the biggest
if (Math.abs(laserbeams[j].movement.z) < 0.01f && Math.abs(laserbeams[j].movement.x) < 0.01f)
{
// we are moving along y axis
laserbeams[j].movement.x += angle1;
}
else
{
if (Math.abs(laserbeams[j].movement.y) < 0.01f)
{
// perpendicular is going to be in the y direction....
laserbeams[j].movement.y += angle1;
}
else
{
angle2 = (float) Math.sqrt(laserbeams[j].movement.x * laserbeams[j].movement.x + laserbeams[j].movement.y * laserbeams[j].movement.y + laserbeams[j].movement.z * laserbeams[j].movement.z);
if (angle2 > 0)
{
laserbeams[j].movement.x += angle1 * (laserbeams[j].movement.y / angle2);
laserbeams[j].movement.y += angle1 * (laserbeams[j].movement.z / angle2);
}
}
}
}
else
{
// z is the biggest
if (Math.abs(laserbeams[j].movement.z) < 0.01f && Math.abs(laserbeams[j].movement.x) < 0.01f)
{
// we are moving along z axis
laserbeams[j].movement.x += angle1;
}
else
{
if (Math.abs(laserbeams[j].movement.z) < 0.01f)
{
// perpendicular is going to be in the z direction....
laserbeams[j].movement.z += angle1;
}
else
{
angle2 = (float) Math.sqrt(laserbeams[j].movement.x * laserbeams[j].movement.x + laserbeams[j].movement.y * laserbeams[j].movement.y + laserbeams[j].movement.z * laserbeams[j].movement.z);
if (angle2 > 0)
{
laserbeams[j].movement.x += angle1 * (laserbeams[j].movement.y / angle2);
laserbeams[j].movement.z += angle1 * (laserbeams[j].movement.z / angle2);
}
}
}
}
}
}
}
else
{
laserbeams[j].movement.x = keyframe[currentframe].shipdata[i].fux[k] * laserbeams[j].scale;
laserbeams[j].movement.y = keyframe[currentframe].shipdata[i].fuy[k] * laserbeams[j].scale;
laserbeams[j].movement.z = keyframe[currentframe].shipdata[i].fuz[k] * laserbeams[j].scale;
}
if (laserbeams[j].rmatrix == null)
{
laserbeams[j].rmatrix = laserbeams[j].mesh.getRotationMatrix();
laserbeams[j].rmatrix = laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrix);
}
else
{
laserbeams[j].rmatrix = laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrix);
}
if (laserbeams[j].rmatrixB == null)
{
laserbeams[j].rmatrixB = laserbeams[j].beammesh.getRotationMatrix();
laserbeams[j].rmatrixB = laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrixB);
}
else
{
laserbeams[j].rmatrixB = laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrixB);
}
laserbeams[j].mesh.setRotationMatrix(laserbeams[j].rmatrix);
laserbeams[j].beammesh.setRotationMatrix(laserbeams[j].rmatrixB);
if (laserbeams[j].isbeam)
{
if (laserbeams[j].targetshipid >= 0 && laserbeams[j].targetshipid < 32)
{
laserbeams[j].beammesh.setVisibility(true);
}
laserbeams[j].mesh.setVisibility(false);
laserbeams[j].lifetime = 4;
}
else
{
laserbeams[j].beammesh.setVisibility(false);
laserbeams[j].mesh.setVisibility(true);
laserbeams[j].lifetime = ships[i].hardpoints[k].weapon.baselifetime;
}
laserbeams[j].guidedturnrate = ships[i].hardpoints[k].weapon.guidedturnrate;
laserbeams[j].isguided = ships[i].hardpoints[k].weapon.isguided;
laserbeams[j].ismissile = ships[i].hardpoints[k].weapon.ismissile;
laserbeams[j].maxvel = ships[i].hardpoints[k].weapon.muzzlevel;
laserbeams[j].owningshipid = i;
// laserbeams[j].targetshipid =
// keyframe[currentframe].shipdata[i].firingframe[k]-1;
laserbeams[j].owningshipteam = ships[i].team;
break;
}
}
}
}
}
}
}
}
}
// position the camera.....
if (currentframe < maxframes)
{
if (pos == null)
{
pos = new SimpleVector(0, 0, 1);
}
if (spawnpos == null)
{
spawnpos = new SimpleVector(0, 0, 1);
}
if (currentframe >= 12)
{
if (currentframe <= maxframes - 12)
{
pos.x = cameraframe[currentframe].x;
pos.y = cameraframe[currentframe].y;
pos.z = cameraframe[currentframe].z;
spawnpos.x = cameraframe[currentframe].lookx;
spawnpos.y = cameraframe[currentframe].looky;
spawnpos.z = cameraframe[currentframe].lookz;
}
else
{
pos.x = cameraframe[maxframes - 12].x;
pos.y = cameraframe[maxframes - 12].y;
pos.z = cameraframe[maxframes - 12].z;
spawnpos.x = cameraframe[maxframes - 12].lookx;
spawnpos.y = cameraframe[maxframes - 12].looky;
spawnpos.z = cameraframe[maxframes - 12].lookz;
}
}
else
{
// because first frame is wrong!
if (maxframes > 12)
{
pos.x = cameraframe[12].x;
pos.y = cameraframe[12].y;
pos.z = cameraframe[12].z;
spawnpos.x = cameraframe[12].lookx;
spawnpos.y = cameraframe[12].looky;
spawnpos.z = cameraframe[12].lookz;
}
else
{
pos.x = cameraframe[0].x;
pos.y = cameraframe[0].y;
pos.z = cameraframe[0].z;
spawnpos.x = cameraframe[0].lookx;
spawnpos.y = cameraframe[0].looky;
spawnpos.z = cameraframe[0].lookz;
}
}
/*
* if(splitindex!=-1) { spawnpos.x = keyframe[currentframe].shipdata[splitindex].x; spawnpos.y = keyframe[currentframe].shipdata[splitindex].y; spawnpos.z =
* keyframe[currentframe].shipdata[splitindex].z;
*
* if(ships[splitindex].meshhalfA!=null) { spawnpos = ships[splitindex].meshhalfA.getWorldTransformation().getTranslation(); } if(ships[splitindex].meshhalfB!=null) { spawnpos =
* spawnpos.calcAdd(ships[splitindex].meshhalfB.getWorldTransformation().getTranslation()); spawnpos.scalarMul(0.5f); }
*
*
* pos.x = spawnpos.x - 70f; pos.y = spawnpos.y - 250f; pos.z = spawnpos.z - 50f;
*
*
* }
*/
camera.setPosition(pos);
camera.lookAt(spawnpos);
camx = pos.x;
camy = pos.y;
camz = pos.z;
spawnpos = spawnpos.normalize(spawnpos);
camdx = spawnpos.x;
camdy = spawnpos.y;
camdz = spawnpos.z;
}
for (j = 0; j < 1000; j++)
{
if (laserbeams[j] != null)
{
if (laserbeams[j].lifetime > 0)
{
laserbeams[j].lifetime--;
if (laserbeams[j].isguided == true && laserbeams[j].isbeam == false)
{
if (laserbeams[j].targetshipid >= 0 && laserbeams[j].targetshipid < 32)
{
// adjust vx,vy,vz accordingly.....
i = laserbeams[j].targetshipid;
if (ships[i] != null)
{
if (ships[i].hp > 0)
{
// okay so adjust ever so slightly.....
if (pos == null)
{
pos = new SimpleVector(0, 0, 1);
}
if (adjustmatrix == null)
{
adjustmatrix = laserbeams[j].mesh.getWorldTransformation();
}
else
{
adjustmatrix = laserbeams[j].mesh.getWorldTransformation(adjustmatrix);
}
pos = adjustmatrix.getTranslation(pos);
mdx = ships[i].x - pos.x;
mdy = ships[i].y - pos.y;
mdz = ships[i].z - pos.z;
mlen = (float) Math.sqrt(mdx * mdx + mdy * mdy + mdz * mdz);
if (mlen > 0)
{
mdx /= mlen;
mdy /= mlen;
mdz /= mlen;
bvx = laserbeams[j].movement.x;
bvy = laserbeams[j].movement.y;
bvz = laserbeams[j].movement.z;
blen = (float) Math.sqrt(bvx * bvx + bvy * bvy + bvz * bvz);
if (blen > 0)
{
bvx /= blen;
bvy /= blen;
bvz /= blen;
}
bvx += (mdx) * laserbeams[j].guidedturnrate;
bvy += (mdy) * laserbeams[j].guidedturnrate;
bvz += (mdz) * laserbeams[j].guidedturnrate;
blen = (float) Math.sqrt(bvx * bvx + bvy * bvy + bvz * bvz);
if (blen > 0)
{
bvx /= blen;
bvy /= blen;
bvz /= blen;
}
laserbeams[j].movement.x = bvx * laserbeams[j].maxvel * laserbeams[j].scale;
laserbeams[j].movement.y = bvy * laserbeams[j].maxvel * laserbeams[j].scale;
laserbeams[j].movement.z = bvz * laserbeams[j].maxvel * laserbeams[j].scale;
// need to rotate as well.....
if (laserbeams[j].rmatrix == null)
{
laserbeams[j].rmatrix = laserbeams[j].mesh.getRotationMatrix();
laserbeams[j].rmatrix = laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrix);
}
else
{
laserbeams[j].rmatrix = laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrix);
}
laserbeams[j].mesh.setRotationMatrix(laserbeams[j].rmatrix);
}
}
}
}
}
if (!laserbeams[j].isbeam)
{
laserbeams[j].mesh.translate(laserbeams[j].movement);
/*
* if (laserbeams[j].rmatrix == null) { laserbeams[j].rmatrix = laserbeams[j].mesh.getRotationMatrix(); } else { laserbeams[j].rmatrix =
* laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrix); } laserbeams[j].mesh.setRotationMatrix(laserbeams[j].rmatrix);
*/
}
else
{
/*
* if (laserbeams[j].rmatrixB == null) { laserbeams[j].rmatrixB = laserbeams[j].beammesh.getRotationMatrix(); } else { laserbeams[j].rmatrixB =
* laserbeams[j].movement.getRotationMatrix(laserbeams[j].rmatrixB); } laserbeams[j].beammesh.setRotationMatrix(laserbeams[j].rmatrixB);
*/
}
if (laserbeams[j].lifetime <= 0)
{
// if (laserbeams[j].isbeam)
// {
laserbeams[j].beammesh.setVisibility(false);
// }
// else
// {
laserbeams[j].mesh.setVisibility(false);
// }
}
else
{
if (laserbeams[j].scale < 1.0f)
{
laserbeams[j].scale = 1.0f;
}
laserbeams[j].mesh.setScale(laserbeams[j].scale);
}
}
else
{
laserbeams[j].beammesh.setVisibility(false);
laserbeams[j].mesh.setVisibility(false);
}
}
else
{
break;
}
}
if (spacedebris != null && world != null && fbuffer != null && camera != null)
{
size = spacedebris.length;
for (i = 0; i < size; i++)
{
if (spacedebris[i] != null)
{
if (currentframe == 0)
{
spacedebris[i].mesh[0].setShader(shaders[0]);
}
spacedebris[i].update(camera, fbuffer, camx, camy, camz, 100f * camdx, 100f * camdy, 100f * camdz);
}
}
}
if (esprites != null)
{
for (i = 0; i < MAXESPRITES / LOWSPECDIV; i++)
{
if (esprites[i] != null)
{
if (espriteframe[i] == -1)
{
continue;
}
if (espriteframe[i] == 0)
{
esprites[i].setVisibility(true);
// Log.i(TAG,"esprite should be visible now");
}
// have a slight pause between frames...probably too fast at
// the moment....
if (currentframe % 3 != 0)
{
continue;
}
// change texture coords of the sprite.....
if (espriteframe[i] >= 64)
{
esprites[i].setVisibility(false);
espriteframe[i] = -1;
espritetexmatrix[i].translate(-0.875f, -0.875f, 0f);
esprites[i].setTextureMatrix(espritetexmatrix[i]);
esprites[i].touch();
// if(i==0)
// {
// Log.d(TAG,"Translated esprite matrix..u:"+espritetexmatrix[i].getTranslation().x+", v:"+espritetexmatrix[i].getTranslation().y);
// }
// Log.i(TAG,"esprite should be invisible again");
}
else
{
// / 0 = 0.0, 0.0
// 1 = 0.125, 0.0 2 = 0.5, 0.0, 3... 7 = 0.875,0
// / 8 = 0,0.125 9 = 0.5,0.125......
//
// 56 = 0.0,0.875, .... 63 = 0.875, 0.875
// 64 = -0.875, -0.875
if (espriteframe[i] % 8 == 0)
{
if (espriteframe[i] != 0)
{
espritetexmatrix[i].translate(-0.875f, 0.125f, 0f);
esprites[i].setTextureMatrix(espritetexmatrix[i]);
esprites[i].touch();
// if(i==0)
// {
// Log.d(TAG,"Translated esprite matrix..u:"+espritetexmatrix[i].getTranslation().x+", v:"+espritetexmatrix[i].getTranslation().y);
// }
}
}
else
{
espritetexmatrix[i].translate(0.125f, 0f, 0f);
esprites[i].setTextureMatrix(espritetexmatrix[i]);
esprites[i].touch();
// i/f(i==0)
// {
// Log.d(TAG,"Translated esprite matrix..u:"+espritetexmatrix[i].getTranslation().x+", v:"+espritetexmatrix[i].getTranslation().y);
// }
}
espriteframe[i]++;
}
}
}
}
// pilot chatter......
if (pchatter != null && musicflag != false)
{
for (k = 0; k < 16; k++)
{
if (keyframe[currentframe].shipdata[k].hp > 0 && (currentframe % 105) == 0 && currentframe > 120 && currentframe < maxframes - 250)
{
// play the relevant pilot chatter.....
if (currentframe > 600)
{
pchatter.play(ships[k].team, true);
}
else
{
pchatter.play(ships[k].team, false);
}
break;
}
}
for(k=0;k<32;k++)
{
if(keyframe[currentframe].shipdata[k].hp>0 && (currentframe % 150)==0 && currentframe > 120 && currentframe < maxframes - 250)
{
if(ships[k].shiptype>2)
{
//check the distance to the camera....
if(Math.abs(keyframe[currentframe].shipdata[k].x-camx)+Math.abs(keyframe[currentframe].shipdata[k].y-camy)+Math.abs(keyframe[currentframe].shipdata[k].z-camz)<80)
{
pchatter.playfx(PilotChatter.fxtype_wind, 0.8f, 0.8f);
break;
}
}
}
}
}
currentframe += (skipnum + 1);
if (currentframe >= maxframes - 1 && maxframes > 100) // good test to
// see if we can
// position the
// keyframe
// anywhere at
// all...
{
// play the video as a loop for now....
// reset the explosions...
for (k = 0; k < 70; k++)
{
if (esprites != null)
{
for (i = 0; i < MAXESPRITES / LOWSPECDIV; i++)
{
if (esprites[i] != null)
{
if (espriteframe[i] == -1)
{
continue;
}
if (espriteframe[i] == 0)
{
esprites[i].setVisibility(true);
Log.i(TAG, "esprite should be visible now");
}
// change texture coords of the sprite.....
if (espriteframe[i] >= 64)
{
esprites[i].setVisibility(false);
espriteframe[i] = -1;
espritetexmatrix[i].translate(-0.875f, -0.875f, 0f);
esprites[i].setTextureMatrix(espritetexmatrix[i]);
esprites[i].touch();
if (i == 0)
{
// Log.d(TAG,"Translated esprite matrix..u:"+espritetexmatrix[i].getTranslation().x+", v:"+espritetexmatrix[i].getTranslation().y);
}
// Log.i(TAG,"esprite should be invisible again");
}
else
{
// / 0 = 0.0, 0.0
// 1 = 0.125, 0.0 2 = 0.5, 0.0, 3... 7 = 0.875,0
// / 8 = 0,0.125 9 = 0.5,0.125......
//
// 56 = 0.0,0.875, .... 63 = 0.875, 0.875
// 64 = -0.875, -0.875
if (espriteframe[i] % 8 == 0)
{
if (espriteframe[i] != 0)
{
espritetexmatrix[i].translate(-0.875f, 0.125f, 0f);
esprites[i].setTextureMatrix(espritetexmatrix[i]);
esprites[i].touch();
if (i == 0)
{
// Log.d(TAG,"Translated esprite matrix..u:"+espritetexmatrix[i].getTranslation().x+", v:"+espritetexmatrix[i].getTranslation().y);
}
}
}
else
{
espritetexmatrix[i].translate(0.125f, 0f, 0f);
esprites[i].setTextureMatrix(espritetexmatrix[i]);
esprites[i].touch();
if (i == 0)
{
// Log.d(TAG,"Translated esprite matrix..u:"+espritetexmatrix[i].getTranslation().x+", v:"+espritetexmatrix[i].getTranslation().y);
}
}
espriteframe[i]++;
}
}
}
}
}
currentframe = 1;
}
}
public void loadlevel(final World world) // overloaded function haha this is
// where we will do it in
// code.....
{
Logger.setLogLevel(Logger.LL_ONLY_ERRORS);
Bitmap bmp = Bitmap.createBitmap(64, 64, Bitmap.Config.ARGB_8888);
int[] pixels = new int[64 * 64];
bmp.getPixels(pixels, 0, 64, 0, 0, 64, 64);
for (i = 0; i < 64; i++)
{
for (j = 0; j < 64; j++)
{
pixels[i + j * 64] = 255 << 24 | 48 << 16 | 48 << 8 | 64;
}
}
bmp.setPixels(pixels, 0, 64, 0, 0, 64, 64);
cachetex = new Texture(bmp, true);
TextureManager.getInstance().addTexture("cachetex", cachetex);
loadingscreen = new Object3D(2);
loadingscreen.setCulling(false);
loadingscreen.addTriangle(new SimpleVector(-2000, -2000, 200), 0, 0, new SimpleVector(2000, -2000, 200), 1, 0, new SimpleVector(2000, 2000, 200), 1, 1);
loadingscreen.addTriangle(new SimpleVector(2000, 2000, 200), 1, 1, new SimpleVector(-2000, 2000, 200), 0, 1, new SimpleVector(-2000, -2000, 200), 0, 0);
loadingscreen.setAdditionalColor(32, 96, 128);
loadingscreen.setBillboarding(true);
loadingscreen.setOrigin(SimpleVector.ORIGIN);
loadingscreen.setTexture("cachetex");
loadingscreen.build();
loadingscreen.strip();
loadingscreen.setVisibility(true);
world.addObject(loadingscreen);
// load sound objects for pilotchatter.....
// we are going to have to play with this......a lot......
createallmeshes(world);
if (jumpoutimmediately)
{
return;
}
createlasertex();
if (jumpoutimmediately)
{
return;
}
createexplosiontex(world);
if (jumpoutimmediately)
{
return;
}
createenginetex(world);
if (jumpoutimmediately)
{
return;
}
createspacedebris(world);
if (jumpoutimmediately)
{
return;
}
loadkeyframes(world);
if (jumpoutimmediately)
{
return;
}
pchatter = new PilotChatter(assets,ateami);
if (jumpoutimmediately)
{
return;
}
// }
Log.i(TAG, "End of load level");
}
public void createteamhptex(final World uiworld)
{
// must do this after loading the ships......so we know the right
// teams....
teamhptextures = new Texture[5];
InputStream intex = null;
for (i = 1; i < 6; i++)
{
boolean tmp11 = false;
for (j = 0; j < 32; j++)
{
if (i == ships[j].team)
{
tmp11 = true;
}
}
if (!tmp11)
{
continue;
}
try
{
intex = assets.open("hud/team_hp_" + i + ".png");
teamhptextures[i - 1] = new Texture(intex, true);
TextureManager.getInstance().addTexture("teamhp" + i, teamhptextures[i - 1]);
}
catch (IOException e)
{
Log.e(TAG, "Error opening team hud texture");
e.printStackTrace();
}
finally
{
try
{
intex.close();
}
catch (Exception e)
{
Log.e(TAG, "Error closing intex");
}
}
}
if (teamhpsprites == null)
{
teamhpsprites = new Object3D[32];
teamhptexmatrix = new Matrix[32];
teamhpucoord = new float[32];
teamhpvcoord = new float[32];
for (i = 0; i < 32; i++)
{
teamhpsprites[i] = new Object3D(2);
teamhpsprites[i].addTriangle(new SimpleVector(-2, -2, 0), 0, 0, new SimpleVector(2, -2, 0), 0.25f, 0, new SimpleVector(2, 2, 0), 0.25f, 0.25f);
teamhpsprites[i].addTriangle(new SimpleVector(2, 2, 0), 0.25f, 0.25f, new SimpleVector(-2, 2, 0), 0, 0.25f, new SimpleVector(-2, -2, 0), 0, 0);
teamhpucoord[i] = 0;
teamhpvcoord[i] = 0;
teamhpsprites[i].setCulling(false);
teamhpsprites[i].setBillboarding(true);
teamhpsprites[i].setTransparencyMode(Object3D.TRANSPARENCY_MODE_DEFAULT);
teamhpsprites[i].setTransparency(250);
teamhpsprites[i].setAdditionalColor(255, 255, 255);
teamhpsprites[i].setTexture("teamhp" + ships[i].team);
teamhptexmatrix[i] = new Matrix();
teamhpsprites[i].setTextureMatrix(teamhptexmatrix[i]);
teamhpsprites[i].compile(true, false);
teamhpsprites[i].build(false);
teamhpsprites[i].setVisibility(false);
teamhpsprites[i].setOrigin(SimpleVector.ORIGIN);
// we want to add to the UI world......(and only that one)
// position in world?
// uiworld is only 100 units deep....
// and our sprites are 2 units wide....
// we have 32 of them at max....
// total space taken up is 64 units if they were side by side...
// with room for 36 units between them total....
// 50 units assigned for each team....
// 16 * 2 = 32...units taken up in the 50..leaves 18...
// have 4 units at end empty...
// have 4 units at start empty....
// 10 units divided into 15 equal segments....is space between
// each one...
if (i < 16)
{
if (i < 8)
{
teamhpsprites[i].translate(-50f + 8f + (float) i * 4.4f, -28f, 90f);
}
else
{
teamhpsprites[i].translate(-50f + 8f + (float) (i - 8) * 4.4f, -24.5f, 90f);
}
}
else
{
if (i < 24)
{
teamhpsprites[i].translate(50f - (8f + (float) (i - 16) * 4.4f), -28f, 90f);
}
else
{
teamhpsprites[i].translate(50f - (8f + (float) (i - 24) * 4.4f), -24.5f, 90f);
}
}
uiworld.addObject(teamhpsprites[i]);
Log.i(TAG, "teamhudhp sprite created");
}
}
else
{
// don't do anything...
}
}
public void createenginetex(final World world)
{
enginetrailtextures = new Texture[1];
InputStream intex = null;
try
{
intex = assets.open("effects/trailtex.png");
enginetrailtextures[0] = new Texture(intex,true);
TextureManager.getInstance().addTexture("etrail",enginetrailtextures[0]);
}
catch(IOException e)
{
Log.e(TAG,"Error opening engine tex");
e.printStackTrace();
}
finally
{
try
{
intex.close();
}
catch(Exception e)
{
Log.e(TAG,"error closing engine tex");
}
}
if(enginesprites==null)
{
Log.i(TAG, "Enginesprites creation");
enginespriteframe = new int[MAXENGSPRITES]; //each fighter/bomber has up to 2 engines, and has 6 billboards per engine....
enginesprites = new Object3D[MAXENGSPRITES];
enginespritetexmatrix = new Matrix[MAXENGSPRITES];
angle1 = 1.0f;
for (i = 0; i < MAXENGSPRITES; i++)
{
enginespriteframe[i] = -1;
enginesprites[i] = new Object3D(8);
enginesprites[i].disableLazyTransformations();
enginesprites[i].addTriangle(new SimpleVector(-ENGSPRITESIZE/8,0,0), 0f, 0f, new SimpleVector(ENGSPRITESIZE/8, 0, 0), 0.25f, 0f, new SimpleVector(ENGSPRITESIZE/8, 0, ENGSPRITESIZE), 0.25f, 0.25f);
enginesprites[i].addTriangle(new SimpleVector(ENGSPRITESIZE/8, 0,ENGSPRITESIZE), 0.25f, 0.25f, new SimpleVector(-ENGSPRITESIZE/8, 0,ENGSPRITESIZE), 0f, 0.25f, new SimpleVector(-ENGSPRITESIZE /8, 0, 0), 0f, 0f);
enginesprites[i].addTriangle(new SimpleVector(0,-ENGSPRITESIZE/8,0), 0f, 0f, new SimpleVector(0,ENGSPRITESIZE/8, 0), 0.25f, 0f, new SimpleVector(0,ENGSPRITESIZE/8, ENGSPRITESIZE), 0.25f, 0.25f);
enginesprites[i].addTriangle(new SimpleVector(0,ENGSPRITESIZE/8, ENGSPRITESIZE), 0.25f, 0.25f, new SimpleVector(0,-ENGSPRITESIZE/8, ENGSPRITESIZE), 0f, 0.25f, new SimpleVector(0,-ENGSPRITESIZE /8, 0), 0f, 0f);
enginesprites[i].addTriangle(new SimpleVector(-ENGSPRITESIZE/8,-ENGSPRITESIZE/8,0), 0f, 0f, new SimpleVector(ENGSPRITESIZE/8, ENGSPRITESIZE/8, 0), 0.25f, 0f, new SimpleVector(ENGSPRITESIZE/8, ENGSPRITESIZE/8, ENGSPRITESIZE), 0.25f, 0.25f);
enginesprites[i].addTriangle(new SimpleVector(ENGSPRITESIZE/8, ENGSPRITESIZE/8,ENGSPRITESIZE), 0.25f, 0.25f, new SimpleVector(-ENGSPRITESIZE/8, -ENGSPRITESIZE/8,ENGSPRITESIZE), 0f, 0.25f, new SimpleVector(-ENGSPRITESIZE /8, -ENGSPRITESIZE/8, 0), 0f, 0f);
enginesprites[i].addTriangle(new SimpleVector(-ENGSPRITESIZE/8,ENGSPRITESIZE/8,0), 0f, 0f, new SimpleVector(ENGSPRITESIZE/8, -ENGSPRITESIZE/8, 0), 0.25f, 0f, new SimpleVector(ENGSPRITESIZE/8, -ENGSPRITESIZE/8, ENGSPRITESIZE), 0.25f, 0.25f);
enginesprites[i].addTriangle(new SimpleVector(ENGSPRITESIZE/8, -ENGSPRITESIZE/8,ENGSPRITESIZE), 0.25f, 0.25f, new SimpleVector(-ENGSPRITESIZE/8, ENGSPRITESIZE/8,ENGSPRITESIZE), 0f, 0.25f, new SimpleVector(-ENGSPRITESIZE /8, ENGSPRITESIZE/8, 0), 0f, 0f);
enginesprites[i].setCulling(false);
enginesprites[i].setTransparencyMode(Object3D.TRANSPARENCY_MODE_ADD);
enginesprites[i].setTransparency(127);
enginesprites[i].setAdditionalColor(255, 255, 255);
enginesprites[i].setTexture("etrail");
enginespritetexmatrix[i] = new Matrix();
enginesprites[i].setTextureMatrix(enginespritetexmatrix[i]);
enginesprites[i].compile(true, false);
enginesprites[i].build(false);
enginesprites[i].setVisibility(false);
enginesprites[i].setOrigin(SimpleVector.ORIGIN);
world.addObject(enginesprites[i]);
Log.i(TAG, "enginesprite mesh created");
}
}
else
{
for (i = 0; i < MAXENGSPRITES; i++)
{
espriteframe[i] = -1;
}
}
}
public void createexplosiontex(final World world)
{
if (rand == null)
{
rand = new Random();
rand.setSeed(System.currentTimeMillis());
}
explosiontextures = new Texture[8]; // tex 8 could be a special one? - massive explosion maybe? (i == 7....)
InputStream intex = null;
for (i = 0; i < 8; i++)
{
j = i + 1;
try
{
// changing for now.....to png with alpha
if (Config.ISLOWSPECDEVICE)
{
intex = assets.open("effects/lowspec/etex" + j + ".png");
}
else
{
intex = assets.open("effects/etex" + j + ".png");
}
explosiontextures[i] = new Texture(intex, true);
TextureManager.getInstance().addTexture("etex" + i, explosiontextures[i]);
}
catch (IOException e)
{
Log.e(TAG, "Error opening explosion texture");
e.printStackTrace();
}
finally
{
try
{
intex.close();
}
catch (Exception e)
{
Log.e(TAG, "Error closing intex");
}
}
}
if (esprites == null)
{
Log.i(TAG, "Esprites creation");
espriteframe = new int[MAXESPRITES / LOWSPECDIV];
esprites = new Object3D[MAXESPRITES / LOWSPECDIV];
espritetexmatrix = new Matrix[MAXESPRITES / LOWSPECDIV];
// espriteshader = new GLSLShader[MAXESPRITES];
angle1 = 1.0f;
for (i = 0; i < MAXESPRITES / LOWSPECDIV; i++)
{
angle1 = 1.0f + 0.25f * (float) (i - MAXESPRITES / LOWSPECDIV / 2) / (float) MAXESPRITES / LOWSPECDIV;
espriteframe[i] = -1;
esprites[i] = new Object3D(2);
esprites[i].disableLazyTransformations();
esprites[i].addTriangle(new SimpleVector(-ESPRITESIZE * angle1, -ESPRITESIZE * angle1, 0), 0f, 0f, new SimpleVector(ESPRITESIZE, -ESPRITESIZE, 0), 0.125f, 0f, new SimpleVector(ESPRITESIZE * angle1, ESPRITESIZE * angle1, 0), 0.125f, 0.125f);
esprites[i].addTriangle(new SimpleVector(ESPRITESIZE * angle1, ESPRITESIZE * angle1, 0), 0.125f, 0.125f, new SimpleVector(-ESPRITESIZE, ESPRITESIZE, 0), 0f, 0.125f, new SimpleVector(-ESPRITESIZE * angle1, -ESPRITESIZE * angle1, 0), 0f, 0f);
esprites[i].setCulling(false);
esprites[i].setBillboarding(true);
esprites[i].setTransparencyMode(Object3D.TRANSPARENCY_MODE_ADD);
esprites[i].setTransparency(255);
esprites[i].setAdditionalColor(255, 255, 255);
esprites[i].setTexture("etex" + (i % 8));
espritetexmatrix[i] = new Matrix();
esprites[i].setTextureMatrix(espritetexmatrix[i]);
esprites[i].compile(true, false);
esprites[i].build(false);
esprites[i].setVisibility(false);
esprites[i].setOrigin(SimpleVector.ORIGIN);
world.addObject(esprites[i]);
Log.i(TAG, "esprite mesh created");
}
}
else
{
for (i = 0; i < MAXESPRITES / LOWSPECDIV; i++)
{
espriteframe[i] = -1;
}
}
}
public void loadkeyframes(final World world)
{
final String ext = ".jpg"; // modified 3-5-2015
final String ext2 = ".jpg";
String testinginput = null;
InputStream in = null;
FileChannel fc = null;
// FileInputStream fin = null;
// ObjectInputStream oin = null;
// SerialisedReplayFile serin = null;
long fsize = 0;
// byte[] fbytes = null;
ByteBuffer fbuffer = null;
try
{
if (rfile == null) // should never happen!
{
// check if file exists first.....
tmpboolean = false;
if (!tmpboolean)
{
in = assets.open("testreplay/replay.dat");
Log.i(TAG, "Standard file loaded"); // this will be used for
// demos later.....(need
// to replace file
// though!)
}
}
else
{
fc = new FileInputStream(rfile).getChannel();
fsize = fc.size();
Log.i(TAG, "File read from system");
// Log.i(TAG,"using serialised method:your time starts now:"+System.currentTimeMillis());
// fin = new FileInputStream(rfile);
// oin = new ObjectInputStream(fin);
}
// int offset = 0;
// number of frames..
if (fc != null)
{
/*
* try { serin = (SerialisedReplayFile) oin.readObject(); } catch (ClassNotFoundException e) { Log.e(TAG,"Class not found - serialisation error"); e.printStackTrace(); //should never
* happen really } finally { try { oin.close(); } catch(Exception ffgeff) { Log.e(TAG,"error closing oin"); } } try { fin.close(); } catch(Exception eeljkf) {
* Log.e(TAG,"Error closing fin"); }
*/
// fbytes = new byte[(int) fsize];
fbuffer = ByteBuffer.allocate((int) fsize);
Log.i(TIMERTAG, "Start Reading Fc:" + System.currentTimeMillis());
if (fc.read(fbuffer) == fsize)
{
Log.i(TIMERTAG, "End reading fc:" + System.currentTimeMillis());
// all file read in.....
// Log.i(TAG, "Reading fc fast way - now with serialisation - but still not optimal");
// int foffset = 0;
// fbytes = fbuffer.array(); //no longer necessery since you have just read it all in...
// keyframe = serin.keyframe;
// cameraframe = serin.camkeys;
// int maxframes = keyframe.length;
// testinginput = serin.txtinput;
Log.i(TIMERTAG, "Begin interpreting keyframes:Time:" + System.currentTimeMillis());
// int maxframes = ByteBuffer.wrap(new byte[] { (byte) fbytes[0], (byte) fbytes[1], (byte) fbytes[2], (byte) fbytes[3] }).getInt();
int maxframes = 0;
try
{
fbuffer.rewind();
maxframes = fbuffer.getInt();
// ///// serialisation trying to replace all this....
keyframe = new KeyFrame[maxframes];
// byte byte0, byte1, byte2, byte3;
// foffset = 4;
for (int ff = 0; ff < maxframes; ff++)
{
if (jumpoutimmediately)
{
return;
}
keyframe[ff] = new KeyFrame();
keyframe[ff].shipids = new byte[32];
keyframe[ff].shiptypes = new byte[32];
keyframe[ff].shipteam = new byte[32];
keyframe[ff].shipdata = new KeyFrameData[32];
for (int gg = 0; gg < 32; gg++)
{
keyframe[ff].shipids[gg] = fbuffer.get();// fbytes[foffset];
// foffset++;// (byte)in.read();
keyframe[ff].shiptypes[gg] = fbuffer.get();// fbytes[foffset];
// foffset++;// (byte)in.read();
keyframe[ff].shipteam[gg] = fbuffer.get();// fbytes[foffset];
// foffset++;// (byte)in.read();
keyframe[ff].shipdata[gg] = new KeyFrameData();
keyframe[ff].shipdata[gg].x = fbuffer.getFloat();
// foffset+=4;
/*
* byte0 = fbytes[foffset]; foffset++;// in.read(); byte1 = fbytes[foffset]; foffset++;// in.read(); byte2 = fbytes[foffset]; foffset++;// in.read(); byte3 =
* fbytes[foffset]; foffset++;// in.read(); keyframe[ff].shipdata[gg].x = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3
* }).getFloat();
*/
keyframe[ff].shipdata[gg].y = fbuffer.getFloat();
// foffset+=4;
/*
* byte0 = fbytes[foffset]; foffset++;// in.read(); byte1 = fbytes[foffset]; foffset++;// in.read(); byte2 = fbytes[foffset]; foffset++;// in.read(); byte3 =
* fbytes[foffset]; foffset++;// in.read(); keyframe[ff].shipdata[gg].y = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3
* }).getFloat();
*/
keyframe[ff].shipdata[gg].z = fbuffer.getFloat();
// foffset+=4;
/*
* byte0 = fbytes[foffset]; foffset++;// in.read(); byte1 = fbytes[foffset]; foffset++;// in.read(); byte2 = fbytes[foffset]; foffset++;// in.read(); byte3 =
* fbytes[foffset]; foffset++;// in.read(); keyframe[ff].shipdata[gg].z = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3
* }).getFloat();
*/
keyframe[ff].shipdata[gg].hp = fbuffer.getShort();
// foffset+=2;
/*
* byte0 = fbytes[foffset]; foffset++;// in.read(); byte1 = fbytes[foffset]; foffset++;// in.read(); keyframe[ff].shipdata[gg].hp = ByteBuffer.wrap(new byte[] { (byte)
* byte0, (byte) byte1 }).getShort();
*/
/*
* if(keyframe[ff].shipdata[gg].hp==-10000) { if(ships[gg]!=null) {
*
* } else { ships[gg] = new Ship();
*
* } if(ships[gg].splitframe==0){ships[gg].splitframe = ff;} }
*/
// byte0 = fbytes[foffset];
// foffset++;// in.read();
int int0 = fbuffer.get();// byte0;
if (int0 < 0)
{
int0 += 256;
}
keyframe[ff].shipdata[gg].firingframe = new byte[int0];
keyframe[ff].shipdata[gg].fx = new float[int0];
keyframe[ff].shipdata[gg].fy = new float[int0];
keyframe[ff].shipdata[gg].fz = new float[int0];
keyframe[ff].shipdata[gg].fux = new float[int0];
keyframe[ff].shipdata[gg].fuy = new float[int0];
keyframe[ff].shipdata[gg].fuz = new float[int0];
for (int kk = 0; kk < keyframe[ff].shipdata[gg].firingframe.length; kk++)
{
keyframe[ff].shipdata[gg].firingframe[kk] = fbuffer.get();// fbytes[foffset];
// foffset++;// in.read();(byte)in.read();
if (keyframe[ff].shipdata[gg].firingframe[kk] > 0)
{
// so we don't have to calculate in the
// loop.....
// keyframe[ff].shipdata[gg].firingframe[kk]--;
keyframe[ff].shipdata[gg].fx[kk] = fbuffer.getFloat();
// foffset+=4;
/*
* byte0 = fbytes[foffset]; foffset++;// in.read(); byte1 = fbytes[foffset]; foffset++;// in.read(); byte2 = fbytes[foffset]; foffset++;// in.read(); byte3 =
* fbytes[foffset]; foffset++;// in.read();
*
* keyframe[ff].shipdata[gg].fx[kk] = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
*/
/*
* byte0 = fbytes[foffset]; foffset++;// in.read(); byte1 = fbytes[foffset]; foffset++;// in.read(); byte2 = fbytes[foffset]; foffset++;// in.read(); byte3 =
* fbytes[foffset]; foffset++;// in.read(); keyframe[ff].shipdata[gg].fy[kk] = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte)
* byte3 }).getFloat();
*/
keyframe[ff].shipdata[gg].fy[kk] = fbuffer.getFloat();
/*
* byte0 = fbytes[foffset]; foffset++;// in.read(); byte1 = fbytes[foffset]; foffset++;// in.read(); byte2 = fbytes[foffset]; foffset++;// in.read(); byte3 =
* fbytes[foffset]; foffset++;// in.read(); keyframe[ff].shipdata[gg].fz[kk] = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte)
* byte3 }).getFloat();
*/
keyframe[ff].shipdata[gg].fz[kk] = fbuffer.getFloat();
/*
* byte0 = fbytes[foffset]; foffset++;// in.read(); byte1 = fbytes[foffset]; foffset++;// in.read(); byte2 = fbytes[foffset]; foffset++;// in.read(); byte3 =
* fbytes[foffset]; foffset++;// in.read();
*
* keyframe[ff].shipdata[gg].fux[kk] = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
*/
keyframe[ff].shipdata[gg].fux[kk] = fbuffer.getFloat();
/*
* byte0 = fbytes[foffset]; foffset++;// in.read(); byte1 = fbytes[foffset]; foffset++;// in.read(); byte2 = fbytes[foffset]; foffset++;// in.read(); byte3 =
* fbytes[foffset]; foffset++;// in.read(); keyframe[ff].shipdata[gg].fuy[kk] = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte)
* byte3 }).getFloat();
*/
keyframe[ff].shipdata[gg].fuy[kk] = fbuffer.getFloat();
/*
* byte0 = fbytes[foffset]; foffset++;// in.read(); byte1 = fbytes[foffset]; foffset++;// in.read(); byte2 = fbytes[foffset]; foffset++;// in.read(); byte3 =
* fbytes[foffset]; foffset++;// in.read();
*/
// keyframe[ff].shipdata[gg].fuz[kk] = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
keyframe[ff].shipdata[gg].fuz[kk] = fbuffer.getFloat();
}
}
}
}
}
catch (Exception e)
{
jumpoutimmediately = true;
}
if (jumpoutimmediately)
{
return;
}
/*
* byte0 = fbytes[foffset]; foffset++;// in.read(); byte1 = fbytes[foffset]; foffset++;// in.read(); byte2 = fbytes[foffset]; foffset++;// in.read(); byte3 = fbytes[foffset];
* foffset++;// in.read(); int txtlength = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getInt();
*/
int txtlength = 0;
try
{
txtlength = fbuffer.getInt();
byte[] buffer = new byte[txtlength];
// in.read(buffer);
fbuffer.get(buffer, 0, txtlength);
StringBuilder str = new StringBuilder();
for (int i = 0; i < txtlength; i++)
{
char abc = (char) buffer[i];
str.append(abc);
}
testinginput = str.toString();
Log.d(TAG, "Testing Input:" + testinginput);
}
catch (Exception e)
{
jumpoutimmediately = true;
}
if (jumpoutimmediately)
{
return;
}
readfrominput(testinginput);
mesh = new Mesh[8];
for (k = 0; k < 8; k++)
{
mesh[k] = new Mesh();
}
for (int gg = 0; gg < 32; gg++)
{
if (jumpoutimmediately)
{
return;
}
ships[gg].pivot = Entity.createEntity(world);
if(ships[gg].shiptype>2)
{
ships[gg].epivot1 = Entity.createEntity(world);
ships[gg].epivot2 = Entity.createEntity(world);
//translate and position the entity appropriately......
if(keyframe[0].shipteam[gg]==1 && ships[gg].shiptype==3)
{
//directly behind
ships[gg].epivot1.translate(1, 0, -17.5f);
ships[gg].epivot2.translate(1, 0, -17.5f);
}
if(keyframe[0].shipteam[gg]==1 && ships[gg].shiptype==4)
{
//directly behind, down a little and across a bit each way....
ships[gg].epivot1.translate(4f, 1f, -17.5f);
ships[gg].epivot2.translate(-3f, 1f, -17.5f);
}
if(keyframe[0].shipteam[gg]==2 && ships[gg].shiptype==3)
{
//directly behind
ships[gg].epivot1.translate(2, 0, -19f);
ships[gg].epivot2.translate(2, 0, -19f);
}
if(keyframe[0].shipteam[gg]==2 && ships[gg].shiptype==4)
{
//directly behind
ships[gg].epivot1.translate(4, 0, -13f);
ships[gg].epivot2.translate(4, 0, -13f);
}
if(keyframe[0].shipteam[gg]==3 && ships[gg].shiptype==3)
{
//directly behind
ships[gg].epivot1.translate(3, 0, -16f);
ships[gg].epivot2.translate(3, 0, -16f);
}
if(keyframe[0].shipteam[gg]==3 && ships[gg].shiptype==4)
{
//directly behind, up a little and across a bit each way
ships[gg].epivot1.translate(3, 0f, -16f);
ships[gg].epivot2.translate(3, 0f, -16f);
}
if(keyframe[0].shipteam[gg]==4 && ships[gg].shiptype==3)
{
//db, up, across
ships[gg].epivot1.translate(4f, 0f, -13f);
ships[gg].epivot2.translate(-5f, 0f, -13f);
}
if(keyframe[0].shipteam[gg]==4 && ships[gg].shiptype==4)
{
//db, up, across
ships[gg].epivot1.translate(7f, 0f, -13f);
ships[gg].epivot2.translate(-6f, 0f, -13f);
}
if(keyframe[0].shipteam[gg]==5 && ships[gg].shiptype==3)
{
//directly behind..
ships[gg].epivot1.translate(2f, 0, -11f);
ships[gg].epivot2.translate(2f, 0, -11f);
}
if(keyframe[0].shipteam[gg]==5 && ships[gg].shiptype==4)
{
//directly behind...
ships[gg].epivot1.translate(4f, 0, -11f);
ships[gg].epivot2.translate(4f, 0, -11f);
}
ships[gg].epivot1.addParent(ships[gg].pivot);
ships[gg].epivot2.addParent(ships[gg].pivot);
}
ships[gg].mesh = new Object3D[1];
/*
* if(ships[gg].team % 2 == 1) { //edit - 5-Apr-2015 - swapped as was doing it wrong....eventually we will have ships per team anyway....all 8 teams....(32 ships)
* ships[gg].mesh[0] = mesh[ships[gg].shiptype-1].obj.cloneObject(); } else { ships[gg].mesh[0] = mesh[4+ships[gg].shiptype-1].obj.cloneObject(); }
*/
int meshid = (ships[gg].shiptype - 1) + ((int) (keyframe[0].shipteam[gg]) - 1) * 4;
if (meshid < 0)
{
Log.i(TAG, "Error...negative meshid");
meshid = 0;
}
if (meshid > 19)
{
Log.i(TAG, "Error...meshid too big");
meshid = 19;
}
String myext = ext;
if (meshid >= 0 && meshid < 20)
{
Log.i(TAG, "meshid:" + meshid);
if (meshid % 4 == 0)
{
if (meshid == 8)
{
myext = ext2;
}
else
{
myext = ext;
}
for (j = 0; j < 8; j++)
{
if (mesh[j].index == meshid)
{
/*
* ships[gg].meshhalfA = mesh[j].obj.cloneObject(); ships[gg].meshhalfB = mesh[j].obj.cloneObject(); ships[gg].meshhalfA.setTransparency(255);
* ships[gg].meshhalfA.setTransparencyMode(Object3D.TRANSPARENCY_MODE_DEFAULT); ships[gg].meshhalfB.setTransparency(255);
* ships[gg].meshhalfB.setTransparencyMode(Object3D.TRANSPARENCY_MODE_DEFAULT);
*/
ships[gg].mesh[0] = mesh[j].obj.cloneObject();
break;
}
}
if (ships[gg].mesh[0] == null)
{
for (j = 0; j < 8; j++)
{
if (mesh[j].index == -1)
{
if (Config.ISLOWSPECDEVICE)
{
mesh[j].loadencryptedserializedobj(assets, "3dmodels/spaceships/cap" + (((meshid - (meshid % 4)) / 4) + 1) + ".dat", "3dmodels/spaceships/lowspec/cap" + (((meshid - (meshid % 4)) / 4) + 1) + myext, meshid, 111);
}
else
{
mesh[j].loadencryptedserializedobj(assets, "3dmodels/spaceships/cap" + (((meshid - (meshid % 4)) / 4) + 1) + ".dat", "3dmodels/spaceships/cap" + (((meshid - (meshid % 4)) / 4) + 1) + myext, meshid, 111);
}
/*
* ships[gg].meshhalfA = mesh[j].obj.cloneObject(); ships[gg].meshhalfB = mesh[j].obj.cloneObject(); ships[gg].meshhalfA.setTransparency(255);
* ships[gg].meshhalfA.setTransparencyMode(Object3D.TRANSPARENCY_MODE_DEFAULT); ships[gg].meshhalfB.setTransparency(255);
* ships[gg].meshhalfB.setTransparencyMode(Object3D.TRANSPARENCY_MODE_DEFAULT);
*/
ships[gg].mesh[0] = mesh[j].obj.cloneObject();
break;
}
}
}
}
if (meshid % 4 == 1)
{
if (meshid == 9)
{
myext = ext2;
}
else
{
myext = ext;
}
for (j = 0; j < 8; j++)
{
if (mesh[j].index == meshid)
{
/*
* ships[gg].meshhalfA = mesh[j].obj.cloneObject(); ships[gg].meshhalfB = mesh[j].obj.cloneObject(); ships[gg].meshhalfA.setTransparency(255);
* ships[gg].meshhalfA.setTransparencyMode(Object3D.TRANSPARENCY_MODE_DEFAULT); ships[gg].meshhalfB.setTransparency(255);
* ships[gg].meshhalfB.setTransparencyMode(Object3D.TRANSPARENCY_MODE_DEFAULT);
*/
ships[gg].mesh[0] = mesh[j].obj.cloneObject();
break;
}
}
if (ships[gg].mesh[0] == null)
{
for (j = 0; j < 8; j++)
{
if (mesh[j].index == -1)
{
if (Config.ISLOWSPECDEVICE)
{
mesh[j].loadencryptedserializedobj(assets, "3dmodels/spaceships/crs" + (((meshid - (meshid % 4)) / 4) + 1) + ".dat", "3dmodels/spaceships/lowspec/crs" + (((meshid - (meshid % 4)) / 4) + 1) + myext, meshid, 111);
}
else
{
mesh[j].loadencryptedserializedobj(assets, "3dmodels/spaceships/crs" + (((meshid - (meshid % 4)) / 4) + 1) + ".dat", "3dmodels/spaceships/crs" + (((meshid - (meshid % 4)) / 4) + 1) + myext, meshid, 111);
}
/*
* ships[gg].meshhalfA = mesh[j].obj.cloneObject(); ships[gg].meshhalfB = mesh[j].obj.cloneObject(); ships[gg].meshhalfA.setTransparency(255);
* ships[gg].meshhalfA.setTransparencyMode(Object3D.TRANSPARENCY_MODE_DEFAULT); ships[gg].meshhalfB.setTransparency(255);
* ships[gg].meshhalfB.setTransparencyMode(Object3D.TRANSPARENCY_MODE_DEFAULT);
*/
ships[gg].mesh[0] = mesh[j].obj.cloneObject();
break;
}
}
}
}
if (meshid % 4 == 2)
{
if (meshid == 18 || meshid == 14)
{
myext = ext2;
}
else
{
myext = ext;
}
for (j = 0; j < 8; j++)
{
if (mesh[j].index == meshid)
{
/*
* ships[gg].meshhalfA = null; ships[gg].meshhalfB = null;
*/
ships[gg].mesh[0] = mesh[j].obj.cloneObject();
break;
}
}
if (ships[gg].mesh[0] == null)
{
for (j = 0; j < 8; j++)
{
if (mesh[j].index == -1)
{
if (Config.ISLOWSPECDEVICE)
{
mesh[j].loadencryptedserializedobj(assets, "3dmodels/spaceships/bmbr" + (((meshid - (meshid % 4)) / 4) + 1) + ".dat", "3dmodels/spaceships/lowspec/bmbr" + (((meshid - (meshid % 4)) / 4) + 1) + myext, meshid, 111);
}
else
{
mesh[j].loadencryptedserializedobj(assets, "3dmodels/spaceships/bmbr" + (((meshid - (meshid % 4)) / 4) + 1) + ".dat", "3dmodels/spaceships/bmbr" + (((meshid - (meshid % 4)) / 4) + 1) + myext, meshid, 111);
}
/*
* ships[gg].meshhalfA = null; ships[gg].meshhalfB = null;
*/
ships[gg].mesh[0] = mesh[j].obj.cloneObject();
break;
}
}
}
}
if (meshid % 4 == 3)
{
if (meshid == 15 || meshid == 19)
{
myext = ext2;
}
else
{
myext = ext;
}
for (j = 0; j < 8; j++)
{
if (mesh[j].index == meshid)
{
/*
* ships[gg].meshhalfA = null; ships[gg].meshhalfB = null;
*/
ships[gg].mesh[0] = mesh[j].obj.cloneObject();
break;
}
}
if (ships[gg].mesh[0] == null)
{
for (j = 0; j < 8; j++)
{
if (mesh[j].index == -1)
{
if (Config.ISLOWSPECDEVICE)
{
mesh[j].loadencryptedserializedobj(assets, "3dmodels/spaceships/fgtr" + (((meshid - (meshid % 4)) / 4) + 1) + ".dat", "3dmodels/spaceships/lowspec/fgtr" + (((meshid - (meshid % 4)) / 4) + 1) + myext, meshid, 111);
}
else
{
mesh[j].loadencryptedserializedobj(assets, "3dmodels/spaceships/fgtr" + (((meshid - (meshid % 4)) / 4) + 1) + ".dat", "3dmodels/spaceships/fgtr" + (((meshid - (meshid % 4)) / 4) + 1) + myext, meshid, 111);
}
/*
* ships[gg].meshhalfA = null; ships[gg].meshhalfB = null;
*/
ships[gg].mesh[0] = mesh[j].obj.cloneObject();
break;
}
}
}
}
}
Log.i(TAG, "meshid:" + meshid);
if (ships[gg].mesh == null)
{
Log.i(TAG, "ship mesh = null");
}
if (ships[gg].mesh.length <= 0)
{
Log.i(TAG, "ship mesh length <= 0");
}
ships[gg].mesh[0].build();
ships[gg].mesh[0].strip();
ships[gg].mesh[0].addParent(ships[gg].pivot);
ships[gg].mesh[0].setVisibility(true);
world.addObject(ships[gg].mesh[0]);
ships[gg].mesh[0].setRotationMatrix(ROTATE3DS.getRotationMatrix());
ships[gg].pivot.translate(new SimpleVector(keyframe[0].shipdata[gg].x, keyframe[0].shipdata[gg].y, keyframe[0].shipdata[gg].z));
SimpleVector rot = new SimpleVector(0, 0, 1);
ships[gg].pivot.setRotationMatrix(rot.getRotationMatrix());
/*
* if (ships[gg].meshhalfA != null) { ships[gg].meshhalfA.build(); ships[gg].meshhalfA.strip(); ships[gg].meshhalfA.addParent(ships[gg].pivot);
* ships[gg].meshhalfA.setVisibility(false); world.addObject(ships[gg].meshhalfA); ships[gg].meshhalfA.setRotationMatrix(ROTATE3DS.getRotationMatrix());
*
* } if (ships[gg].meshhalfB != null) { ships[gg].meshhalfB.build(); ships[gg].meshhalfB.strip(); ships[gg].meshhalfB.addParent(ships[gg].pivot);
* ships[gg].meshhalfB.setVisibility(false); world.addObject(ships[gg].meshhalfB); ships[gg].meshhalfB.setRotationMatrix(ROTATE3DS.getRotationMatrix()); }
*/
}
// serialisation should have taken care of this....
// now read in camera values....
try
{
for (int i = 0; i < maxframes; i++)
{
if (jumpoutimmediately)
{
return;
}
cameraframe[i] = new CameraKeyFrame();
/*
* byte0 = fbytes[foffset]; foffset++;// in.read(); byte1 = fbytes[foffset]; foffset++;// in.read(); byte2 = fbytes[foffset]; foffset++;// in.read(); byte3 =
* fbytes[foffset]; foffset++;// in.read(); cameraframe[i].x = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
*/
cameraframe[i].x = fbuffer.getFloat();
/*
* byte0 = fbytes[foffset]; foffset++;// in.read(); byte1 = fbytes[foffset]; foffset++;// in.read(); byte2 = fbytes[foffset]; foffset++;// in.read(); byte3 =
* fbytes[foffset]; foffset++;// in.read();
*
* cameraframe[i].y = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
*/
cameraframe[i].y = fbuffer.getFloat();
/*
* byte0 = fbytes[foffset]; foffset++;// in.read(); byte1 = fbytes[foffset]; foffset++;// in.read(); byte2 = fbytes[foffset]; foffset++;// in.read(); byte3 =
* fbytes[foffset]; foffset++;// in.read(); cameraframe[i].z = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
*/
cameraframe[i].z = fbuffer.getFloat();
/*
* byte0 = fbytes[foffset]; foffset++;// in.read(); byte1 = fbytes[foffset]; foffset++;// in.read(); byte2 = fbytes[foffset]; foffset++;// in.read(); byte3 =
* fbytes[foffset]; foffset++;// in.read(); cameraframe[i].lookx = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
*/
cameraframe[i].lookx = fbuffer.getFloat();
/*
* byte0 = fbytes[foffset]; foffset++;// in.read(); byte1 = fbytes[foffset]; foffset++;// in.read(); byte2 = fbytes[foffset]; foffset++;// in.read(); byte3 =
* fbytes[foffset]; foffset++;// in.read(); cameraframe[i].looky = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
*/
cameraframe[i].looky = fbuffer.getFloat();
/*
* byte0 = fbytes[foffset]; foffset++;// in.read(); byte1 = fbytes[foffset]; foffset++;// in.read(); byte2 = fbytes[foffset]; foffset++;// in.read(); byte3 =
* fbytes[foffset]; foffset++;// in.read(); cameraframe[i].lookz = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
*/
cameraframe[i].lookz = fbuffer.getFloat();
}
}
catch (Exception e)
{
jumpoutimmediately = true;
}
if (jumpoutimmediately)
{
return;
}
}
// else
// {
// Log.e(TAG, "fc did not read files properly");
// }
Log.i(TIMERTAG, "End interpreting keyframes:Time:" + System.currentTimeMillis());
try
{
fc.close();
}
catch (Exception fhh)
{
Log.e(TAG, "fc close failed");
}
Log.i(TIMERTAG, "oin method: your time ends here:" + System.currentTimeMillis());
}
else
{
Log.i(TAG, "Reading slow way");
int byte0 = in.read();
int byte1 = in.read();
int byte2 = in.read();
int byte3 = in.read();
int maxframes = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getInt();
keyframe = new KeyFrame[maxframes];
for (int ff = 0; ff < maxframes; ff++)
{
keyframe[ff] = new KeyFrame();
keyframe[ff].shipids = new byte[32];
keyframe[ff].shiptypes = new byte[32];
keyframe[ff].shipteam = new byte[32];
keyframe[ff].shipdata = new KeyFrameData[32];
for (int gg = 0; gg < 32; gg++)
{
keyframe[ff].shipids[gg] = (byte) in.read();
keyframe[ff].shiptypes[gg] = (byte) in.read();
keyframe[ff].shipteam[gg] = (byte) in.read();
keyframe[ff].shipdata[gg] = new KeyFrameData();
byte0 = in.read();
byte1 = in.read();
byte2 = in.read();
byte3 = in.read();
keyframe[ff].shipdata[gg].x = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
byte0 = in.read();
byte1 = in.read();
byte2 = in.read();
byte3 = in.read();
keyframe[ff].shipdata[gg].y = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
byte0 = in.read();
byte1 = in.read();
byte2 = in.read();
byte3 = in.read();
keyframe[ff].shipdata[gg].z = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
byte0 = in.read();
byte1 = in.read();
keyframe[ff].shipdata[gg].hp = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1 }).getShort();
byte0 = in.read();
int int0 = byte0;
if (int0 < 0)
{
int0 += 256;
}
keyframe[ff].shipdata[gg].firingframe = new byte[int0];
keyframe[ff].shipdata[gg].fx = new float[int0];
keyframe[ff].shipdata[gg].fy = new float[int0];
keyframe[ff].shipdata[gg].fz = new float[int0];
keyframe[ff].shipdata[gg].fux = new float[int0];
keyframe[ff].shipdata[gg].fuy = new float[int0];
keyframe[ff].shipdata[gg].fuz = new float[int0];
for (int kk = 0; kk < keyframe[ff].shipdata[gg].firingframe.length; kk++)
{
keyframe[ff].shipdata[gg].firingframe[kk] = (byte) in.read();
if (keyframe[ff].shipdata[gg].firingframe[kk] > 0)
{
// Log.d(TAG,"Firing should happen");
// keyframe[ff].shipdata[gg].firingframe[kk]--;
byte0 = in.read();
byte1 = in.read();
byte2 = in.read();
byte3 = in.read();
keyframe[ff].shipdata[gg].fx[kk] = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
byte0 = in.read();
byte1 = in.read();
byte2 = in.read();
byte3 = in.read();
keyframe[ff].shipdata[gg].fy[kk] = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
byte0 = in.read();
byte1 = in.read();
byte2 = in.read();
byte3 = in.read();
keyframe[ff].shipdata[gg].fz[kk] = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
byte0 = in.read();
byte1 = in.read();
byte2 = in.read();
byte3 = in.read();
keyframe[ff].shipdata[gg].fux[kk] = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
byte0 = in.read();
byte1 = in.read();
byte2 = in.read();
byte3 = in.read();
keyframe[ff].shipdata[gg].fuy[kk] = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
byte0 = in.read();
byte1 = in.read();
byte2 = in.read();
byte3 = in.read();
keyframe[ff].shipdata[gg].fuz[kk] = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
}
}
}
}
byte0 = in.read();
byte1 = in.read();
byte2 = in.read();
byte3 = in.read();
int txtlength = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getInt();
byte[] buffer = new byte[txtlength];
in.read(buffer);
StringBuilder str = new StringBuilder();
for (int i = 0; i < txtlength; i++)
{
char abc = (char) buffer[i];
str.append(abc);
}
testinginput = str.toString();
Log.d(TAG, "Testing Input:" + testinginput);
readfrominput(testinginput);
for (int gg = 0; gg < 32; gg++)
{
ships[gg].pivot = Entity.createEntity(world);
ships[gg].mesh = new Object3D[1];
if (keyframe[0].shipteam[gg] % 2 == 0)
{
/*
* if (ships[gg].meshhalfA == null) { if (ships[gg].shiptype < 3) { ships[gg].meshhalfA = mesh[ships[gg].shiptype - 1].obj.cloneObject(); ships[gg].meshhalfB =
* mesh[ships[gg].shiptype - 1].obj.cloneObject(); ships[gg].meshhalfA.setTransparency(255); ships[gg].meshhalfA.setTransparencyMode(Object3D.TRANSPARENCY_MODE_DEFAULT);
* ships[gg].meshhalfB.setTransparency(255); ships[gg].meshhalfB.setTransparencyMode(Object3D.TRANSPARENCY_MODE_DEFAULT);
*
* } }
*/
ships[gg].mesh[0] = mesh[ships[gg].shiptype - 1].obj.cloneObject();
}
else
{
/*
* if (ships[gg].meshhalfA == null) { if (ships[gg].shiptype < 3) { ships[gg].meshhalfA = mesh[4 + ships[gg].shiptype - 1].obj.cloneObject(); ships[gg].meshhalfB = mesh[4 +
* ships[gg].shiptype - 1].obj.cloneObject(); ships[gg].meshhalfA.setTransparency(255); ships[gg].meshhalfA.setTransparencyMode(Object3D.TRANSPARENCY_MODE_DEFAULT);
* ships[gg].meshhalfB.setTransparency(255); ships[gg].meshhalfB.setTransparencyMode(Object3D.TRANSPARENCY_MODE_DEFAULT);
*
* } }
*/
ships[gg].mesh[0] = mesh[4 + ships[gg].shiptype - 1].obj.cloneObject();
}
ships[gg].mesh[0].build();
ships[gg].mesh[0].strip();
ships[gg].mesh[0].addParent(ships[gg].pivot);
ships[gg].mesh[0].setVisibility(true);
/*
* if (ships[gg].meshhalfA != null) { ships[gg].meshhalfA.build(); ships[gg].meshhalfA.strip(); ships[gg].meshhalfA.addParent(ships[gg].pivot);
* ships[gg].meshhalfA.setVisibility(false); world.addObject(ships[gg].meshhalfA); ships[gg].meshhalfA.setRotationMatrix(ROTATE3DS.getRotationMatrix());
*
* } if (ships[gg].meshhalfB != null) { ships[gg].meshhalfB.build(); ships[gg].meshhalfB.strip(); ships[gg].meshhalfB.addParent(ships[gg].pivot);
* ships[gg].meshhalfB.setVisibility(false); world.addObject(ships[gg].meshhalfB); ships[gg].meshhalfB.setRotationMatrix(ROTATE3DS.getRotationMatrix()); }
*/
world.addObject(ships[gg].mesh[0]);
ships[gg].mesh[0].setRotationMatrix(ROTATE3DS.getRotationMatrix());
ships[gg].pivot.translate(new SimpleVector(keyframe[0].shipdata[gg].x, keyframe[0].shipdata[gg].y, keyframe[0].shipdata[gg].z));
SimpleVector rot = new SimpleVector(0, 0, 1);
ships[gg].pivot.setRotationMatrix(rot.getRotationMatrix());
}
// now read in camera values....
for (int i = 0; i < maxframes; i++)
{
cameraframe[i] = new CameraKeyFrame();
byte0 = in.read();
byte1 = in.read();
byte2 = in.read();
byte3 = in.read();
cameraframe[i].x = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
byte0 = in.read();
byte1 = in.read();
byte2 = in.read();
byte3 = in.read();
cameraframe[i].y = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
byte0 = in.read();
byte1 = in.read();
byte2 = in.read();
byte3 = in.read();
cameraframe[i].z = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
byte0 = in.read();
byte1 = in.read();
byte2 = in.read();
byte3 = in.read();
cameraframe[i].lookx = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
byte0 = in.read();
byte1 = in.read();
byte2 = in.read();
byte3 = in.read();
cameraframe[i].looky = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
byte0 = in.read();
byte1 = in.read();
byte2 = in.read();
byte3 = in.read();
cameraframe[i].lookz = ByteBuffer.wrap(new byte[] { (byte) byte0, (byte) byte1, (byte) byte2, (byte) byte3 }).getFloat();
}
}
}
catch (FileNotFoundException ee)
{
// error!
jumpoutimmediately = true;
failexit = true;
Log.e(TAG, "Replay file not found failexit");
}
catch (IOException e)
{
// TODO Auto-generated catch block
jumpoutimmediately = true;
failexit = true;
Log.e(TAG, "IO Exception in replay file failexit");
e.printStackTrace();
}
finally
{
try
{
in.close();
}
catch (Exception e)
{
Log.e(TAG, "Could not close replay file failexit ");
failexit = true;
}
}
Log.i(TAG, "Completed loading keyframes");
}
public void createallmeshes(final World world)
{
}
public void createspacedebris(final World world)
{
spacedebris = new SpaceDebris[SpaceDebris.MAXDEBRIS];
Bitmap bmp = Bitmap.createBitmap(16, 16, Bitmap.Config.ARGB_8888);
int[] pixels = new int[256];
bmp.getPixels(pixels, 0, 16, 0, 0, 16, 16);
for (j = 0; j < 256; j++)
{
pixels[j] = 0;
}
for (int x = 6; x < 9; x++)
{
for (int y = 6; y < 9; y++)
{
j = x + y * 16;
if (x == 7 || y == 7)
{
if (x == 7 && y == 7)
{
pixels[j] = 255 << 24 | 255 << 16 | 255 << 8 | 255;
}
else
{
pixels[j] = 192 << 24 | 192 << 16 | 192 << 8 | 255;
}
}
}
}
bmp.setPixels(pixels, 0, 16, 0, 0, 16, 16);
Texture tex = new Texture(bmp, true);
TextureManager.getInstance().addTexture("dust", tex);
for (j = 0; j < SpaceDebris.MAXDEBRIS; j++)
{
spacedebris[j] = new SpaceDebris(world, j);
spacedebris[j].mesh = new Object3D[1];
if (j == 0)
{
spacedebris[j].mesh[0] = new Object3D(2);
spacedebris[j].mesh[0].addTriangle(new SimpleVector(0, 0, 0), 0, 0, new SimpleVector(0, 1.25, 0), (float) 0.5, 1, new SimpleVector(1.25, 0, 0), 1, 0);
spacedebris[j].mesh[0].setTexture("dust");
spacedebris[j].mesh[0].setTransparencyMode(Object3D.TRANSPARENCY_MODE_DEFAULT);
spacedebris[j].mesh[0].setTransparency(250);
spacedebris[j].mesh[0].setCulling(false);
spacedebris[j].mesh[0].build();
spacedebris[j].mesh[0].strip();
world.addObject(spacedebris[j].mesh[0]);
spacedebris[j].mesh[0].addParent(spacedebris[j].pivot);
}
else
{
spacedebris[j].pivot = spacedebris[0].pivot.cloneObject();
spacedebris[j].mesh[0] = spacedebris[0].mesh[0].cloneObject();
try
{
spacedebris[j].mesh[0].build();
spacedebris[j].mesh[0].strip();
}
catch (Exception e)
{
}
spacedebris[j].mesh[0].addParent(spacedebris[j].pivot);
world.addObject(spacedebris[j].mesh[0]);
}
spacedebris[j].mesh[0].setVisibility(true);
spacedebris[j].pivot.translate(spacedebris[j].getrandomposition());
}
}
public void createlasertex()
{
InputStream intex1 = null;
try
{
intex1 = assets.open("effects/lightgreenbeam.png");
Texture gtex = new Texture(intex1);
TextureManager.getInstance().addTexture("greenbeam", gtex);
}
catch (IOException e)
{
Log.e(TAG, "Error opening texture for green laser");
e.printStackTrace();
}
finally
{
try
{
intex1.close();
}
catch (Exception e)
{
Log.e(TAG, "Error closing intex1");
}
}
intex1 = null;
try
{
intex1 = assets.open("effects/redbeam.png");
Texture gtex = new Texture(intex1);
TextureManager.getInstance().addTexture("redbeam", gtex);
}
catch (IOException e)
{
Log.e(TAG, "Error opening texture for red laser");
e.printStackTrace();
}
finally
{
try
{
intex1.close();
}
catch (Exception e)
{
Log.e(TAG, "Error closing intex1");
}
}
intex1 = null;
try
{
intex1 = assets.open("effects/purplebeam.png");
Texture gtex = new Texture(intex1);
TextureManager.getInstance().addTexture("purplebeam", gtex);
}
catch (IOException e)
{
Log.e(TAG, "Error opening texture for purple laser");
e.printStackTrace();
}
finally
{
try
{
intex1.close();
}
catch (Exception e)
{
Log.e(TAG, "Error closing intex1");
}
}
intex1 = null;
try
{
intex1 = assets.open("effects/bluebeam.png");
Texture gtex = new Texture(intex1);
TextureManager.getInstance().addTexture("bluebeam", gtex);
}
catch (IOException e)
{
Log.e(TAG, "Error opening texture for bluebeam");
e.printStackTrace();
}
finally
{
try
{
intex1.close();
}
catch (Exception e)
{
Log.e(TAG, "Error closing intex1");
}
}
intex1 = null;
try
{
intex1 = assets.open("effects/yellowbeam.png");
Texture gtex = new Texture(intex1);
TextureManager.getInstance().addTexture("yellowbeam", gtex);
}
catch (IOException e)
{
Log.e(TAG, "Error opening texture for yellowbeam");
e.printStackTrace();
}
finally
{
try
{
intex1.close();
}
catch (Exception e)
{
Log.e(TAG, "Error closing intex1");
}
}
}
public boolean readfrominput(String input)
{
// initialise all ships etc....positions, weapon loadouts etc etc...
try
{
String[] shipstr = input.split(":");
// int team0 = -1;
int team1 = -1;
// int ateam = -1;
// int dteam = -1;
if (shipstr != null)
{
if (shipstr.length > 0)
{
// System.out.println("Shipstr length:"+shipstr.length);
int size = shipstr.length;
if (size > 32)
{
size = 32;
}
for (int s = 0; s < size; s++)
{
// System.out.println("Ship S:"+s);
Ship ship = null;
if (ships[s] == null)
{
ship = new Ship();
}
else
{
ship = ships[s];
}
String[] fields = shipstr[s].split("\\|");
if (fields != null)
{
// System.out.println("Ship fields length:"+fields.length);
// for(int i=0;i<fields.length;i++)
// {
ship.id = Integer.decode(fields[0]);
ship.shiptype = Integer.decode(fields[1]);
ship.hp = (int) Float.parseFloat(fields[2]);
ship.team = Integer.decode(fields[3]);
if (s < 16)
{
// ateam = ship.team;
ateami = ship.team;
}
else
{
dteami = ship.team;
// dteam = ship.team;
}
ship.sizetype = Integer.decode(fields[4]);
ship.maxvel = Float.parseFloat(fields[5]);
ship.minvel = Float.parseFloat(fields[6]);
ship.maxaccel = Float.parseFloat(fields[7]);
ship.minaccel = Float.parseFloat(fields[8]);
// ship.maxrotaccel = Float.parseFloat(fields[8]);
// ship.minrotaccel = Float.parseFloat(fields[9]);
ship.fullhp = (int) Float.parseFloat(fields[9]);
// ship.hp = ship.fullhp;
ship.cputime = Integer.decode(fields[12]);
ship.cpuindex = Integer.decode(fields[12]);
ship.powerlevel = 100;// Integer.decode(fields[13]);
ship.rechargerate = 1;// Integer.decode(fields[14]);
int offset = 13;
for (int j = 0; j < 16; j++)
{
ship.aislidervalues[j] = Integer.decode(fields[offset]);
offset++;
}
int numh = Integer.decode(fields[offset]);
offset++;
ship.hardpoints = new HardPoint[numh];
for (int j = 0; j < numh; j++)
{
ship.hardpoints[j] = new HardPoint();
ship.hardpoints[j].x = Float.parseFloat(fields[offset]);
ship.hardpoints[j].y = Float.parseFloat(fields[offset + 1]);
ship.hardpoints[j].z = Float.parseFloat(fields[offset + 2]);
ship.hardpoints[j].dx = Float.parseFloat(fields[offset + 3]);
ship.hardpoints[j].dy = Float.parseFloat(fields[offset + 4]);
ship.hardpoints[j].dz = Float.parseFloat(fields[offset + 5]);
ship.hardpoints[j].hp = Integer.decode(fields[offset + 6]);
ship.hardpoints[j].mintargetingdot = Float.parseFloat(fields[offset + 7]);
ship.hardpoints[j].weapon = new Weapon();
ship.hardpoints[j].weapon.damageperhit = Float.parseFloat(fields[offset + 8]);// Integer.decode(fields[offset+8]);
if (ship.hardpoints[j].weapon.damageperhit < 1)
{
ship.hardpoints[j].weapon.damageperhit = 1;
}
ship.hardpoints[j].weapon.cooldowntimerequired = Integer.decode(fields[offset + 9]);
ship.hardpoints[j].weapon.cooldownindex = Integer.decode(fields[offset + 10]);
ship.hardpoints[j].weapon.ammolimit = Integer.decode(fields[offset + 11]);
ship.hardpoints[j].weapon.ammoleft = Integer.decode(fields[offset + 12]);
ship.hardpoints[j].weapon.powerdrain = Integer.decode(fields[offset + 13]);
ship.hardpoints[j].weapon.locktimerequired = Integer.decode(fields[offset + 14]);
ship.hardpoints[j].weapon.locktimeindex = Integer.decode(fields[offset + 15]);
ship.hardpoints[j].weapon.baselifetime = Integer.decode(fields[offset + 16]);
if (Integer.decode(fields[offset + 17]) == 1)
{
ship.hardpoints[j].weapon.isbeam = true;
// ship.hardpoints[j].weapon.baselifetime =
// 2; //really short lived...
}
else
{
ship.hardpoints[j].weapon.isbeam = false;
}
if (Integer.decode(fields[offset + 18]) == 1)
{
ship.hardpoints[j].weapon.ismissile = true;
}
else
{
ship.hardpoints[j].weapon.ismissile = false;
}
if (Integer.decode(fields[offset + 19]) == 1)
{
ship.hardpoints[j].weapon.isguided = true;
}
else
{
ship.hardpoints[j].weapon.isguided = false;
}
ship.hardpoints[j].weapon.guidedturnrate = Float.parseFloat(fields[offset + 20]);
ship.hardpoints[j].weapon.muzzlevel = Float.parseFloat(fields[offset + 21]);
ship.hardpoints[j].weapon.optimumrange = Float.parseFloat(fields[offset + 22]);
ship.hardpoints[j].weapon.weapontype = Integer.decode(fields[offset + 23]);
// tractors and disruptors
if (ship.hardpoints[j].weapon.weapontype == 5 || ship.hardpoints[j].weapon.weapontype == 6)
{
ship.hardpoints[j].weapon.isbeam = true;
}
if (ship.hardpoints[j].weapon.weapontype == 6 && ship.hardpoints[j].weapon.baselifetime >= 3)
{
ship.hardpoints[j].weapon.isbeam = false;
}
// plasma.....kind of counts as a missile....
if (ship.hardpoints[j].weapon.weapontype == 4)
{
ship.hardpoints[j].weapon.ismissile = true;
ship.hardpoints[j].weapon.isguided = false;
}
// swarmer missile...
if (ship.hardpoints[j].weapon.weapontype == 7)
{
ship.hardpoints[j].weapon.ismissile = true;
ship.hardpoints[j].weapon.isguided = true;
ship.hardpoints[j].weapon.guidedturnrate = 0.05f; // very
// agile
// little
// missiles...
}
offset += 24;
}
ship.xr = Float.parseFloat(fields[offset]);
// System.out.println("Shipxr as a check:"+ship.xr);
offset++;
if (Integer.decode(fields[offset]) == 1)
{
ship.iscap = true;
}
else
{
ship.iscap = false;
}
offset++;
if (Integer.decode(fields[offset]) == 1)
{
ship.isace = true;
}
else
{
ship.isace = false;
}
offset++;
if (fields[offset].equals("ZZ"))
{
// System.out.println("Data good!");
}
else
{
// System.out.println("Data bad:"+s);
return false;
}
if (ship.team == team1)
{
// defenders...
// some kind of formation system would be lovely
// eventually!
// for now we use this....oh? :-(
ship.x = (s % 4) * 150;
ship.y = ((s - s % 4) / 4) * 150;
ship.z = -2500;
if (ship.shiptype == 4)
{
ship.z += 300;
}
if (ship.shiptype == 1)
{
ship.y -= -250f;
}
if (ship.shiptype > 2)
{
ship.x -= 225f;
ship.x *= 3f;
if (ship.shiptype == 3)
{
ship.y *= -1;
}
}
ship.vx = 0;
ship.vy = 0;
ship.vz = (ship.minvel + ship.maxvel) * 0.5f;
}
else
{
// attackers...
ship.x = (s % 4) * 150;
ship.y = ((s - s % 4) / 4) * 150;
ship.z = 3700;
if (ship.shiptype == 4)
{
ship.z -= 300;
}
if (ship.shiptype == 1)
{
ship.y -= -250f;
}
if (ship.shiptype > 2)
{
ship.x -= 225f;
ship.x *= 3f;
if (ship.shiptype == 3)
{
ship.y *= -1;
}
}
ship.vx = 0;
ship.vy = 0;
ship.vz = -(ship.minvel + ship.maxvel) * 0.5f;
}
// }
}
ships[s] = ship;
}
}
}
return true;
}
catch (Exception e)
{
return false;
}
}
public void logmemoryusage()
{
try
{
long totalmemory = Runtime.getRuntime().totalMemory();
Log.d(TAG, "Total MEM:" + totalmemory);
long freememory = Runtime.getRuntime().freeMemory();
Log.d(TAG, "Free MEM:" + freememory);
Log.d(TAG, "Memory usage:" + (totalmemory - freememory));
}
catch (Exception e)
{
Log.e(TAG, "Error getting memory usage");
}
}
}