@Override
public void init(GameContainer gameContainer, StateBasedGame stateBasedGame)
throws SlickException {
this.stateBasedGame = stateBasedGame;
center =
new Dimension(
AsaGame.SOURCE_RESOLUTION.width / 2 - 100, AsaGame.SOURCE_RESOLUTION.height / 2);
resetGame();
tandwiel1 = new Image(Resource.getPath(Resource.TANDWIEL5));
tandwiel2 = new Image(Resource.getPath(Resource.TANDWIEL6));
spinner = new Image(Resource.getPath(Resource.SPINNER));
spinneroverlay = new Image(Resource.getPath(Resource.SPINNER_OVERLAY));
background_spinner = new Image(Resource.getPath(Resource.BACKGROUND_SPINNER));
background_spinner_half = new Image(Resource.getPath(Resource.BACKGROUND_SPINNER_HALF));
background_spinner_half.setAlpha(0.7f);
background = new Image(Resource.getPath(Resource.GAME_BACKGROUND));
selectImage = new Image(Resource.getPath(Resource.SAVE_SCORE));
choise = new Image(Resource.getPath(Resource.MAKE_YOUR_CHOISE));
fontBlack = Resource.getFont(Resource.FONT_SANCHEZ, 30, Color.BLACK);
lens = new Animation();
lens.setLooping(false);
for (int i = 0; i < 33; i++) {
if ((i + "").length() == 1) {
lens.addFrame(new Image(Resource.getPath("LENS/lens1_0000" + i + ".png")), 550 / 33);
} else if ((i + "").length() == 2) {
lens.addFrame(new Image(Resource.getPath("LENS/lens1_000" + i + ".png")), 550 / 33);
}
}
lens.stop();
}
public void render(GameContainer gc, StateBasedGame sbg, Graphics g) throws SlickException {
Instructions.draw(0, 0);
move.draw(450, 120);
slash.draw(450, 200);
baddy.draw(450, 300);
if (slash.getFrame() == 1) {
g.drawImage(new Image("res/Link/Sword (right 2).png"), 490, 200);
}
}
@Override
public void update(GameContainer gc, StateBasedGame sb, float delta) {
Dice dice = ((Dice) owner);
DiceManager dm = DiceManager.getInstance();
if (!dice.isRolling() && !checked) {
// int rand = (int) (Math.random()*6);
// dice.setResult(rand);
dm.checkIfAllDicesAreSet();
anim.setCurrentFrame(numbers.indexOf(dice.getResult() - 1));
anim.stop();
checked = true;
}
}
private void initializeAssets() throws SlickException {
// Maps anlegen
maps.put(0, "Testmap.tmx");
// Sheet für die Bilder der Animation anlegen + Bilder zur Animation
// hinzufügen
playerSheet = new SpriteSheet("res/animations/character_top.png", 130, 120);
playerTop = new Animation();
for (int col = 0; col < 15; ++col) {
playerTop.addFrame(playerSheet.getSprite(col, 0), 80);
}
playerSide = new Animation();
playerSide.addFrame(new Image("res/animations/character_side.png"), 80);
}
@Override
public void render(GameContainer gc, Graphics g2d) throws SlickException {
if (!isAlive) {
animationDead.draw(x, y);
} else if (isJumping) {
animationJump.draw(x, y);
} else {
if (x < 34) {
animationRunLeft.draw(x, y);
} else {
animationRunRight.draw(x, y);
}
}
}
@Override
public void update(long currentFrame) {
// Check for moving
if (!_myState.moving) {
// Check for destroy
if (_animation.isStopped()) {
_level.getLogicManager().detachLogic(this);
}
return;
}
super.update(currentFrame);
// Check for squash grunts / spiders
for (CellLogic cell : _level.getCellManager().getCollisionsWith(this, 16, currentFrame)) {
// Check for grunt
try {
Grunt grunt = (Grunt) cell;
grunt.getBehaviour().exit("Squash");
} catch (Exception e) {
}
// Check for spider
try {
Spider spider = (Spider) cell;
spider.squash(currentFrame);
} catch (Exception e) {
}
}
}
@Override
public void render(Graphics g, long time) {
// Render the position of the ball
renderPosition(time, 20);
// Draw the ball
_animation.draw(_screen.x(), _screen.y());
}
public Player(
Image[] framesRight,
Image[] framesLeft,
Image[] jumpFrames,
Image[] deadFrames,
BasicGame game) {
this.animationRunRight = new Animation(framesRight, 100);
this.animationRunLeft = new Animation(framesLeft, 100);
this.animationJump = new Animation(jumpFrames, 75);
this.animationDead = new Animation(deadFrames, 75);
border =
new Circle(
x + animationRunRight.getWidth() / 2,
y + animationRunRight.getHeight() / 2,
animationRunRight.getWidth() / 2);
isOnLeftSide = true;
isAlive = true;
this.game = game;
}
/* */ public Animation copy()
/* */ {
/* 672 */ Animation copy = new Animation();
/* */
/* 674 */ copy.spriteSheet = this.spriteSheet;
/* 675 */ copy.frames = this.frames;
/* 676 */ copy.autoUpdate = this.autoUpdate;
/* 677 */ copy.direction = this.direction;
/* 678 */ copy.loop = this.loop;
/* 679 */ copy.pingPong = this.pingPong;
/* 680 */ copy.speed = this.speed;
/* */
/* 682 */ return copy;
/* */ }
private Animation parseImagestripAnimations(
Scanner cmdScanner, ImageStrip imgStrip, int frameDuration) {
int firstFrameCol, lastFrameCol;
if (cmdScanner.hasNextBoolean()) {
firstFrameCol = 0;
lastFrameCol = imgStrip.getCols();
} else {
firstFrameCol = cmdScanner.nextInt();
lastFrameCol = cmdScanner.nextInt();
}
boolean loop = cmdScanner.nextBoolean();
List<Image> result = new ArrayList<Image>();
for (int col = firstFrameCol; col < lastFrameCol && col < imgStrip.getCols(); col++) {
result.add(imgStrip.getSubImage(col));
}
Animation anim = new Animation(result.toArray(new Image[result.size()]), frameDuration);
anim.setAutoUpdate(false);
anim.setLooping(loop);
return anim;
}
public Player(
SpriteSheet runSheetLeft,
SpriteSheet runSheetRight,
SpriteSheet deadSheet,
SpriteSheet jumpSheet,
BasicGame game) {
this.animationRunLeft = new Animation(runSheetLeft, 100);
this.animationRunRight = new Animation(runSheetRight, 100);
this.animationJump = new Animation(jumpSheet, 75);
this.animationDead = new Animation(deadSheet, 150);
this.animationDead.setLooping(false);
this.animationDead.setCurrentFrame(0);
border =
new Circle(
x + animationRunRight.getWidth() / 2,
y + animationRunRight.getHeight() / 2,
animationRunRight.getWidth() / 2);
isOnLeftSide = true;
isAlive = true;
this.game = game;
}
public void render(GameContainer gc, StateBasedGame sbg, Graphics g) throws SlickException {
camera.centerOn((int) Player.x, (int) Player.y);
camera.drawMap();
camera.translateGraphics();
// it helps to add status reports to see what's going on
// but it gets old quickly
// System.out.println("Current X: " +player.x + " \n Current Y: "+ y);
sprite.draw((int) Player.x, (int) Player.y);
// g.drawString("x: " + (int)player.x + "y: " +(int)player.y , player.x, player.y - 10);
g.drawString("Health: " + Player.health, camera.cameraX + 10, camera.cameraY + 10);
g.drawString("speed: " + (int) (Player.speed * 10), camera.cameraX + 10, camera.cameraY + 25);
// g.draw(player.rect);
g.drawString("time passed: " + counter / 1000, camera.cameraX + 600, camera.cameraY);
// moveenemies();
for (itemwin w : stuffwin) {
if (w.isvisible) {
w.currentImage.draw(w.x, w.y);
// draw the hitbox
// g.draw(w.hitbox);
}
}
for (Enemy e : monster) {
// System.out.println("The current selection is: " +e.currentanime);
e.currentanime.draw(e.Bx, e.By);
}
}
/**
* @see org.newdawn.slick.BasicGame#render(org.newdawn.slick.GameContainer,
* org.newdawn.slick.Graphics)
*/
@Override
public void render(GameContainer container, Graphics g) throws SlickException {
g.scale(2, 2);
g.fillRect(0, 0, 800, 600, back, 0, 0);
g.resetTransform();
g.drawImage(image, 100, 100);
image.draw(100, 200, 80, 200);
font.drawString(100, 200, "Text Drawn before the callable");
SlickCallable callable =
new SlickCallable() {
@Override
protected void performGLOperations() throws SlickException {
renderGL();
}
};
callable.call();
homer.draw(450, 250, 80, 200);
font.drawString(150, 300, "Text Drawn after the callable");
}
@Override
public void render(GameContainer gc, StateBasedGame sb, Graphics gr) {
Vector2f pos = owner.getPosition();
anim.draw(pos.x, pos.y);
}
public void update(GameContainer gc, StateBasedGame sbg, int delta) throws SlickException {
counter += delta;
Input input = gc.getInput();
float fdelta = delta * Player.speed;
Player.setpdelta(fdelta);
double rightlimit = (forestMap.getWidth() * SIZE) - (SIZE * 0.75);
// System.out.println("Right limit: " + rightlimit);
float projectedright = Player.x + fdelta + SIZE;
boolean cangoright = projectedright < rightlimit;
// there are two types of fixes. A kludge and a hack. This is a kludge.
if (input.isKeyDown(Input.KEY_UP)) {
sprite = proup;
float fdsc = (float) (fdelta - (SIZE * .15));
if (!(isBlocked(Player.x, Player.y - fdelta)
|| isBlocked((float) (Player.x + SIZE + 1.5), Player.y - fdelta))) {
sprite.update(delta);
// The lower the delta the slower the sprite will animate.
Player.y -= fdelta;
}
} else if (input.isKeyDown(Input.KEY_DOWN)) {
sprite = prodown;
if (!isBlocked(Player.x, Player.y + SIZE + fdelta)
|| !isBlocked(Player.x + SIZE - 1, Player.y + SIZE + fdelta)) {
sprite.update(delta);
Player.y += fdelta;
}
} else if (input.isKeyDown(Input.KEY_LEFT)) {
sprite = proleft;
if (!(isBlocked(Player.x - fdelta, Player.y)
|| isBlocked(Player.x - fdelta, Player.y + SIZE - 1))) {
sprite.update(delta);
Player.x -= fdelta;
}
} else if (input.isKeyDown(Input.KEY_RIGHT)) {
sprite = proright;
// the boolean-kludge-implementation
if (cangoright
&& (!(isBlocked(Player.x + SIZE + fdelta, Player.y)
|| isBlocked(Player.x + SIZE + fdelta, Player.y + SIZE - 1)))) {
sprite.update(delta);
Player.x += fdelta;
} // else { System.out.println("Right limit reached: " +
// rightlimit);}
}
Player.rect.setLocation(Player.getplayershitboxX(), Player.getplayershitboxY());
for (itemwin w : stuffwin) {
if (Player.rect.intersects(w.hitbox)) {
// System.out.println("yay");
if (w.isvisible) {
w.isvisible = false;
makevisible();
sbg.enterState(3, new FadeOutTransition(Color.black), new FadeInTransition(Color.black));
}
}
}
for (Enemy m : monster) {
if (Player.rect.intersects(m.ahitbox)) {
// System.out.println("yay");
if (m.isvisible) {
Player.health -= 1000;
}
}
}
Player.health = 1000;
if (Player.health <= 0) {
makevisible();
sbg.enterState(2, new FadeOutTransition(Color.black), new FadeInTransition(Color.black));
}
}
Enemy(int a, int b) throws SlickException {
Bx = a;
By = b;
hitboxX = this.getskhitboxX();
hitboxY = this.getskhitboxY();
rect = new Rectangle(hitboxX, hitboxY, width, height);
int BHealth;
boolean isBAlive = true;
canmove = true;
currentanime = skwait;
id = ++numberOfEnemies;
this.mydirection = Direction.WAIT;
SpriteSheet skeletonSS = new SpriteSheet("res/enemy.png", 64, 64, 0);
skup = new Animation();
skup.setAutoUpdate(true);
skup.addFrame(skeletonSS.getSprite(0, 8), 75);
skup.addFrame(skeletonSS.getSprite(1, 8), 75);
skup.addFrame(skeletonSS.getSprite(2, 8), 75);
skup.addFrame(skeletonSS.getSprite(3, 8), 75);
skup.addFrame(skeletonSS.getSprite(4, 8), 75);
skup.addFrame(skeletonSS.getSprite(5, 8), 75);
skup.addFrame(skeletonSS.getSprite(6, 8), 75);
skup.addFrame(skeletonSS.getSprite(7, 8), 75);
skup.addFrame(skeletonSS.getSprite(8, 8), 75);
skdown = new Animation();
skdown.setAutoUpdate(false);
skdown.addFrame(skeletonSS.getSprite(0, 10), 75);
skdown.addFrame(skeletonSS.getSprite(1, 10), 75);
skdown.addFrame(skeletonSS.getSprite(2, 10), 75);
skdown.addFrame(skeletonSS.getSprite(3, 10), 75);
skdown.addFrame(skeletonSS.getSprite(4, 10), 75);
skdown.addFrame(skeletonSS.getSprite(5, 10), 75);
skdown.addFrame(skeletonSS.getSprite(6, 10), 75);
skdown.addFrame(skeletonSS.getSprite(7, 10), 75);
skdown.addFrame(skeletonSS.getSprite(8, 10), 75);
skleft = new Animation();
skleft.setAutoUpdate(false);
skleft.addFrame(skeletonSS.getSprite(0, 9), 75);
skleft.addFrame(skeletonSS.getSprite(1, 9), 75);
skleft.addFrame(skeletonSS.getSprite(2, 9), 75);
skleft.addFrame(skeletonSS.getSprite(3, 9), 75);
skleft.addFrame(skeletonSS.getSprite(4, 9), 75);
skleft.addFrame(skeletonSS.getSprite(5, 9), 75);
skleft.addFrame(skeletonSS.getSprite(6, 9), 75);
skleft.addFrame(skeletonSS.getSprite(7, 9), 75);
skleft.addFrame(skeletonSS.getSprite(8, 9), 75);
skright = new Animation();
skright.setAutoUpdate(false);
skright.addFrame(skeletonSS.getSprite(0, 11), 75);
skright.addFrame(skeletonSS.getSprite(1, 11), 75);
skright.addFrame(skeletonSS.getSprite(2, 11), 75);
skright.addFrame(skeletonSS.getSprite(3, 11), 75);
skright.addFrame(skeletonSS.getSprite(4, 11), 75);
skright.addFrame(skeletonSS.getSprite(5, 11), 75);
skright.addFrame(skeletonSS.getSprite(6, 11), 75);
skright.addFrame(skeletonSS.getSprite(7, 11), 75);
skright.addFrame(skeletonSS.getSprite(8, 11), 75);
skwait = new Animation();
skwait.setAutoUpdate(true);
skwait.addFrame(skeletonSS.getSprite(0, 14), 75);
skwait.addFrame(skeletonSS.getSprite(1, 14), 75);
skwait.addFrame(skeletonSS.getSprite(2, 14), 75);
skwait.addFrame(skeletonSS.getSprite(3, 14), 75);
skdead = new Animation();
skdead.setAutoUpdate(false);
skdead.addFrame(skeletonSS.getSprite(2, 20), 75);
skdead.addFrame(skeletonSS.getSprite(3, 20), 75);
skdead.addFrame(skeletonSS.getSprite(4, 20), 75);
skdead.addFrame(skeletonSS.getSprite(5, 20), 75);
currentanime = skwait;
}
@Override
public void init(GameContainer container) throws SlickException {
try {
worldMusic = sound.addSoundToMap("World", "res/Sound/World.wav", sid.getMusicID(0));
playerAttackSound = sound.addSoundToMap("Attack", "res/Sound/Shoot.wav", sid.getAttackID(0));
bossAttackSound =
sound.addSoundToMap("Attack", "res/Sound/Boss_attack.wav", sid.getAttackID(1));
collisionSound =
sound.addSoundToMap("Collision", "res/Sound/Collide.wav", sid.getEffectID(0));
} catch (MalformedURLException e1) {
e1.printStackTrace();
}
sound.loopSound(worldMusic);
Image[] movementUp = {
new Image("res/Character1_back.png"),
new Image("res/Character1_back.png"),
new Image("res/Character1_back.png"),
new Image("res/Character1_back.png"),
new Image("res/Character1_back.png"),
new Image("res/Character1_back.png"),
new Image("res/Character1_back.png"),
new Image("res/Character1_back.png")
};
Image[] movementDown = {
new Image("res/Character1_frontanimation-frame-1.png"),
new Image("res/Character1_frontanimation-frame-2.png"),
new Image("res/Character1_frontanimation-frame-3.png"),
new Image("res/Character1_frontanimation-frame-4.png"),
new Image("res/Character1_frontanimation-frame-5.png"),
new Image("res/Character1_frontanimation-frame-6.png"),
new Image("res/Character1_frontanimation-frame-7.png"),
new Image("res/Character1_frontanimation-frame-8.png")
};
Image[] movementRight = {
new Image("res/Character1_right.png"),
new Image("res/Character1_right.png"),
new Image("res/Character1_right.png"),
new Image("res/Character1_right.png"),
new Image("res/Character1_right.png"),
new Image("res/Character1_right.png"),
new Image("res/Character1_right.png"),
new Image("res/Character1_right.png")
};
Image[] movementLeft = {
new Image("res/Character1_left.png"),
new Image("res/Character1_left.png"),
new Image("res/Character1_left.png"),
new Image("res/Character1_left.png"),
new Image("res/Character1_left.png"),
new Image("res/Character1_left.png"),
new Image("res/Character1_left.png"),
new Image("res/Character1_left.png")
};
int duration[] = {100, 100, 100, 100, 100, 100, 100, 100};
up = new Animation(movementUp, duration, false);
down = new Animation(movementDown, duration, false);
left = new Animation(movementLeft, duration, false);
right = new Animation(movementRight, duration, false);
Animation[] animList = {up, down, left, right};
Animation[] bossAnim = {up.copy(), down.copy(), left.copy(), right.copy()};
player = new Player(new Vector2d(10 * SIZE, 10 * SIZE), animList);
player.setAttackSound(playerAttackSound);
entity = new Boss(new Vector2d(25 * SIZE, 25 * SIZE), bossAnim, player);
entity.setProjectileList(projectiles);
entity.setAttackSound(bossAttackSound);
player.setCurrentBoss(entity);
tileMap = new TiledMap("res/tilemap.tmx");
blocked = new boolean[tileMap.getWidth()][tileMap.getHeight()];
try {
this.initAbilities();
} catch (IOException e) {
e.printStackTrace();
}
for (int x = 0; x < tileMap.getWidth(); x++) {
for (int y = 0; y < tileMap.getHeight(); y++) {
int ID = tileMap.getTileId(x, y, 0);
String value = tileMap.getTileProperty(ID, "blocked", "false");
if ("true".equals(value)) {
blocked[x][y] = true;
}
}
}
}
@Override
public void render(GameContainer gameContainer, StateBasedGame stateBasedGame, Graphics graphics)
throws SlickException {
background.draw(0, 0);
tandwiel1.draw(
-tandwiel1.getWidth() / 2,
AsaGame.SOURCE_RESOLUTION.height / 2 - tandwiel1.getHeight() / 2);
tandwiel2.draw(
tandwiel1.getWidth() / 2 - tandwielOffset - 40,
AsaGame.SOURCE_RESOLUTION.height / 2 - tandwiel2.getHeight());
graphics.setFont(fontBlack);
if (baseImage != null) {
webcamFeed
.getSubImage(80, 0, 480, 480)
.draw(center.getWidth() - ((500) / 2), center.getHeight() - (500 / 2), 500, 500);
background_spinner_half.draw(
center.getWidth() - background_spinner.getWidth() / 2, center.getHeight() + 45);
} else {
background_spinner.draw(
center.getWidth() - background_spinner.getWidth() / 2,
center.getHeight() - background_spinner.getHeight() / 2);
}
if (mode == 1) {
spinner.draw(
center.getWidth() - spinner.getWidth() / 2, center.getHeight() - spinner.getHeight() / 2);
spinneroverlay.draw(
center.getWidth() - spinner.getWidth() / 2, center.getHeight() - spinner.getHeight() / 2);
selectImage.draw(center.getWidth() / 2 - 20, 60);
choise.draw(
choise.getWidth() * 0.15f,
center.getHeight() * 2 - choise.getHeight() * 1.6f,
pulseScale);
for (int i = 0; i < wheelOptions.size(); i++) {
float offsetDegree = 360 / wheelOptions.size();
float degrees = (270 + ((rotation + rotationDelta) % 360 + offsetDegree * i) % 360) % 360;
if (degrees < 0) {
degrees = degrees + 360;
}
float rad = (float) (degrees * (Math.PI / 180));
float radius = 313;
float x = (float) (center.getWidth() + radius * Math.cos(rad));
float y = (float) (center.getHeight() + radius * Math.sin(rad));
WheelOptionYesNo option = wheelOptions.get(i);
Image optionIcon = option.getIcon();
float biggerThanDegrees = 270 + (offsetDegree / 2);
if (biggerThanDegrees > 360) {
biggerThanDegrees = biggerThanDegrees - 360;
}
if (degrees >= 270 - (offsetDegree / 2) && degrees < biggerThanDegrees) {
x = x - (float) (optionIcon.getWidth() * 1.3 / 2);
y = y - (float) (optionIcon.getHeight() * 1.3 / 2);
option.getIcon().draw(x, y, (float) 1.3);
} else {
x = x - (float) (optionIcon.getWidth() * 1 / 2);
y = y - (float) (optionIcon.getHeight() * 1 / 2);
option.getIcon().draw(x, y);
}
if (degrees >= 270 - (offsetDegree / 2) && degrees < biggerThanDegrees) {
selectedOption = i;
}
}
} else {
lens.draw(center.getWidth() - (550 / 2), center.getHeight() - (550 / 2));
spinner.draw(
center.getWidth() - spinner.getWidth() / 2, center.getHeight() - spinner.getHeight() / 2);
spinneroverlay.draw(
center.getWidth() - spinner.getWidth() / 2, center.getHeight() - spinner.getHeight() / 2);
if (drawCountdown) {
countdown.draw(center.getWidth() - 75, center.getHeight() + 75, 150, 150);
}
}
}
public void init(GameContainer gc, StateBasedGame sbg) throws SlickException {
gc.setTargetFrameRate(60);
gc.setShowFPS(false);
// *******************
// Scenerey Stuff
// ****************
grassMap = new TiledMap("res/coral.tmx");
// grassMap = new TiledMap("res/coral.tmx");
// Ongoing checks are useful
System.out.println("Tile map is this wide: " + grassMap.getWidth());
camera = new Camera(gc, grassMap);
// *********************************************************************************
// Player stuff --- these things should probably be chunked into methods
// and classes
// *********************************************************************************
SpriteSheet runningSS = new SpriteSheet("res/skeletonpritesheet.png", 64, 64, 0);
// System.out.println("Horizontal count: "
// +runningSS.getHorizontalCount());
// System.out.println("Vertical count: " +runningSS.getVerticalCount());
up = new Animation();
up.setAutoUpdate(true);
up.addFrame(runningSS.getSprite(0, 8), 330);
up.addFrame(runningSS.getSprite(1, 8), 330);
up.addFrame(runningSS.getSprite(2, 8), 330);
up.addFrame(runningSS.getSprite(3, 8), 330);
up.addFrame(runningSS.getSprite(4, 8), 330);
up.addFrame(runningSS.getSprite(5, 8), 330);
up.addFrame(runningSS.getSprite(6, 8), 330);
up.addFrame(runningSS.getSprite(7, 8), 330);
up.addFrame(runningSS.getSprite(8, 8), 330);
down = new Animation();
down.setAutoUpdate(false);
down.addFrame(runningSS.getSprite(0, 10), 330);
down.addFrame(runningSS.getSprite(1, 10), 330);
down.addFrame(runningSS.getSprite(2, 10), 330);
down.addFrame(runningSS.getSprite(3, 10), 330);
down.addFrame(runningSS.getSprite(4, 10), 330);
down.addFrame(runningSS.getSprite(5, 10), 330);
down.addFrame(runningSS.getSprite(6, 10), 330);
down.addFrame(runningSS.getSprite(7, 10), 330);
down.addFrame(runningSS.getSprite(8, 10), 330);
left = new Animation();
left.setAutoUpdate(false);
left.addFrame(runningSS.getSprite(0, 9), 330);
left.addFrame(runningSS.getSprite(1, 9), 330);
left.addFrame(runningSS.getSprite(2, 9), 330);
left.addFrame(runningSS.getSprite(3, 9), 330);
left.addFrame(runningSS.getSprite(4, 9), 330);
left.addFrame(runningSS.getSprite(5, 9), 330);
left.addFrame(runningSS.getSprite(6, 9), 330);
left.addFrame(runningSS.getSprite(7, 9), 330);
left.addFrame(runningSS.getSprite(8, 9), 330);
right = new Animation();
right.setAutoUpdate(false);
right.addFrame(runningSS.getSprite(0, 11), 330);
right.addFrame(runningSS.getSprite(1, 11), 330);
right.addFrame(runningSS.getSprite(2, 11), 330);
right.addFrame(runningSS.getSprite(3, 11), 330);
right.addFrame(runningSS.getSprite(4, 11), 330);
right.addFrame(runningSS.getSprite(5, 11), 330);
right.addFrame(runningSS.getSprite(6, 11), 330);
right.addFrame(runningSS.getSprite(7, 11), 330);
right.addFrame(runningSS.getSprite(8, 11), 330);
wait = new Animation();
wait.setAutoUpdate(true);
wait.addFrame(runningSS.getSprite(0, 14), 733);
wait.addFrame(runningSS.getSprite(1, 14), 733);
wait.addFrame(runningSS.getSprite(2, 14), 733);
wait.addFrame(runningSS.getSprite(3, 14), 733);
// wait.addFrame(runningSS.getSprite(2, 14), 733);
// wait.addFrame(runningSS.getSprite(5, 14), 333);
sprite = wait;
// *****************************************************************
// Obstacles etc.
// build a collision map based on tile properties in the TileD map
Blocked.blocked = new boolean[grassMap.getWidth()][grassMap.getHeight()];
// System.out.println("Map height:" + grassMap.getHeight());
// System.out.println("Map width:" + grassMap.getWidth());
// There can be more than 1 layer. You'll check whatever layer has the
// obstacles.
// You could also use this for planning traps, etc.
// System.out.println("Number of tile layers: "
// +grassMap.getLayerCount());
System.out.println("The grassmap is " + grassMap.getWidth() + "by " + grassMap.getHeight());
for (int xAxis = 0; xAxis < grassMap.getWidth(); xAxis++) {
for (int yAxis = 0; yAxis < grassMap.getHeight(); yAxis++) {
// int tileID = grassMap.getTileId(xAxis, yAxis, 0);
// Why was this changed?
// It's a Different Layer.
// You should read the TMX file. It's xml, i.e.,human-readable
// for a reason
int tileID = grassMap.getTileId(xAxis, yAxis, 1);
String value = grassMap.getTileProperty(tileID, "blocked", "false");
if ("true".equals(value)) {
System.out.println("The tile at x " + xAxis + " andy axis " + yAxis + " is blocked.");
Blocked.blocked[xAxis][yAxis] = true;
}
}
}
System.out.println("Array length" + Blocked.blocked[0].length);
// A remarkably similar process for finding hostiles
hostiles = new boolean[grassMap.getWidth()][grassMap.getHeight()];
/* for (int xAxis = 0; xAxis < grassMap.getWidth(); xAxis++) {
for (int yAxis = 0; yAxis < grassMap.getHeight(); yAxis++) {
int xBlock = (int) xAxis;
int yBlock = (int) yAxis;
if (!Blocked.blocked[xBlock][yBlock]) {
if (yBlock % 7 == 0 && xBlock % 15 == 0 ) {
Item i = new Item(xAxis * SIZE, yAxis * SIZE);
stuff.add(i);
//stuff1.add(h);
hostiles[xAxis][yAxis] = true;
}
}
}
}
for (int xAxis = 0; xAxis < grassMap.getWidth(); xAxis++) {
for (int yAxis = 0; yAxis < grassMap.getHeight(); yAxis++) {
int xBlock = (int) xAxis;
int yBlock = (int) yAxis;
if (!Blocked.blocked[xBlock][yBlock]) {
if (yBlock % 7 == 0 && xBlock % 15 == 0 ) {
Item i = new Item(xAxis * SIZE, yAxis * SIZE);
stuff.add(i);
//stuff1.add(h);
hostiles[xAxis][yAxis] = true;
}
}
}
}
*/
// healthpotion = new Item(100, 100);
// healthpotion1 = new Item(450, 400);
// stuff.add(healthpotion);
// stuff.add(healthpotion1);
// stormy = new Ninja(0,0);
// daniel = new Ninja(124,254);
// dojo.add(stormy);
// dojo.add(daniel);
flava = new Enemy(1500, 2500);
flav = new Enemy(1000, 1000);
bonez.add(flava);
bonez.add(flav);
bone1 = new Bone(655, 70);
bone2 = new Bone(1750, 800);
doghouse.add(bone1);
doghouse.add(bone2);
// speedpotion = new Item1(100,150);
// speedpotion1 = new Item1(450,100);
// stuff1.add(speedpotion);
// stuff1.add(speedpotion1);
// antidote = new Itemwin(3004,92);
// stuffwin.add(antidote);
BoneMaker.Makethebones();
}
public void init(GameContainer gc, StateBasedGame sbg) throws SlickException {
gc.setTargetFrameRate(60);
gc.setShowFPS(false);
// *******************
// Scenerey Stuff
// ****************
forestMap = new TiledMap("res/agivens_4_map.tmx");
// Ongoing checks are useful
System.out.println("Tile map is this wide: " + forestMap.getWidth());
camera = new Camera(gc, forestMap);
// *********************************************************************************
// Player stuff --- these things should probably be chunked into methods
// and classes
// *********************************************************************************
SpriteSheet proMoving = new SpriteSheet("res/ProtagonistSpriteSheet.png", 64, 64, 0);
// System.out.println("Horizontal count: "
// +runningSS.getHorizontalCount());
// System.out.println("Vertical count: " +runningSS.getVerticalCount());
proup = new Animation();
proup.setAutoUpdate(true);
proup.addFrame(proMoving.getSprite(0, 8), 330);
proup.addFrame(proMoving.getSprite(1, 8), 330);
proup.addFrame(proMoving.getSprite(2, 8), 330);
proup.addFrame(proMoving.getSprite(3, 8), 330);
proup.addFrame(proMoving.getSprite(4, 8), 330);
proup.addFrame(proMoving.getSprite(5, 8), 330);
proup.addFrame(proMoving.getSprite(6, 8), 330);
proup.addFrame(proMoving.getSprite(7, 8), 330);
proup.addFrame(proMoving.getSprite(8, 8), 330);
prodown = new Animation();
prodown.setAutoUpdate(false);
prodown.addFrame(proMoving.getSprite(0, 10), 330);
prodown.addFrame(proMoving.getSprite(1, 10), 330);
prodown.addFrame(proMoving.getSprite(2, 10), 330);
prodown.addFrame(proMoving.getSprite(3, 10), 330);
prodown.addFrame(proMoving.getSprite(4, 10), 330);
prodown.addFrame(proMoving.getSprite(5, 10), 330);
prodown.addFrame(proMoving.getSprite(6, 10), 330);
prodown.addFrame(proMoving.getSprite(7, 10), 330);
prodown.addFrame(proMoving.getSprite(8, 10), 330);
proleft = new Animation();
proleft.setAutoUpdate(false);
proleft.addFrame(proMoving.getSprite(0, 9), 330);
proleft.addFrame(proMoving.getSprite(1, 9), 330);
proleft.addFrame(proMoving.getSprite(2, 9), 330);
proleft.addFrame(proMoving.getSprite(3, 9), 330);
proleft.addFrame(proMoving.getSprite(4, 9), 330);
proleft.addFrame(proMoving.getSprite(5, 9), 330);
proleft.addFrame(proMoving.getSprite(6, 9), 330);
proleft.addFrame(proMoving.getSprite(7, 9), 330);
proleft.addFrame(proMoving.getSprite(8, 9), 330);
proright = new Animation();
proright.setAutoUpdate(false);
proright.addFrame(proMoving.getSprite(0, 11), 330);
proright.addFrame(proMoving.getSprite(1, 11), 330);
proright.addFrame(proMoving.getSprite(2, 11), 330);
proright.addFrame(proMoving.getSprite(3, 11), 330);
proright.addFrame(proMoving.getSprite(4, 11), 330);
proright.addFrame(proMoving.getSprite(5, 11), 330);
proright.addFrame(proMoving.getSprite(6, 11), 330);
proright.addFrame(proMoving.getSprite(7, 11), 330);
proright.addFrame(proMoving.getSprite(8, 11), 330);
prowait = new Animation();
prowait.setAutoUpdate(true);
prowait.addFrame(proMoving.getSprite(0, 14), 733);
prowait.addFrame(proMoving.getSprite(1, 14), 733);
prowait.addFrame(proMoving.getSprite(2, 14), 733);
prowait.addFrame(proMoving.getSprite(3, 14), 733);
// wait.addFrame(runningSS.getSprite(2, 14), 733);
// wait.addFrame(runningSS.getSprite(5, 14), 333);
sprite = prowait;
// *****************************************************************
// Obstacles etc.
// build a collision map based on tile properties in the TileD map
blocked.blocked = new boolean[forestMap.getWidth()][forestMap.getHeight()];
// System.out.println("Map height:" + grassMap.getHeight());
// System.out.println("Map width:" + grassMap.getWidth());
// There can be more than 1 layer. You'll check whatever layer has the
// obstacles.
// You could also use this for planning traps, etc.
// System.out.println("Number of tile layers: "
// +grassMap.getLayerCount());
System.out.println("The grassmap is " + forestMap.getWidth() + " by " + forestMap.getHeight());
for (int xAxis = 0; xAxis < forestMap.getWidth(); xAxis++) {
for (int yAxis = 0; yAxis < forestMap.getHeight(); yAxis++) {
// int tileID = grassMap.getTileId(xAxis, yAxis, 0);
// Why was this changed?
// It's a Different Layer.
// You should read the TMX file. It's xml, i.e.,human-readable
// for a reason
int tileID = forestMap.getTileId(xAxis, yAxis, 1);
String value = forestMap.getTileProperty(tileID, "blocked", "false");
if ("true".equals(value)) {
System.out.println(
"The tile at x axis " + xAxis + " and y axis " + yAxis + " is blocked.");
blocked.blocked[xAxis][yAxis] = true;
}
}
}
System.out.println("Array length " + blocked.blocked[0].length);
// A remarkably similar process for finding hostiles
hostiles = new boolean[forestMap.getWidth()][forestMap.getHeight()];
grabtowin = new itemwin(4400, 4400);
stuffwin.add(grabtowin);
numberone = new Enemy(300, 300);
monster.add(numberone);
}
public void render(GameContainer gc, StateBasedGame sbg, Graphics g) throws SlickException {
camera.centerOn((int) Player.x, (int) Player.y);
camera.drawMap();
camera.translateGraphics();
// it helps to add status reports to see what's going on
// but it gets old quickly
// System.out.println("Current X: " +player.x + " \n Current Y: "+ y);
sprite.draw((int) Player.x, (int) Player.y);
// g.drawString("x: " + (int)player.x + "y: " +(int)player.y , player.x, player.y - 10);
// g.drawString("Health: " + Player.health/1000, camera.cameraX + 10,
// camera.cameraY + 10);
g.drawString("speed: " + (int) (Player.speed * 10), camera.cameraX + 10, camera.cameraY + 25);
// doesn't actually count HELP
g.drawString("bone: " + (int) (Player.Counter * 1), camera.cameraX + 10, camera.cameraY + 10);
// g.draw(player.rect);
g.drawString("time passed: " + counter / 1000, camera.cameraX + 600, camera.cameraY);
// moveenemies();
// for (Item i : stuff) {
// if (i.isvisible) {
// i.currentImage.draw(i.x, i.y);
// draw the hitbox
// g.draw(i.hitbox);
// }
// }
/* for (Ninja n : dojo) {
if (n.isvisible) {
n.currentImage.draw(n.x, n.y);
// draw the hitbox
g.draw(n.hitbox);
}
}
*/
for (Bone b : doghouse) {
if (b.isvisible) {
b.currentImage.draw(b.x, b.y);
// draw the hitbox
// g.draw(b.hitbox);
}
}
// stormy.currentImage.draw(stormy.x,stormy.y);
// daniel.currentImage.draw(daniel.x,daniel.y);
// for (Item1 h : stuff1) {
// if (h.isvisible) {
// h.currentImage.draw(h.x, h.y);
// draw the hitbox
// g.draw(h.hitbox);
// }
// }
for (Enemy e : bonez) {
if (e.isAlive) {
e.currentanime.draw(e.Bx, e.By);
// draw the hitbox
// g.draw(e.hitbox);
}
}
// for (Itemwin w: stuffwin) {
// if (w.isvisible) {
// w.currentImage.draw(w.x, w.y);
// draw the hitbox
// g.draw(w.hitbox);
// }
// }
}
// This method draws when player is still
public void drawMovingNoPlayerMov(int x_tile_dist, int y_tile_dist, Graphics g) {
// System.out.println(getMoving());
// System.out.println(inputDelta);
float part = (float) getInputDelta() / (float) getSpeed();
int offset = (int) (part * Map.SIZE_OF_TILE);
// System.out.println(part);
// System.out.println(offset);
int x_move = ((Player.getPlayerXCenter() + x_tile_dist) * Map.SIZE_OF_TILE) + Map.X_OFFSET;
int y_move = ((Player.getPlayerYCenter() + y_tile_dist) * Map.SIZE_OF_TILE) + Map.Y_OFFSET;
int tile = Map.SIZE_OF_TILE;
int actual_x = 0;
int actual_y = 0;
switch (getMoving()) {
case 1:
// anim.draw(x_move+tile-offset, y_move+offset-tile);
actual_x = x_move + tile - offset;
actual_y = y_move + offset - tile;
break;
case 2:
// anim.draw(x_move, y_move+offset-tile);
actual_x = x_move;
actual_y = y_move + offset - tile;
break;
case 3:
// anim.draw(x_move-tile+offset, y_move+offset-tile);
actual_x = x_move - tile + offset;
actual_y = y_move + offset - tile;
break;
case 4:
// anim.draw(x_move+tile-offset, y_move);
actual_x = x_move + tile - offset;
actual_y = y_move;
break;
case 6:
// anim.draw(x_move-tile+offset, y_move);
actual_x = x_move - tile + offset;
actual_y = y_move;
break;
case 7:
// anim.draw(x_move+tile-offset, y_move+tile-offset);
actual_x = x_move + tile - offset;
actual_y = y_move + tile - offset;
break;
case 8:
// anim.draw(x_move, y_move+tile-offset);
actual_x = x_move;
actual_y = y_move + tile - offset;
break;
case 9:
// anim.draw(x_move-tile+offset, y_move+tile-offset);
actual_x = x_move - tile + offset;
actual_y = y_move + tile - offset;
break;
}
anim.draw(actual_x, actual_y);
if (attacked) {
g.setColor(RED);
g.drawRect(actual_x, actual_y, Map.SIZE_OF_TILE, Map.SIZE_OF_TILE);
g.setColor(BLACK);
}
getStatus().drawMoveMonster(actual_x, actual_y);
}
public void update(GameContainer gc, StateBasedGame sbg, int delta) throws SlickException {
counter += delta;
Input input = gc.getInput();
float fdelta = delta * Player.speed;
Player.setpdelta(fdelta);
double rightlimit = (grassMap.getWidth() * SIZE) - (SIZE * 0.75);
// System.out.println("Right limit: " + rightlimit);
float projectedright = Player.x + fdelta + SIZE;
boolean cangoright = projectedright < rightlimit;
// there are two types of fixes. A kludge and a hack. This is a kludge.
if (input.isKeyDown(Input.KEY_UP)) {
sprite = up;
float fdsc = (float) (fdelta - (SIZE * .15));
if (!(isBlocked(Player.x, Player.y - fdelta)
|| isBlocked((float) (Player.x + SIZE + 1.5), Player.y - fdelta))) {
sprite.update(delta);
// The lower the delta the slower the sprite will animate.
Player.y -= fdelta;
}
} else if (input.isKeyDown(Input.KEY_DOWN)) {
sprite = down;
if (!isBlocked(Player.x, Player.y + SIZE + fdelta)
|| !isBlocked(Player.x + SIZE - 1, Player.y + SIZE + fdelta)) {
sprite.update(delta);
Player.y += fdelta;
}
} else if (input.isKeyDown(Input.KEY_LEFT)) {
sprite = left;
if (!(isBlocked(Player.x - fdelta, Player.y)
|| isBlocked(Player.x - fdelta, Player.y + SIZE - 1))) {
sprite.update(delta);
Player.x -= fdelta;
}
} else if (input.isKeyDown(Input.KEY_RIGHT)) {
sprite = right;
// the boolean-kludge-implementation
if (cangoright
&& (!(isBlocked(Player.x + SIZE + fdelta, Player.y)
|| isBlocked(Player.x + SIZE + fdelta, Player.y + SIZE - 1)))) {
sprite.update(delta);
Player.x += fdelta;
} // else { System.out.println("Right limit reached: " +
// rightlimit);}
}
Player.rect.setLocation(Player.getplayershitboxX(), Player.getplayershitboxY());
// for (Item i : stuff) {
//
// if (Player.rect.intersects(i.hitbox)) {
// //System.out.println("yay");
// if (i.isvisible) {
// Player.health += 10000;
// i.isvisible = false;
// }
// }
// }
/*for (Ninja n : dojo) {
if (Player.rect.intersects(n.hitbox)) {
//System.out.println("yay");
if (n.isvisible) {
Player.health += 10000;
n.isvisible = false;
}
}
}
*/
for (Bone b : doghouse) {
if (Player.rect.intersects(b.hitbox)) {
// System.out.println("yay");
if (b.isvisible) {
Player.speed += .1f;
b.isvisible = false;
Player.Counter += 1;
}
}
if (Player.Counter > 10) {
Bone.Counter = false;
sbg.enterState(3, new FadeOutTransition(Color.black), new FadeInTransition(Color.black));
}
}
/*for (Item1 h : stuff1) {
if (Player.rect.intersects(h.hitbox)) {
//System.out.println("yay");
if (h.isvisible) {
Player.speed += .1f;
h.isvisible = false;
}
}
}
*/
// for (Itemwin w : stuffwin) {
// if (Player.rect.intersects(w.hitbox)) {
// //System.out.println("yay");
// if (w.isvisible) {
// w.isvisible = false;
// makevisible();
// sbg.enterState(3, new FadeOutTransition(Color.black), new FadeInTransition(Color.black));
//
// }
//
// }
// }
for (Enemy e : bonez) {
if (e.isAlive) {
e.move();
}
}
for (Enemy e : bonez) {
if (e.isAlive) {
if (Player.rect.intersects(e.rect)) {
Player.health = 0;
e.isAlive = true;
// once they touch the enemy player die
}
}
}
Player.health -= counter / 1000;
if (Player.health <= 0) {
makevisible();
sbg.enterState(2, new FadeOutTransition(Color.black), new FadeInTransition(Color.black));
}
}
