import java.awt.

Color; private Rectangle playerBounds;

import java.awt.Dimension; private Rectangle enemyBounds;

import java.awt.Graphics;

import java.awt.Graphics2D; private Rectangle enemy1Bounds;

import java.awt.Image; private Rectangle enemy2Bounds;

import java.awt.Rectangle;

import java.awt.RenderingHints; // Define sprite-related variables

import java.awt.event.ActionEvent; private Image characterSprite; // This will store your

character sprite sheet
import java.awt.event.ActionListener;
private int frameCount = 4; // Number of frames in
import java. awt.event.KeyEvent;
your sprite sheet
import java.awt.event.KeyListener;
private int currentFrame = 0; // Current frame for
import java.awt.event.MouseEvent; animation

import java.util.ArrayList; private int frameWidth = 16; // Width of each frame

in your sprite sheet
import java.awt.event.MouseListener;
private int frameHeight = 16; // Height of each frame
import java.awt.image.BufferedImage; in your sprite sheet
import java.io.File; private boolean doorCollision = false;
import java.io.IOException; private BufferedImage grad;
import java.util.List; private int doorhold;

private int doorX = 400;

private int doorY = 500;

import javax.swing.*; private int doorCounter = 0;
import javax.imageio.ImageIO;

public class tryy extends JPanel implements

ActionListener, KeyListener, MouseListener{
//inventory
Timer timers = new Timer(16, this);
private Image chest;
private int characterX = 0;
private boolean showInventory;
private int characterY = 0;
private String[] inventoryItems;
private int characterSpeed = 3;
private boolean showDoor;
private int jumpSpeed = 14;
private Rectangle characterBounds; // Add this field
private int gravity = 1; for character bounding box
private Image spriteSheet; private Rectangle doorBounds;
private int scaledWidth = 50; private ImageIcon apple1;
private int scaledHeight = 50; private int appleX = 250;
private int velocityX = 0; private int appleY = 500;
private int velocityY = 0; private boolean showApple1;
private int playerLife = 3;

private Direction currentDirection = Direction.DOWN;

private boolean isJumping = false;

private boolean isMoving = false;

private boolean isOnTile = false;

private ImageIcon door;

public boolean isOnTile(){

return isOnTile;

private int enemySpeed = 10, enemySpeed1 = 5, }

enemySpeed2 = 2;
catch (IOException e){
private BufferedImage wall, tile1, cactus, vines, design;
e.printStackTrace();
private boolean drawimage;
}
private BufferedImage enemy, enemy1, enemy2;

private BufferedImage apple;

spriteSheet = new ImageIcon("red2.png").getImage();

setFocusable(true);

addKeyListener(this);

addMouseListener(this);
private int enemyX = 0, enemy1X = 0, enemy2X = 0;
Timer timer = new Timer(1000 / 60, this); // MERONG
private int enemyY = 440,enemy1Y = 280, enemy2Y = /60 PARA TUMAAS YUNG FRAMES PER SECOND
55;
timer.start();

private Timer timer, timer1, timer2;

}

