package com.gebauz.burutaru.game.entities;
import java.util.Vector;
import com.badlogic.gdx.Gdx;
import com.gebauz.bauzoid.graphics.sprite.AtlasSprite;
import com.gebauz.bauzoid.graphics.sprite.AtlasSpriteFrame;
import com.gebauz.bauzoid.graphics.sprite.AtlasSpriteInstance;
import com.gebauz.bauzoid.graphics.sprite.Sprite;
import com.gebauz.bauzoid.graphics.sprite.SpriteParameters;
import com.gebauz.bauzoid.math.MathUtil;
import com.gebauz.bauzoid.math.Matrix4;
import com.gebauz.bauzoid.math.Vector2;
import com.gebauz.bauzoid.math.Vector3;
import com.gebauz.bauzoid.math.Vector4;
import com.gebauz.bauzoid.math.collision.RectElement;
import com.gebauz.bauzoid.math.collision.Shape;
import com.gebauz.bauzoid.math.collision.ShapeInstance;
import com.gebauz.bauzoid.math.collision.ShapeUtil;
import com.gebauz.burutaru.game.GameLogic;
import com.gebauz.burutaru.game.entities.BlobEnemies.Instance;
import com.gebauz.burutaru.game.entities.PowerUps.Type;
public class CarrotEnemies
extends Entity
{
// Constants========================================================================================
public static final float SPRITE_WIDTH =
110;
public static final float SPRITE_HEIGHT = SPRITE_WIDTH/
2;
public static final float ANIM_DURATION = 1.2f
;
// Embedded Types===================================================================================
public class Instance
extends Enemy
{
public float lifeTime =
0;
public boolean isAlive =
false;
public AtlasSpriteInstance spriteInstance =
null;
public Instance
(float _x,
float _y
)
{
super();
//x = _x; y = _y;
isAlive =
true;
lifeTime = 0.0f
;
spriteInstance =
new AtlasSpriteInstance
(getGraphics
(), mCarrotSprite, mCarrotFrames, mCarrotShape
);
spriteInstance.
param.
x = _x
;
spriteInstance.
param.
y = _y
;
spriteInstance.
param.
w = SPRITE_WIDTH
;
spriteInstance.
param.
h = SPRITE_HEIGHT
;
spriteInstance.
param.
pivotX =
0;
spriteInstance.
param.
pivotY = spriteInstance.
param.
h/
2;
spriteInstance.
param.
mirrorX =
true;
spriteInstance.
param.
angle =
45;
}
public void update
(float deltaTime
)
{
super.
update(deltaTime
);
lifeTime += deltaTime
;
//spriteInstance.param.x -= deltaTime * 400;
}
public void render
()
{
float t =
(lifeTime
% ANIM_DURATION
) / ANIM_DURATION
;
int frame = MathUtil.
clamp((int)(t
* mCarrotFrames.
length),
0, mCarrotFrames.
length-
1);
spriteInstance.
renderFrame(frame
);
/*mParams.x = x;
mParams.y = y;
mParams.w = SPRITE_WIDTH;
mParams.h = SPRITE_HEIGHT;
mParams.pivotX = 0;
mParams.pivotY = mParams.h/2;
mParams.mirrorX = true;
//mParams.angle = (lifeTime * 90) % 360;
//mParams.angle = 34;
//mParams.angle = 90;
mCarrotFrames[frame].param.apply(mParams);
mCarrotFrames[frame].render();*/
spriteInstance.
param.
angle =
(lifeTime
* 45) % 360;
float pX =
((RectElement
)spriteInstance.
getShape().
getElement(0)).
x;
float pY =
((RectElement
)spriteInstance.
getShape().
getElement(0)).
y;
float p2X = pX +
((RectElement
)spriteInstance.
getShape().
getElement(0)).
w;
float p2Y = pY
;
float p3X = pX +
((RectElement
)spriteInstance.
getShape().
getElement(0)).
w;
float p3Y = pY +
((RectElement
)spriteInstance.
getShape().
getElement(0)).
h;
float p4X = pX
;
float p4Y = pY +
((RectElement
)spriteInstance.
getShape().
getElement(0)).
h;
//Vector2 p2 = mCarrotFrames[frame].param.transformPoint(p2X, p2Y);
Matrix4 transform = spriteInstance.
param.
getTransform();
Vector4 p = transform.
transform(new Vector4
(pX, pY,
0,
1));
Vector4 p2 = transform.
transform(new Vector4
(p2X, p2Y,
0,
1));
Vector4 p3 = transform.
transform(new Vector4
(p3X, p3Y,
0,
1));
Vector4 p4 = transform.
transform(new Vector4
(p4X, p4Y,
0,
1));
//Gdx.app.log("BLA", "1) " + p2.x + ", " + p2.y + " - " + p.x + ", " + p.y + ", " + p.z + ", " + p.w);
mTester.
param.
x = p.
x;
mTester.
param.
y = p.
y;
/*mTester.param.w = p2.x-p.x;
mTester.param.h = p2.y-p.y;
mTester.param.pivotX = 0;
mTester.param.pivotY = 0;*/
mTester.
param.
w =
4;
mTester.
param.
h =
4;
mTester.
param.
centerPivot();
mTester.
render();
mTester.
param.
x = p2.
x;
mTester.
param.
y = p2.
y;
mTester.
render();
mTester.
param.
x = p3.
x;
mTester.
param.
y = p3.
y;
mTester.
render();
mTester.
param.
x = p4.
x;
mTester.
param.
y = p4.
y;
mTester.
render();
/*getGraphics().getBatch().begin();
mParams.y += 100.0f;
mCarrotFrames[frame].param.apply(mParams);
getGraphics().getBatch().drawSprite(mCarrotFrames[frame]);
getGraphics().getBatch().end();*/
}
/*public boolean checkForHit(float _x, float _y, float w, float h)
{
return (((_x) > (spriteInstance.param.x - SPRITE_WIDTH/2)) &&
((_x) < (spriteInstance.param.x + SPRITE_WIDTH/2)) &&
((_y) > (spriteInstance.param.y - SPRITE_HEIGHT/2)) &&
((_y) < (spriteInstance.param.y + SPRITE_HEIGHT/2)));
}*/
@
Override
public boolean checkHit
(Shape shape, Matrix4 shapeTransform
)
{
// shape is from bullet
Matrix4 myTransform = spriteInstance.
param.
getTransform();
Matrix4.
multiply(myTransform, shapeTransform, myTransform.
getInverse());
return shape.
intersects(spriteInstance.
getShape(), myTransform
);
}
@
Override
public float getX
()
{
return spriteInstance.
param.
x;
}
@
Override
public float getY
()
{
return spriteInstance.
param.
y;
}
}
// Fields===========================================================================================
private Vector<Instance
> mEnemies =
new Vector<Instance
>();
private Shape mCarrotShape =
null;
private AtlasSprite mCarrotSprite =
null;
private AtlasSpriteFrame mCarrotFrames
[] =
null;
private Sprite mTester =
null;
// Methods==========================================================================================
public CarrotEnemies
(GameLogic gameLogic
)
{
super(gameLogic
);
mCarrotSprite =
new AtlasSprite
(getGraphics
(),
"data/textures/carrot.png",
"data/textures/carrot.txt");
mTester =
new Sprite
(getGraphics
(),
"data/textures/tester.png");
}
@
Override
public void initAsync
()
{
mCarrotSprite.
initAsync();
mTester.
initAsync();
}
@
Override
public void init
()
{
mCarrotSprite.
init();
mCarrotFrames = mCarrotSprite.
createSpriteInstances();
mTester.
init();
mCarrotShape = ShapeUtil.
createShapeFromFile("data/textures/carrot.shape");
}
@
Override
public void exit
()
{
mCarrotShape =
null;
mCarrotFrames =
null;
if (mTester
!=
null)
{
mTester.
dispose();
mTester =
null;
}
if (mCarrotSprite
!=
null)
{
mCarrotSprite.
dispose();
mCarrotSprite =
null;
}
}
@
Override
public void update
(float deltaTime
)
{
int i =
0;
while (i
< mEnemies.
size())
{
Instance enemy = mEnemies.
get(i
);
enemy.
update(deltaTime
);
if (!enemy.
isAlive)
{
mEnemies.
remove(i
);
continue;
}
++i
;
}
}
@
Override
public void render
()
{
int i =
0;
while (i
< mEnemies.
size())
{
Instance enemy = mEnemies.
get(i
);
if (enemy.
isAlive)
{
enemy.
render();
}
++i
;
}
}
public void spawn
(float x,
float y
)
{
mEnemies.
add(new Instance
(x, y
));
}
public boolean checkForHit
(Shape shape, Matrix4 transform
)
{
boolean hitFound =
false;
int i =
0;
while (i
< mEnemies.
size())
{
Instance enemy = mEnemies.
get(i
);
if (enemy.
checkHit(shape, transform
))
{
// TODO: unify enemy positioning (with interface or smth);
hitFound =
true;
}
++i
;
}
return hitFound
;
}
/*
public boolean checkForHit(float x, float y, float w, float h)
{
boolean hitFound = false;
int i = 0;
while (i < mEnemies.size())
{
Instance enemy = mEnemies.get(i);
if (enemy.checkForHit(x, y, w, h))
{
//TODO: unify enemy positioning (with interface or smth);
getGameLogic().getExplosions().spawn(enemy.spriteInstance.param.x, enemy.spriteInstance.param.y);
// spawn powerup
// TEMP:
int n = getGame().getRandomInt(1, 10);
if (n == 5)
{
int rand = getGame().getRandomInt(PowerUps.Type.SPEED_UP.ordinal(), PowerUps.Type.MISSILE.ordinal());
getGameLogic().getPowerUps().spawn(enemy.x, enemy.y, Type.values()[rand]);
}
//mEnemies.remove(i);
//hitFound = true;
//continue;
}
++i;
}
return hitFound;
}
*/
// TODO: unify
public boolean getNearestEnemy
(float x,
float y, Vector2 result,
float previousDistanceSqr
)
{
boolean found =
false;
float distanceSqr = previousDistanceSqr
;
for (int i =
0; i
< mEnemies.
size(); i++
)
{
Instance enemy = mEnemies.
get(i
);
if (enemy.
isAlive)
{
float diffX = enemy.
spriteInstance.
param.
x - x
;
float diffY = enemy.
spriteInstance.
param.
y - y
;
float currentDistanceSqr = diffX
*diffX + diffY
*diffY
;
if ((distanceSqr
< 0) ||
(currentDistanceSqr
< distanceSqr
))
{
found =
true;
distanceSqr = currentDistanceSqr
;
result.
x = enemy.
spriteInstance.
param.
x;
result.
y = enemy.
spriteInstance.
param.
y;
}
}
}
return found
;
}
public void fillEnemyList
(Vector<Enemy
> list
)
{
for (int i =
0; i
< mEnemies.
size(); i++
)
{
list.
add(mEnemies.
get(i
));
}
}
// Getters/Setters==================================================================================
}