/**
* Draws all gameobjects on the canvas
*
* @param canvas
*/
private void drawCanvas(Canvas canvas) {
bg.draw(canvas);
for (Obstacle r : obstacles) {
r.draw(canvas);
}
for (PowerUp p : powerUps) {
p.draw(canvas);
}
player.draw(canvas);
fg.draw(canvas);
pauseButton.draw(canvas);
// Score Text
Paint paint = new Paint();
paint.setColor(Color.BLACK);
paint.setTextSize(getScoreTextMetrics());
canvas.drawText(
game.getResources().getString(R.string.onscreen_score_text)
+ " "
+ game.accomplishmentBox.points
+ " / "
+ game.getResources().getString(R.string.onscreen_coin_text)
+ " "
+ game.coins,
0,
getScoreTextMetrics(),
paint);
}
@Test
public void picksHealth() {
// jogador apanha um bonus de vida (ganha vida)
Player p = new Player(true);
int life = p.getLifepoints();
// cria objeto que da a vida ao player
Health h = new Health(p.getX(), p.getY(), true);
Obstacle ob = new Obstacle((int) p.getX(), (int) p.getY(), 20, true);
// verifica se apanha
assertTrue(h.colide(p));
h.caught(p, true);
// verifica se nao ganha vida, pois tem a vida cheia
assertEquals(life, p.getLifepoints());
// perde vida
ob.damage(p);
int life1 = p.getLifepoints();
assertTrue(life > life1);
// ganha vida
h.caught(p, true);
assertTrue(life1 < p.getLifepoints());
}
public void draw() {
background(255);
// Turn off highlighting for all obstalces
for (int i = 0; i < obstacles.size(); i++) {
Obstacle o = (Obstacle) obstacles.get(i);
o.highlight(false);
}
// Act on all boids
for (int i = 0; i < boids.size(); i++) {
Boid b = (Boid) boids.get(i);
b.avoid(obstacles);
b.run();
}
// Display the obstacles
for (int i = 0; i < obstacles.size(); i++) {
Obstacle o = (Obstacle) obstacles.get(i);
o.display();
}
// Instructions
textFont(f);
fill(0);
text(
"Hit space bar to toggle debugging lines.\nClick the mouse to generate a new boids.",
10,
height - 30);
}
/**
* Draws everything normal, except the player will only be drawn, when the parameter is true
*
* @param drawPlayer
*/
private void drawBlinking(boolean drawPlayer) {
while (!holder.getSurface().isValid()) {
/*wait*/
}
Canvas canvas = holder.lockCanvas();
bg.draw(canvas);
for (Obstacle r : obstacles) {
r.draw(canvas);
}
for (PowerUp p : powerUps) {
p.draw(canvas);
}
if (drawPlayer) {
player.draw(canvas);
}
fg.draw(canvas);
pauseButton.draw(canvas);
// Score Text
Paint paint = new Paint();
paint.setColor(Color.BLACK);
paint.setTextSize(getScoreTextMetrics());
canvas.drawText(
game.getResources().getString(R.string.onscreen_score_text)
+ " "
+ game.accomplishmentBox.points
+ " / "
+ game.getResources().getString(R.string.onscreen_coin_text)
+ " "
+ game.coins,
0,
getScoreTextMetrics(),
paint);
holder.unlockCanvasAndPost(canvas);
}
/**
* Verifie si l'oiseau est toujours dans l'ecran et s'il ne touche pas un obstacle (change sa
* couleur dans le cas contraire)
*
* @return si l'animation doit se poursuivre ou non
*/
public boolean poursuiteAnim() {
for (Obstacle i : listeCorps) {
for (int cp = (listeCorps.indexOf(i)); cp < listeCorps.size(); cp++) {
if (i.collision()) {
try {
etat = 1;
img = ImageIO.read(new File("ressources/oiseau_vener_collision.png"));
} catch (Exception e) {
e.printStackTrace();
}
if (!i.equals(listeCorps.get(cp))) i.appliquerCollision(listeCorps.get(cp));
setChanged();
notifyObservers();
return false;
}
}
}
return (oiseau.getCorpsPosX() + Constantes.DIAMETRE) > Constantes.BORD_GAUCHE
&& (oiseau.getCorpsPosX() + Constantes.DIAMETRE) < Constantes.BORD_DROIT
&& (oiseau.getCorpsPosY() + Constantes.DIAMETRE) > Constantes.PLAFOND
&& (oiseau.getCorpsPosY() + Constantes.DIAMETRE) < Constantes.SOL;
}
private boolean interact(Obstacle obstacle) {
ArrayList<Point> ptList = new ArrayList<Point>();
Point[] pts = obstacle.getPoints();
for (Point p : pts) {
double distance = p.distance(msc.x, msc.y);
if (distance > 25 && distance < 75) {
ptList.add(p);
}
}
if (ptList.size() > 0) {
long t = System.currentTimeMillis();
int attempts = 0;
while (attempts < 5 && Timing.timeFromMark(t) < 5000) {
int r = General.random(0, ptList.size() - 1);
Point p = ptList.get(r);
Mouse.move(p);
if (waitUptext(obstacle.getUptext(), 200)) {
Mouse.click(1);
return true;
}
attempts++;
}
}
return false;
}
/** Test of getPosition method, of class Obstacle. */
@Test
public void testGetPosition() {
Obstacle instance =
new Obstacle(ObstacleType.KEY, "obstacleKey", new Point2D.Double(0, 900), level);
Point2D expResult = new Point2D.Double(0, 500);
Point2D result = instance.getPosition();
assertEquals("Obstacle's getPosition returns something unexpected", expResult, result);
}
public void render(Obstacle obstacle) {
Vector adjustedPosition = obstacle.position().add(viewPoint);
graphics.drawOval(
(int) (adjustedPosition.x() - obstacle.boundingRadius()),
(int) (adjustedPosition.y() - obstacle.boundingRadius()),
(int) (obstacle.boundingRadius() * 2),
(int) (obstacle.boundingRadius() * 2));
}
/** Test of setPosition method, of class Obstacle. */
@Test
public void testSetPosition() {
Point2D position = new Point2D.Double(600, 600);
Obstacle instance =
new Obstacle(ObstacleType.DOOR, "obstacleDoor", new Point2D.Double(1400, 0), level);
instance.setPosition(position);
assertEquals("Obstacle setPosition isn't correct", position, instance.getPosition());
}
public void avoid(ArrayList obstacles) {
// Make a vector that will be the position of the object
// relative to the Boid rotated in the direction of boid's velocity
PVector closestRotated = new PVector(sight + 1, sight + 1);
float closestDistance = 99999;
Obstacle avoid = null;
// Let's look at each obstacle
for (int i = 0; i < obstacles.size(); i++) {
Obstacle o = (Obstacle) obstacles.get(i);
float d = PVector.dist(loc, o.loc);
PVector dir = vel.get();
dir.normalize();
PVector diff = PVector.sub(o.loc, loc);
// Now we use the dot product to rotate the vector that points from boid to obstacle
// Velocity is the new x-axis
PVector rotated = new PVector(diff.dot(dir), diff.dot(getNormal(dir)));
// Is the obstacle in our path?
if (PApplet.abs(rotated.y) < (o.radius + r)) {
// Is it the closest obstacle?
if ((rotated.x > 0) && (rotated.x < closestRotated.x)) {
closestRotated = rotated;
avoid = o;
}
}
}
// Can we actually see the closest one?
if (PApplet.abs(closestRotated.x) < sight) {
// The desired vector should point away from the obstacle
// The closer to the obstacle, the more it should steer
PVector desired =
new PVector(closestRotated.x, -closestRotated.y * sight / closestRotated.x);
desired.normalize();
desired.mult(closestDistance);
desired.limit(maxspeed);
// Rotate back to the regular coordinate system
rotateVector(desired, vel.heading2D());
// Draw some debugging stuff
if (debug) {
stroke(0);
line(loc.x, loc.y, loc.x + desired.x * 10, loc.y + desired.y * 10);
avoid.highlight(true);
}
// Apply Reynolds steering rules
desired.sub(vel);
desired.limit(maxforce);
acc.add(desired);
}
}
private void generateObstacles() {
for (int i = 0; i < 5; i++) {
Obstacle obs = obs_generator.generate();
obs.moveAt(new Vector2(0, generated_world_max_height));
obs.setVelocity(0, SCROLL_SPEED_Y);
obstacles.add(obs);
generated_world_max_height += obs.getHeight();
}
}
/** Checks whether a obstacle is passed. */
private void checkPasses() {
for (Obstacle o : obstacles) {
if (o.isPassed()) {
if (!o.isAlreadyPassed) {
o.onPass();
createPowerUp();
}
}
}
}
/** Applique les forces et enregistre la trajectoire de l'oiseau */
public static void trame() {
for (Obstacle o : AngryBirdsModel.listeCorps) {
for (int cp = (listeCorps.indexOf(o)); cp < listeCorps.size(); cp++) {
System.out.println(
"Obstacle "
+ o
+ " : "
+ o.getCorpsPosX()
+ ","
+ o.getCorpsPosY()
+ " - "
+ o.getCorpsSpeedX()
+ ","
+ o.getCorpsSpeedY());
if (o.collision()) {
if (!o.equals(listeCorps.get(cp))) o.appliquerCollision(listeCorps.get(cp));
}
o.mouvement();
}
}
oiseau.setCorpsSpeedY(oiseau.getCorpsSpeedY() + 0.1); // (oiseau.poids/1000);
oiseau.setCorpsPosX(oiseau.getCorpsPosX() + oiseau.getCorpsSpeedX());
oiseau.setCorpsPosY(oiseau.getCorpsPosY() + oiseau.getCorpsSpeedY());
}
public void moveObstacles() {
int res = obs1.moveLeft();
if (obs2 != null) obs2.moveLeft();
if (res == 1 && obs2 == null) {
obs2 = createObstacle();
}
if (res == 2) {
obs1 = obs2;
obs2 = null;
}
}
private void updateObstacles(float deltaTime) {
Iterator<Obstacle> it = obstacles.iterator();
while (it.hasNext()) {
Obstacle ob = it.next();
if (ob.getPosition().y < current_height - 200) {
it.remove();
} else {
ob.update(deltaTime);
ob.setVelocity(0, SCROLL_SPEED_Y);
}
}
}
public boolean contains(Obstacle o) {
// ---------------------------------------------------
// Not to add two obstacle for same location
// --------------------------------------------------
double distanceY = o.getCenterY() - centerY;
double distanceX = o.getCenterX() - centerX;
double distanceWidth = (o.getWidth() + width) / 2;
double distanceHeight = (o.getHeight() + height) / 2;
if (distanceWidth <= distanceX && distanceHeight <= distanceY) {
return true;
} else return false;
}
private void checkCollisions() {
if (mainElectron.position.x - mainElectron.radius <= 0
|| mainElectron.position.x + mainElectron.radius >= WORLD_WIDTH) {
// collision with the shields of the capacitor
state = State.GAME_END;
listener.gameEnded();
}
// Check collisions with obstacles
for (Obstacle obs : obstacles) {
if (obs.collidesWith(mainElectron.bounds)) {
state = State.GAME_END;
listener.gameEnded();
}
}
}
@Test
public void colidesWithObstacle() {
// jogador colide com um obstaculo (perde vida)
Player p = new Player(true);
int life = p.getLifepoints();
Obstacle ob = new Obstacle((int) p.getX(), (int) p.getY(), life, true);
// verifica se colide
assertTrue(ob.colide(p));
ob.damage(p);
// verifica se perde vida
assertTrue(life > p.getLifepoints());
}
/** Checks collisions and performs the action */
private void checkCollision() {
for (Obstacle o : obstacles) {
if (o.isColliding(player)) {
o.onCollision();
gameOver();
}
}
for (int i = 0; i < powerUps.size(); i++) {
if (this.powerUps.get(i).isColliding(player)) {
this.powerUps.get(i).onCollision();
this.powerUps.remove(i);
i--;
}
}
if (player.isTouchingEdge()) {
gameOver();
}
}
/** Update sprite movements */
private void move() {
for (Obstacle o : obstacles) {
o.setSpeedX(-getSpeedX());
o.move();
}
for (PowerUp p : powerUps) {
p.move();
}
bg.setSpeedX(-getSpeedX() / 2);
bg.move();
fg.setSpeedX(-getSpeedX() * 4 / 3);
fg.move();
pauseButton.move();
player.move();
}
// GAMEPLAY
@Test
public void gameOver() {
// jogador fica sem vida
Player p = new Player(true);
int life = p.getLifepoints();
// cria obstaculo que tira a vida toda ao player
Obstacle ob = new Obstacle((int) p.getX(), (int) p.getY(), life, true);
// verifica se colide
assertTrue(ob.colide(p));
ob.damage(p);
// verifica se perde vida toda
assertTrue(life > p.getLifepoints());
assertEquals(p.getLifepoints(), 0);
}
@Override
public void onPaint(Graphics g) {
g.setColor(new Color(60, 60, 60));
g.fillRect(4, 4, 275, 100);
g.setColor(Color.WHITE);
g.drawString("JJ's Gnome Agility", 10, 20);
g.drawString("My position: " + Player.getPosition(), 10, 40);
g.drawString("Animation ID: " + Player.getAnimation(), 10, 60);
g.drawString("Uptext: " + Game.getUptext(), 10, 80);
Obstacle ob = getNearestObstacle();
g.drawString("Nearest obstacle: " + ob, 10, 100);
g.setColor(Color.RED);
Point[] pts = ob.getPoints();
for (Point p : pts) {
g.drawLine(p.x, p.y, p.x, p.y);
}
}
@Test
public void picksInvulnerableBonus() {
// jogador fica invulnerável durante x tempo
Player p = new Player(true);
int life = p.getLifepoints();
Invulnerability ob = new Invulnerability();
Obstacle obj = new Obstacle((int) p.getX(), (int) p.getY(), life, true);
// verifica se apanha
assertTrue(ob.colide(p));
ob.caught(p, true);
// colide com objeto que danifica
obj.damage(p);
// verifica se nao perde vida
assertEquals(life, p.getLifepoints());
}
private Obstacle getNearestObstacle() {
Obstacle[] obstacles = Obstacle.values();
RSTile myPos = Player.getPosition();
double nearest = myPos.distanceToDouble(obstacles[0].getLocation());
int index = 0;
for (int i = 1; i < obstacles.length; i++) {
double distance = obstacles[i].getLocation().distanceToDouble(myPos);
if (distance < nearest) {
nearest = distance;
index = i;
}
}
return obstacles[index];
}
@Override
public void collide(final Vector2D normal, final Obstacle obstacle) {
obstacle.collide(normal, this);
}
// Update method to update the game play
public void update(float dt, float fps) {
FPS = fps;
switch (GameState) {
case 0:
{
// Only if game is not paused
if (!GamePaused) {
bgX -= ScrollSpeed * dt; // Speed of background scrolling
// Reset once reaches 0
if (bgX < -ScreenWidth) {
bgX = 0;
}
// Only when game is active we update the following
if (GameActive) {
SpawnTimer += dt;
timer += dt;
if (timer > 5.f) {
ScrollSpeed += 100;
timer = 0;
}
if (SpawnTimer > SpawnRate) {
FetchObstacle();
SpawnTimer = 0.f;
}
stickman_anim.update(System.currentTimeMillis());
// Adventure mode
if (GameMode == 1) {
Progress_bar.setPosX(Progress_bar.getPosX() + BarSpeed * 0.015f);
if (Progress_bar.getPosX() > DestinationPoint) {
Win = true;
GameActive = false;
}
}
}
// Feedback for game over
if (GameActive == false) {
if (UpdateHighscore && GameMode == 0) {
Vector<Integer> highscores = appPrefs.getHighscore();
Vector<Integer> updatedscores = new Vector<Integer>();
boolean scoreentered = false;
int index = 0;
for (int i = 0; i < highscores.size(); ++i) {
if (score > highscores.get(index) && !scoreentered) {
updatedscores.addElement(score);
scoreentered = true;
} else {
updatedscores.addElement(highscores.get(index));
++index;
}
}
for (int i = 0; i < updatedscores.size(); ++i) {
appPrefs.setHighscore(i, updatedscores.get(i));
}
UpdateHighscore = false;
}
// Vibration feedback
vibrateTime += dt;
if (vibrateTime > MaxVibrateTime) {
stopVibrate();
} else {
startVibrate();
}
}
if (nearestObstacle.isActive()) {
// Detecting user tap for tapping obstacle
if (nearestObstacle.getType() == Obstacle.TYPE.T_TAP && Tapped == true) {
score += 10;
nearestObstacle.setActive(false);
DirectionVector.SetZero();
Tapped = false;
}
// Detecting user swipe direction for direction obstacle
else if (DirectionVector.IsZero() == false
&& Obstacle.fromInteger(ProcessSwipe(DirectionVector))
== nearestObstacle.getType()) {
score += 10;
nearestObstacle.setActive(false);
DirectionVector.SetZero();
}
DirectionVector.SetZero();
}
// Updating game elements
for (int i = 0; i < obstacleList.length; ++i) {
if (obstacleList[i].isActive()) {
obstacleList[i].setPosX(obstacleList[i].getPosX() - ScrollSpeed * dt);
// if out of screen
if (obstacleList[i].getPosX() < 0) {
obstacleList[i].setActive(false);
}
// Only if game is active we check these collisions
if (GameActive == true) {
// Player collision against obstacles
if (CheckCollision(
stickman_anim.getX(),
stickman_anim.getY(),
stickman_anim.getSpriteWidth(),
stickman_anim.getSpriteHeight(),
(int) obstacleList[i].getPosX(),
(int) obstacleList[i].getPosY(),
obstacleList[i].getImgWidth(),
obstacleList[i].getImgHeight())) {
obstacleList[i].setActive(false);
GameActive = false; // Game status set to false
// Enable buttons
Restart_button.setActive(true);
Mainmenu_button.setActive(true);
}
// Get nearest obstacle
if (nearestObstacle.isActive() == false) {
nearestObstacle = obstacleList[i];
} else if (obstacleList[i].getPosX() < nearestObstacle.getPosX()) {
nearestObstacle = obstacleList[i];
}
}
}
}
}
}
break;
}
}
@Override
public boolean onTouchEvent(MotionEvent event) {
// Only process if game is active
if (GameActive && !GamePaused) {
// If the next obstacle is not a tap type check for swipe
if (nearestObstacle.getType() != Obstacle.TYPE.T_TAP && FingerDown == false) {
switch (event.getAction()) {
case MotionEvent.ACTION_DOWN:
{
InitialPos.Set(event.getX(), event.getY());
}
break;
case MotionEvent.ACTION_MOVE:
LastPos.Set(event.getX(), event.getY());
break;
case MotionEvent.ACTION_UP:
DirectionVector.Set(LastPos.operatorMinus(InitialPos));
break;
}
}
// else check for tap
else {
if (event.getAction() == MotionEvent.ACTION_DOWN) {
FingerDown = true;
Tapped = true;
} else if (event.getAction() == MotionEvent.ACTION_UP) {
FingerDown = false;
}
}
// Check if touch pause button
if (event.getAction() == MotionEvent.ACTION_DOWN) {
// If touch pause button
if (CheckTouch(
event.getX(),
event.getY(),
Pause_button.getPosX(),
Pause_button.getPosY(),
(int) Pause_button.getPosX() + Pause_button.getImgWidth(),
(int) Pause_button.getPosY() + Pause_button.getImgHeight())) {
GamePaused = true;
}
}
return true;
} else if (GameActive && GamePaused) {
if (event.getAction() == MotionEvent.ACTION_DOWN) {
if (CheckTouch(
event.getX(),
event.getY(),
Unpause_button.getPosX(),
Unpause_button.getPosY(),
(int) Unpause_button.getPosX() + Unpause_button.getImgWidth(),
(int) Unpause_button.getPosY() + Unpause_button.getImgHeight())) {
GamePaused = false;
}
}
return true;
}
// To process other taps while game is not active
else {
if (event.getAction() == MotionEvent.ACTION_DOWN) {
// If touch restart button
if (CheckTouch(
event.getX(),
event.getY(),
Restart_button.getPosX(),
Restart_button.getPosY(),
(int) Restart_button.getPosX() + Restart_button.getImgWidth(),
(int) Restart_button.getPosY() + Restart_button.getImgHeight())) {
// Restart the game
soundManager.PlaySFX();
Reset();
}
// If touch mainmenu button
else if (CheckTouch(
event.getX(),
event.getY(),
Mainmenu_button.getPosX(),
Mainmenu_button.getPosY(),
(int) Mainmenu_button.getPosX() + Mainmenu_button.getImgWidth(),
(int) Mainmenu_button.getPosY() + Mainmenu_button.getImgHeight())) {
soundManager.PlaySFX();
Intent intent = new Intent();
intent.setClass(getContext(), Mainmenu.class);
intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
getContext().startActivity(intent);
}
}
return true;
}
}