protected void paintComponent(Graphics g){

public tryy() {
super.paintComponent(g);

inventoryItems = new String [] {};

showInventory = false;
apple1 = new ImageIcon("apple2.png");

try{

enemy = ImageIO.read(new File("bird.png"));

enemy1 = ImageIO.read(new File("bird1.png"));

g.drawImage(grad, 0, 0, this);
enemy2 = ImageIO.read(new File("bird2.png"));
//background
wall = ImageIO.read(new File("wall.png"));
drawimage = g.drawImage(wall, 0, 0, 500,700, this);
cactus = ImageIO.read(new File("cactus.png"));
//cactus
tile1 = ImageIO.read(new File("tile1.jpg"));
drawimage = g.drawImage(cactus, 0, 620, 50, 50,
vines = ImageIO.read(new File("baging.png")); this);

design = ImageIO.read(new File("design.png")); drawimage = g.drawImage(cactus, 30, 620, 50, 50,

this);
characterSprite = new
ImageIcon("life.png").getImage(); drawimage = g.drawImage(cactus, 60, 620, 50, 50,
this);
chest = ImageIO.read(new File("chest.png"));
drawimage = g.drawImage(cactus, 90, 620, 50, 50,
this);
 drawimage = g.drawImage(cactus, 120, 620, 50, 50, //vines
this);
g.drawImage(vines, 0,0, this);
drawimage = g.drawImage(cactus, 150, 620, 50, 50,
this);

drawimage = g.drawImage(cactus, 180, 620, 50, 50,

this);

drawimage = g.drawImage(cactus, 210, 620, 50, 50, //tile

this);
g.drawImage(tile1, 0, 600, this);
drawimage = g.drawImage(cactus, 240, 620, 50, 50,
this); g.drawImage(tile1, 30, 600, this);

drawimage = g.drawImage(cactus, 270, 620, 50, 50, g.drawImage(tile1, 60, 600, this);
this);

drawimage = g.drawImage(cactus, 300, 620, 50, 50, g.drawImage(tile1, 120, 520, this);
this);
g.drawImage(tile1, 150, 520, this);
drawimage = g.drawImage(cactus, 330, 620, 50, 50,
this);

drawimage = g.drawImage(cactus, 360, 620, 50, 50, g.drawImage(tile1, 230, 470, this);
this); g.drawImage(tile1, 260, 470, this);
drawimage = g.drawImage(cactus, 390, 620, 50, 50,
this);
g.drawImage(tile1, 430, 390, this);
drawimage = g.drawImage(cactus, 420, 620, 50, 50,
this);

drawimage = g.drawImage(cactus, 450, 620, 50, 50, g.drawImage(tile1, 150, 420, this);
this);
g.drawImage(tile1, 120, 420, this);

//design
g.drawImage(tile1, 100, 360, this);

g.drawImage(tile1, 70, 360, this);

drawimage = g.drawImage(design, 410, 400,50, 180,
this);
g.drawImage(tile1, 170, 310, this);
drawimage = g.drawImage(design, 410, 500,50, 180,
this); g.drawImage(tile1, 200, 310, this);

drawimage = g.drawImage(design, 250, 250,50, 180,

this);
g.drawImage(tile1, 250, 250, this);
drawimage = g.drawImage(design, 250, 350,50, 180,
g.drawImage(tile1, 280, 250, this);
this);

drawimage = g.drawImage(design, 330, 200,50, 180,

this); g.drawImage(tile1, 330, 190, this);
drawimage = g.drawImage(design, 330, 300,50, 180, g.drawImage(tile1, 360, 190, this);
this);

drawimage = g.drawImage(design, 330, 400,50, 180,

this); g.drawImage(tile1, 260, 140, this);

g.drawImage(tile1, 230, 140, this);

drawimage = g.drawImage(design, 330, 500,50, 180,
this);

drawimage = g.drawImage(design, 70, 360,50, 180, g.drawImage(tile1, 330, 90, this);

this);
g.drawImage(tile1, 360, 90, this);
drawimage = g.drawImage(design, 70, 460,50, 180,
this);

drawimage = g.drawImage(design, 230, 470,50, 180, drawimage = g.drawImage(chest, 200, 300, 50, 50,
this); this);
 }

// Draw the character sprite based on the current

frame and direction
if(!showApple1){
int sourceX = currentFrame * frameWidth;
apple1.paintIcon(this, g, 250, 500);
int sourceY = currentDirection.ordinal() *
} if (!showApple1 && appleX <= characterX && appleY
frameHeight;
== appleY){
int destX = characterX;
showApple1 = true;
int destY = characterY;
addItemToInventory("apple");

repaint();
g.drawImage(characterSprite, destX, destY, destX +
}
scaledWidth, destY + scaledHeight,

sourceX, sourceY, sourceX + frameWidth,

sourceY + frameHeight, this);

if (showInventory) {

g.setColor(Color.ORANGE);
playerBounds = new Rectangle(characterX, characterY, g.fillRect(20, 50, 150, 100);
scaledWidth, scaledHeight);
g.setColor(Color.BLACK);
enemyBounds = new Rectangle(enemyX, enemyY, 40,
40); g.drawRect(20, 50, 150, 100);

enemy1Bounds = new Rectangle(enemy1X, enemy1Y,

40, 40); g.setColor(Color.BLACK);
enemy2Bounds = new Rectangle(enemy2X, enemy2Y, for (int i = 0; i < inventoryItems.length; i++) {
40, 40);
g.drawString(inventoryItems[i], 30,70 + i*20);

if (enemy != null) {

g.drawImage(enemy, enemyX, enemyY, 40, 40, this);

g.drawImage(enemy1, enemy1X, enemy1Y, 40, 40,

this);

g.drawImage(enemy2, enemy2X, enemy2Y, 40, 40,

this); }
// I DECLARED THIS RENDERINGHINTS PARA MAS
SMOOTH YUNG ACTION NG CHARAC

Graphics2D g2d = (Graphics2D) g;

g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASIN private void addItemToInventory (String newItem) {

G, RenderingHints.VALUE_ANTIALIAS_ON);

String [] newInventoryItems = new String

g2d.drawImage(spriteSheet, destX, destY, destX + [inventoryItems.length + 1];
scaledWidth, destY + scaledHeight,
System.arraycopy(inventoryItems, 0,
sourceX, sourceY, sourceX + frameWidth, newInventoryItems, 0, inventoryItems.length);
sourceY + frameHeight, null);
newInventoryItems[newInventoryItems.length - 1]
= newItem;
 inventoryItems = newInventoryItems; Rectangle tile4Bounds = new Rectangle(140, 520,
25, 25);

Rectangle tile6Bounds = new Rectangle(260, 470,

30, 25);
}
Rectangle tile8Bounds = new Rectangle(120, 420,
35, 25);

private void moveCharacter() { Rectangle tile13Bounds = new Rectangle(100,

360, 20, 25);
// Move character within boundaries
Rectangle tile15Bounds = new Rectangle(180,
characterX += velocityX; 310, 20, 25);
characterY += velocityY; Rectangle tile17Bounds = new Rectangle(270,
255, 20, 25);

// Check if the character is moving Rectangle tile19Bounds = new Rectangle(350,

195, 20, 25);
isMoving = (velocityX != 0 || velocityY != 0);
Rectangle tile20Bounds = new Rectangle(250,
145, 20, 25);
if (characterX < 0) { Rectangle tile22Bounds = new Rectangle(350, 90,
characterX = 0; 20, 25);

} else if (characterX + scaledWidth > getWidth()) { Rectangle tile23Bounds = new

Rectangle(430,390,10,10);
characterX = getWidth() - scaledWidth;

}
Rectangle cactusBounds1= new Rectangle(30, 620, 480,
50);
if (characterY < 0) {

characterY = 0;

} else if (characterY + scaledHeight > getHeight()) {

characterY = getHeight() - scaledHeight;

isJumping = false; // Character has landed, so

reset the jumping flag
if (playerBounds.intersects(enemyBounds)) {
}

}
playerLife--;

if (playerLife <= 0) {
private void updateAnimation() {
playerLife = 3;

}
}

}
private void checkTileCollision() {

Rectangle playerBounds = new Rectangle(characterX,

characterY, scaledWidth, scaledHeight); if (playerBounds.intersects(tile1Bounds)) {

Rectangle enemyBounds = new Rectangle(260, 470, 40, // Collided with the first tile
40); characterY = 600 - scaledHeight;
Rectangle enemy1Bounds = new Rectangle(enemy1X, velocityY = 0; // Reset vertical velocity
enemy1Y, 40, 40);
isJumping = false;
Rectangle enemy2Bounds = new Rectangle(enemy2X,
enemy2Y, 40, 40); isOnTile = true; // Set the flag to true when on a tile

Rectangle tile1Bounds = new Rectangle(0, 600, 70, if (playerBounds.intersects(tile4Bounds)) {

25); // Example bounds for the first tile
 // Collided with the first tile // Collided with the first tile

characterY = 520- scaledHeight; characterY = 195- scaledHeight;

velocityY = 0; // Reset vertical velocity velocityY = 0; // Reset vertical velocity

isJumping = false; isJumping = false;

isOnTile = true; // Set the flag to true when on a tile isOnTile = true; // Set the flag to true when on a tile

} }

if (playerBounds.intersects(tile6Bounds)) { if (playerBounds.intersects(tile20Bounds)) {

// Collided with the first tile // Collided with the first tile

characterY = 470- scaledHeight; characterY = 145- scaledHeight;

velocityY = 0; // Reset vertical velocity velocityY = 0; // Reset vertical velocity

isJumping = false; isJumping = false;

isOnTile = true; // Set the flag to true when on a tile isOnTile = true; // Set the flag to true when on a tile

} }

if (playerBounds.intersects(tile8Bounds)) { if (playerBounds.intersects(tile22Bounds)) {

// Collided with the first tile // Collided with the first tile

characterY = 420- scaledHeight; characterY = 90- scaledHeight;

velocityY = 0; // Reset vertical velocity velocityY = 0; // Reset vertical velocity

isJumping = false; isJumping = false;

isOnTile = true; // Set the flag to true when on a tile isOnTile = true; // Set the flag to true when on a tile

} }

if (playerBounds.intersects(tile13Bounds)) { if (playerBounds.intersects(tile23Bounds)) {

// Collided with the first tile // Collided with the first tile

characterY = 360- scaledHeight; characterY = 390 - scaledHeight;

velocityY = 0; // Reset vertical velocity velocityY = 0; // Reset vertical velocity

isJumping = false; isJumping = false;

isOnTile = true; // Set the flag to true when on a tile isOnTile = true; // Set the flag to true when on a tile

} }

if (playerBounds.intersects(tile15Bounds)) { if (playerBounds.intersects(cactusBounds1)) {

// Collided with the first tile playerLife--; // Deduct life when the player touches
a cactus
characterY = 310- scaledHeight;

velocityY = 0; // Reset vertical velocity

if (playerLife <= 0) {
isJumping = false;
// Handle the logic when the player runs out of
isOnTile = true; // Set the flag to true when on a tile
life (e.g., game over)
}
playerLife = 3; // Reset the player's life
if (playerBounds.intersects(tile17Bounds)) {
characterX = 0; // Reset the player's position
// Collided with the first tile
characterY = 0;
characterY = 255- scaledHeight;
// Add any other necessary game state resets
velocityY = 0; // Reset vertical velocity
}
isJumping = false;
}
isOnTile = true; // Set the flag to true when on a tile
}
}

if (playerBounds.intersects(tile19Bounds)) {
 repaint();

private void handleJumping() {

// Apply gravity consistently

velocityY += gravity;

private void movingBird(){

// Check if the character has reached the ground enemyX += enemySpeed2;

if (characterY + scaledHeight >= getHeight()) { if (enemyX > getWidth()){

characterY = getHeight() - scaledHeight; // Set enemyX = -50;

character on the ground
}
velocityY = 0; // Reset vertical velocity

isJumping = false; // Reset jumping flag

repaint();
}
}
}

private void movingBird1(){

enemy1X += enemySpeed1;

if (enemy1X > getWidth()){

@Override
enemy1X = -100;
public void actionPerformed(ActionEvent e){
}
movingBird();
repaint();
movingBird1();
}
movingBird2();
private void movingBird2(){
moveCharacter();
enemy2X += enemySpeed;
updateAnimation();
if (enemy2X > getWidth()){
handleJumping();
enemy2X = -150;
checkTileCollision();
}

repaint();
if (playerBounds.intersects(enemyBounds) ||
}
playerBounds.intersects(enemy1Bounds) ||
playerBounds.intersects(enemy2Bounds)) {

playerLife--;

if (playerLife <= 0) {

// Handle the logic when the player runs out of public static void main (String[]args){
life (you can add game over logic here)
JFrame frame= new JFrame("Sprite World");
playerLife = 3;
tryy spriteWorld = new tryy();
characterX = 0;
frame.add(spriteWorld);
characterY = 0;
frame.setSize(500, 700);
// Add any other necessary game state resets

} frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOS
E);
}
frame.setVisible(true);
}

@Override

public void keyReleased(KeyEvent e) {

@Override // Handle key releases to stop character movement

public void mouseClicked(MouseEvent e) { int keyCode = e.getKeyCode();

int x = e.getX(); if (keyCode == KeyEvent.VK_A || keyCode ==

KeyEvent.VK_D) {
int y = e.getY();
velocityX = 0; // Stop horizontal movement

}
int spriteX = 0;

int spriteY = 400;

@Override
int spriteWidth = 60;
public void keyPressed(KeyEvent e) {
int spriteHeight = 60;
// Handle key presses for character movement and
jumping
if (x >= spriteX && x <= spriteX + spriteWidth
int keyCode = e.getKeyCode();
&& y >= spriteY && y <= spriteY + spriteHeight) {
if (keyCode == KeyEvent.VK_A) {

currentDirection = Direction.LEFT;
showInventory = !showInventory;
velocityX = -characterSpeed; // Move character
repaint();
left
}
} else if (keyCode == KeyEvent.VK_D) {
}
currentDirection = Direction.RIGHT;

velocityX = characterSpeed; // Move character

right

@Override } else if (keyCode == KeyEvent.VK_W) {

public void mousePressed(MouseEvent e) {} if (!isJumping) {

// Jump if not currently jumping

isJumping = true;

@Override velocityY = -jumpSpeed; // Apply jump velocity

public void mouseReleased(MouseEvent e) {} }

}else if (keyCode == KeyEvent.VK_B) {

showInventory = !showInventory;

@Override repaint();

public void mouseEntered(MouseEvent e) {} }

@Override private enum Direction {

public void mouseExited(MouseEvent e) {} DOWN, UP, LEFT, RIGHT

@Override }

public void keyTyped(KeyEvent e) {}