Green Lantern Java Game 320x240 Upd
The Lantern Corps in Your Pocket: Green Lantern Java (320x240) Game Review
Long before we had high-fidelity mobile apps, Java games (J2ME) were the kings of portable gaming. For those still rocking a classic device or using an emulator, the Green Lantern: Rise of the Manhunters
Java game remains a nostalgic gem. Specifically optimized for the 320x240 screen resolution
, this title brings the power of the ring to your fingertips. Gameplay Overview: Willpower Unleashed
In this 2011 movie tie-in, you step into the flight boots of Hal Jordan
, the latest recruit of the Green Lantern Corps. While the console versions featured complex 3D environments, the Java edition delivers a tight side-scrolling action experience perfect for classic button-input phones. Hard-Light Constructs
: The core of the game is using your Power Ring to create weapons. You can summon giant fists, gatling guns, and war hammers to smash through waves of Manhunter androids. Combat Mechanics
: Much like the "God of War" style combat found in its console counterparts, the game focuses on combos and satisfying finishing moves.
: As you progress, you can improve your stats, including health and energy boosts, allowing you to unlock even more devastating ring attacks. Why the 320x240 Version?
The 320x240 resolution was a standard for many iconic QWERTY and landscape-oriented phones (like the Nokia E-series or BlackBerry). This specific build ensures: Proper Aspect Ratio
: No stretched sprites or cut-off menus; the UI is tailor-made for horizontal screens. Smooth Performance
: Java games are notoriously lightweight, making them playable even on low-spec vintage hardware. Where to Find It
While official storefronts for J2ME games have largely disappeared, the community keeps these titles alive through archives. You can often find the 2011 Green Lantern Java Game on community-driven sites like sites.google.com/view/ofintioka or various dedicated "mobile game" archival forums. Final Verdict:
It’s a competent movie tie-in that serves its purpose: letting you run wild with a Green Lantern ring on a bunch of bad guys. If you’re a fan of the DC mythos and love retro mobile gaming, this is a must-have for your library. installation instructions for a specific device or help setting up a Java emulator Green Lantern: Rise of the Manhunters Review
The Ultimate Green Lantern Java Game Experience: 320x240 Updated Version
Are you a fan of the Green Lantern superhero and Java games? Look no further! In this article, we'll dive into the world of Green Lantern Java games, specifically focusing on the 320x240 updated version. Get ready to relive the action-packed adventures of Hal Jordan and his trusty power ring.
Introduction to Green Lantern Java Games
Green Lantern, a popular DC Comics superhero, has been featured in numerous video games across various platforms. Java games, in particular, have been a staple for mobile gamers, offering a range of exciting experiences on-the-go. The Green Lantern Java game series has captivated fans worldwide with its engaging gameplay, stunning graphics, and faithful adaptation of the comic book source material.
What Makes the 320x240 Updated Version Special?
The 320x240 updated version of the Green Lantern Java game is a significant upgrade from its predecessors. With a higher resolution and improved graphics, this version provides a more immersive gaming experience. The increased screen size allows for more detailed character models, environments, and special effects, drawing players deeper into the world of the Green Lantern Corps. green lantern java game 320x240 upd
Gameplay Features and Mechanics
In the Green Lantern Java game 320x240 updated version, players take on the role of Hal Jordan, the original Green Lantern. The game's storyline follows the movie's plot, with some additional comic book-inspired elements. As Hal Jordan, you'll face off against iconic villains like Sinestro, Parallax, and the Manhunters.
The gameplay mechanics involve a mix of side-scrolling action, combat, and puzzle-solving. Players can control Hal Jordan's movements, jumping, and attacks, while utilizing his power ring to create objects, construct platforms, and blast enemies. The ring's abilities are essential to progress through the levels, and players must use their wits to overcome obstacles and defeat foes.
Key Features of the 320x240 Updated Version
- Improved Graphics: With a resolution of 320x240 pixels, the updated version boasts crisp and vibrant visuals, bringing the world of Green Lantern to life.
- Increased Level Count: The game features a range of levels, each with its unique challenges, enemies, and boss battles.
- Upgraded Soundtrack: An energetic and atmospheric soundtrack complements the on-screen action, enhancing the overall gaming experience.
- Intuitive Controls: Easy-to-use controls ensure that players can focus on the action, rather than struggling with complicated button layouts.
Benefits of Playing the Green Lantern Java Game 320x240 Updated Version
- Nostalgia: For fans of the comic book series, the movie, or previous Green Lantern games, this updated version offers a chance to relive fond memories and experience the character in a new way.
- Accessible Gameplay: The Java game's platform independence makes it easy to play on a range of devices, from older smartphones to feature phones.
- Challenge and Fun: With engaging gameplay mechanics and a variety of challenges, the Green Lantern Java game 320x240 updated version provides hours of entertainment.
Tips and Tricks for Mastering the Game
- Master the Power Ring: Learn to use Hal Jordan's power ring effectively, creating objects and using them to overcome obstacles and defeat enemies.
- Explore Levels: Take time to explore each level, searching for hidden paths, secrets, and collectibles.
- Upgrade Your Skills: As you progress through the game, focus on upgrading Hal Jordan's abilities and power ring to increase your chances of success.
Conclusion
The Green Lantern Java game 320x240 updated version is a must-play for fans of the superhero and Java games. With its engaging gameplay, improved graphics, and faithful adaptation of the source material, this game offers a compelling experience. Whether you're a seasoned gamer or just looking for a fun, action-packed adventure, the Green Lantern Java game 320x240 updated version is an excellent choice.
Get Ready to Join the Green Lantern Corps!
So, are you ready to join Hal Jordan and the Green Lantern Corps in their quest to protect the universe? Download the Green Lantern Java game 320x240 updated version today and experience the thrill of being a Green Lantern!
Additional Resources
- Game Download: Find the Green Lantern Java game 320x240 updated version on your favorite Java game download sites or mobile app stores.
- Game Forums: Join online forums and communities to discuss the game, share tips, and connect with fellow fans.
- Green Lantern Comics and Movies: Explore the world of Green Lantern further by reading the comics or watching the movies.
By joining the world of Green Lantern Java games, you'll become a part of a vibrant community of fans and gamers. Get ready to experience the excitement of being a Green Lantern!
Green Lantern: Rise of the Manhunters (2011) is the official Java mobile game developed by Gameloft to tie in with the live-action movie.
Because the landscape screen resolution of 320x240 was standard for mid-to-high-end feature phones of that era (like the Nokia E-series and some BlackBerry devices), it is highly sought after by retro mobile gamers. 🕹️ Gameplay & Controls
The game is a 2D side-scrolling action brawler. You control Hal Jordan as he battles the Manhunters across several alien planets. D-Pad / 2, 4, 6, 8: Move Hal, duck, and jump. 5 / Center Key: Standard melee attack.
1, 3, 7, 9: Quick-use keys for your green energy construct weapons (e.g., giant swords, maces, or gatling guns).
0: Activate heavy area-of-effect Green Lantern shield or blast. 🗺️ Quick Walkthrough Guide Chapter 1: The Invasion of Oa
Objective: Defend the Green Lantern Citadel from the sudden Manhunter attack.
Tip: Focus on mastering the basic combo: 3 quick hits followed by a construct heavy attack. Watch your green energy meter; don't let it deplete entirely or you'll have to wait for it to recharge. Chapter 2: Sector Patrols Objective: Fight off airborne and shielded enemies. The Lantern Corps in Your Pocket: Green Lantern
Tip: Flying enemies are best handled by jumping and executing an aerial construct slam. For shielded Manhunters, use a heavy charged attack to break their guard before executing a combo. Chapter 3: The Final Stand Objective: Defeat the Ultra Manhunter boss.
Tip: The final boss has highly telegraphed ground-pound and laser attacks. Roll or jump out of the red warning zones, wait for its shield to drop, and unload your construct attacks. 💾 How to Find and Play It Today
Since the official mobile storefronts for Java (J2ME) games are long gone, you have to rely on community preservation archives and emulation. Step 1: Finding the File
Search on the Internet Archive or dedicated community preservation sites like Dedomil or Phoneky.
Search specifically for "Green Lantern Gameloft 320x240 jar". Ensure the file has the .jar extension. Step 2: Emulating the Game
You cannot run .jar files natively on modern smartphones or PCs without an emulator.
For Android: Download J2ME Loader from the Google Play Store. It is highly compatible and allows you to map custom on-screen keyboards for 320x240 setups.
For PC: Use KEmulator or MicroEmulator. These are lightweight programs that perfectly mimic the classic Nokia/Sony Ericsson operating systems.
Everyone Forgot This Green Lantern Game… Is It Actually Good?
5.3 Rendering loop example (pseudo-code)
protected void paint(Graphics g)
// draw to offscreen first
Graphics offG = offscreen.getGraphics();
offG.setColor(0x000000);
offG.fillRect(0, 0, 320, 240);
// draw parallax stars (two layers)
drawStars(offG, scrollX);
// player, enemies, bullets, constructs
player.paint(offG);
enemyManager.paint(offG);
// HUD
drawHUD(offG);
// blit to screen
g.drawImage(offscreen, 0, 0, Graphics.TOP
Summary
The file you are looking for is the **Gameloft adaptation of Green Lantern (
Green Lantern for Java (320x240) is a classic side-scrolling action game based on the DC Comics superhero. Players take control of Hal Jordan, using the Power Ring to create constructs and defeat enemies across various interstellar levels. 🕹️ Game Features Resolution: Optimized for 320x240 screen displays. Combat: Use "constructs" like giant fists and blades. Story: Follows Hal Jordan's battle against the Manhunters. Platform: Compatible with J2ME-supported mobile devices. 📥 Updates in the "UPD" Version Performance: Smoother frame rates on older hardware. Bug Fixes: Resolved glitches in the collision detection.
Compatibility: Better support for newer Nokia and Sony Ericsson handsets. Controls: Refined d-pad responsiveness for faster combat. 🛠️ How to Play Installation: Transfer the .jar or .jad file to your phone.
Keys: Usually uses 2, 4, 6, 8 for movement and 5 for attacks.
Power: Monitor your ring charge to ensure you can use constructs. To help you get the right version for your device: Specific phone model (e.g., Nokia N95, Samsung B3410) Language preference (English, Spanish, etc.) File format needed (.jar or .jad)
If you share these details, I can find the exact download link or emulator settings for you.
The search for Green Lantern: Rise of the Manhunters 320x240 Java (.jar) format
typically refers to the mobile version released alongside the 2011 film. While the game was prominent on consoles, a dedicated 2D side-scrolling version was developed for J2ME-capable feature phones. Key Game Features
Use "hard-light" constructs like giant fists, gatling guns, and war hammers to fight the Manhunter androids. Progression: Improved Graphics : With a resolution of 320x240
Collect energy to perform more powerful attacks and upgrade your health and energy stats.
Features a mix of side-scrolling beat-em-up action and flying sequences where you blast enemies in space. How to Run the Game Today
Since 320x240 Java games were designed for older "feature phones" (like Nokia S60 or Sony Ericsson devices), you need an emulator to play them on modern hardware: J2ME Loader . These allow you to load files and set the resolution specifically to On Android: J2ME Loader app
is the standard for running old mobile games. It handles scaling and onscreen controls for touch devices. Installation: Once you have a compatible
file, simply open it through the emulator's file manager to start the installation process. Always ensure your emulator is configured to
to prevent the graphics from appearing stretched or cropped. for your current device?
You can save this as GreenLanternGame.java and compile it with the J2ME Wireless Toolkit.
// GreenLanternGame.java
// A story-driven action game for 320x240 screens
// Controls: Left/Right = Move, Fire = Shoot, Up = Fly Up (in flight segments)
import javax.microedition.lcdui.;
import javax.microedition.midlet.;
import java.util.Random;
public class GreenLanternGame extends MIDlet implements CommandListener, Runnable {
private Display display;
private GameCanvas canvas;
private Command exitCommand;
private Command backCommand;
private boolean running;
private Thread gameThread;
private int gameState; // 0=menu, 1=level1, 2=level2, 3=level3, 4=cutscene, 5=gameOver, 6=victory
private int cutsceneStep;
private long cutsceneTimer;
// Game objects
private int playerX, playerY;
private int[] enemiesX, enemiesY;
private boolean[] enemiesAlive;
private int[] bulletsX, bulletsY;
private boolean[] bulletsActive;
private int score;
private int lives;
private int energy; // Green Lantern ring energy
private int levelProgress;
private Random rand;
private String storyText;
// Flight segment variables
private boolean flightMode;
private int obstacleX;
private int scrollY;
public GreenLanternGame()
display = Display.getDisplay(this);
canvas = new GameCanvas();
exitCommand = new Command("Exit", Command.EXIT, 1);
backCommand = new Command("Back", Command.BACK, 1);
canvas.addCommand(exitCommand);
canvas.setCommandListener(this);
rand = new Random();
gameState = 0; // menu
enemiesX = new int[10];
enemiesY = new int[10];
enemiesAlive = new boolean[10];
bulletsX = new int[10];
bulletsY = new int[10];
bulletsActive = new boolean[10];
score = 0;
lives = 3;
energy = 100;
flightMode = false;
public void startApp()
display.setCurrent(canvas);
running = true;
gameThread = new Thread(this);
gameThread.start();
public void pauseApp() {}
public void destroyApp(boolean unconditional)
running = false;
public void commandAction(Command c, Displayable d)
if (c == exitCommand)
destroyApp(true);
notifyDestroyed();
else if (c == backCommand && gameState == 5)
gameState = 0; // back to menu
resetGame();
private void resetGame()
score = 0;
lives = 3;
energy = 100;
levelProgress = 0;
flightMode = false;
gameState = 0;
private void startLevel(int level)
playerX = 140;
playerY = 200;
flightMode = false;
levelProgress = 0;
energy = 100;
// Initialize enemies
for (int i = 0; i < 10; i++)
enemiesX[i] = 20 + rand.nextInt(280);
enemiesY[i] = -50 - (i * 50);
enemiesAlive[i] = true;
// Clear bullets
for (int i = 0; i < 10; i++) bulletsActive[i] = false;
if (level == 2)
storyText = "Sinestro's fear constructs attack!";
flightMode = true;
scrollY = 0;
obstacleX = rand.nextInt(280);
else if (level == 3)
storyText = "Parallax rises. Willpower is your only weapon.";
public void run() {
while (running) {
try
updateGame();
canvas.repaint();
Thread.sleep(50); // ~20 FPS
catch (Exception e) {}
}
}
private void updateGame()
int keyState = canvas.getKeyStates();
if (gameState == 0)
// Menu state - story-driven menu
if (keyState != 0)
gameState = 4; // start cutscene
cutsceneStep = 0;
cutsceneTimer = System.currentTimeMillis();
storyText = "In brightest day, in blackest night...";
return;
if (gameState == 4) // Cutscene
if (System.currentTimeMillis() - cutsceneTimer > 3000)
cutsceneStep++;
cutsceneTimer = System.currentTimeMillis();
switch(cutsceneStep)
case 1: storyText = "No evil shall escape my sight!"; break;
case 2: storyText = "Let those who worship evil's might..."; break;
case 3: storyText = "Beware my power... GREEN LANTERN'S LIGHT!"; break;
case 4: gameState = 1; startLevel(1); break;
return;
if (gameState == 5) // Game Over
return;
if (gameState == 6) // Victory
if (keyState != 0)
gameState = 0;
resetGame();
return;
// --- GAMEPLAY UPDATE ---
if (flightMode)
// Flight segment (Level 2)
scrollY += 8;
if (scrollY > 240)
scrollY = 0;
obstacleX = rand.nextInt(280);
// Move player in flight mode
if ((keyState & LEFT_PRESSED) != 0) playerX -= 6;
if ((keyState & RIGHT_PRESSED) != 0) playerX += 6;
if ((keyState & UP_PRESSED) != 0) playerY -= 5;
if ((keyState & DOWN_PRESSED) != 0) playerY += 5;
// Boundaries
if (playerX < 10) playerX = 10;
if (playerX > 310) playerX = 310;
if (playerY < 20) playerY = 20;
if (playerY > 230) playerY = 230;
// Collision with obstacle
if (Math.abs(playerX - obstacleX) < 20 && scrollY > 200)
energy -= 20;
if (energy <= 0)
lives--;
if (lives <= 0) gameState = 5;
else startLevel(2);
obstacleX = rand.nextInt(280);
scrollY = 0;
// Level progress
levelProgress++;
if (levelProgress > 200)
gameState = 3; // go to level 3
startLevel(3);
flightMode = false;
else
// Ground combat levels (1 and 3)
// Player movement
if ((keyState & LEFT_PRESSED) != 0) playerX -= 5;
if ((keyState & RIGHT_PRESSED) != 0) playerX += 5;
if (playerX < 10) playerX = 10;
if (playerX > 310) playerX = 310;
// Shooting
if ((keyState & FIRE_PRESSED) != 0)
for (int i = 0; i < 10; i++)
if (!bulletsActive[i])
bulletsActive[i] = true;
bulletsX[i] = playerX;
bulletsY[i] = playerY - 10;
break;
// Update bullets
for (int i = 0; i < 10; i++)
if (bulletsActive[i])
bulletsY[i] -= 8;
if (bulletsY[i] < 0) bulletsActive[i] = false;
// Check collision
for (int j = 0; j < 10; j++)
if (enemiesAlive[j] && Math.abs(bulletsX[i] - enemiesX[j]) < 15 &&
Math.abs(bulletsY[i] - enemiesY[j]) < 15)
enemiesAlive[j] = false;
bulletsActive[i] = false;
score += 10;
levelProgress++;
// Update enemies
for (int i = 0; i < 10; i++)
if (enemiesAlive[i])
enemiesY[i] += 3;
if (enemiesY[i] > 240)
enemiesY[i] = -20;
enemiesX[i] = 20 + rand.nextInt(280);
// Enemy hits player
if (Math.abs(playerX - enemiesX[i]) < 20 && Math.abs(playerY - enemiesY[i]) < 20)
energy -= 15;
enemiesAlive[i] = false;
if (energy <= 0)
lives--;
if (lives <= 0) gameState = 5;
else startLevel(gameState);
enemiesY[i] = -20;
// Level progression
if (levelProgress >= 20)
if (gameState == 1)
gameState = 2;
startLevel(2);
else if (gameState == 3)
gameState = 6; // Victory
// Regenerate energy slowly
if (energy < 100 && !flightMode) energy++;
class GameCanvas extends Canvas
private Font titleFont = Font.getFont(Font.FACE_PROPORTIONAL, Font.STYLE_BOLD, Font.SIZE_LARGE);
private Font textFont = Font.getFont(Font.FACE_PROPORTIONAL, Font.STYLE_PLAIN, Font.SIZE_SMALL);
public void paint(Graphics g)
// Black background
g.setColor(0, 0, 0);
g.fillRect(0, 0, getWidth(), getHeight());
if (gameState == 0)
// Menu Screen
g.setColor(0, 255, 0);
g.setFont(titleFont);
g.drawString("GREEN LANTERN", 160, 40, Graphics.HCENTER);
g.setColor(100, 255, 100);
g.setFont(textFont);
g.drawString("Press any key", 160, 120, Graphics.HCENTER);
g.drawString("Defeat Sinestro", 160, 150, Graphics.HCENTER);
g.drawString("Protect Oa", 160, 180, Graphics.HCENTER);
// Green Lantern symbol
g.setColor(0, 180, 0);
g.fillArc(130, 80, 60, 60, 0, 360);
g.setColor(0, 0, 0);
g.fillArc(140, 90, 40, 40, 0, 360);
else if (gameState == 4)
// Cutscene
g.setColor(0, 255, 0);
g.setFont(titleFont);
g.drawString("STORY", 160, 30, Graphics.HCENTER);
g.setFont(textFont);
g.drawString(storyText, 160, 100, Graphics.HCENTER);
g.drawString("You are Hal Jordan", 160, 140, Graphics.HCENTER);
g.drawString("Last hope of the Corps", 160, 170, Graphics.HCENTER);
else if (gameState == 5)
// Game Over
g.setColor(255, 0, 0);
g.setFont(titleFont);
g.drawString("GAME OVER", 160, 80, Graphics.HCENTER);
g.setColor(200, 200, 200);
g.setFont(textFont);
g.drawString("Score: " + score, 160, 140, Graphics.HCENTER);
g.drawString("Press Back to Menu", 160, 200, Graphics.HCENTER);
else if (gameState == 6)
// Victory
g.setColor(0, 255, 0);
g.setFont(titleFont);
g.drawString("VICTORY!", 160, 60, Graphics.HCENTER);
g.setFont(textFont);
g.drawString("You have mastered", 160, 110, Graphics.HCENTER);
g.drawString("the willpower!", 160, 135, Graphics.HCENTER);
g.drawString("Oa is saved.", 160, 160, Graphics.HCENTER);
g.drawString("Press any key", 160, 210, Graphics.HCENTER);
else
// Gameplay Screen
// Draw UI
g.setColor(0, 255, 0);
g.drawString("Score: " + score, 5, 5, Graphics.LEFT);
g.drawString("Lives: " + lives, 5, 20, Graphics.LEFT);
g.drawString("Energy: " + energy, 5, 35, Graphics.LEFT);
// Energy bar
g.setColor(50, 50, 50);
g.fillRect(80, 35, 100, 8);
g.setColor(0, 255, 0);
g.fillRect(80, 35, energy, 8);
// Draw story hint
if (gameState == 1) g.drawString("Earth Invasion", 200, 5, Graphics.LEFT);
else if (gameState == 2) g.drawString("Flight: Avoid fear!", 200, 5, Graphics.LEFT);
else if (gameState == 3) g.drawString("Parallax Boss", 200, 5, Graphics.LEFT);
if (flightMode)
// Flight mode graphics
g.setColor(0, 100, 0);
g.fillRect(0, 0, 320, 240);
// Starfield
for (int i = 0; i < 50; i++)
g.setColor(255, 255, 255);
g.drawLine(i * 7, (scrollY + i * 10) % 240, i * 7, (scrollY + i * 10) % 240);
// Obstacle (fear construct)
g.setColor(100, 0, 100);
g.fillRect(obstacleX, scrollY, 25, 25);
g.setColor(200, 0, 200);
g.drawString("FEAR", obstacleX + 2, scrollY + 8, Graphics.LEFT);
// Player - Green Lantern
g.setColor(0, 255, 0);
g.fillArc(playerX - 10, playerY - 10, 20, 20, 0, 360);
g.setColor(0, 180, 0);
g.fillArc(playerX - 6, playerY - 6, 12, 12, 0, 360);
else
// Ground combat
// Draw ground
g.setColor(30, 30, 30);
g.fillRect(0, 210, 320, 30);
// Draw enemies (Sinestro Corps)
for (int i = 0; i < 10; i++)
if (enemiesAlive[i])
g.setColor(100, 0, 255);
g.fillRect(enemiesX[i] - 8, enemiesY[i] - 8, 16, 16);
g.setColor(200, 100, 255);
g.drawString("S", enemiesX[i] - 3, enemiesY[i] - 5, Graphics.LEFT);
// Draw bullets
for (int i = 0; i < 10; i++)
if (bulletsActive[i])
g.setColor(0, 255, 0);
g.fillRect(bulletsX[i] - 2, bulletsY[i] - 4, 4, 8);
// Draw player - Green Lantern
g.setColor(0, 255, 0);
g.fillArc(playerX - 12, playerY - 12, 24, 24, 0, 360);
g.setColor(0, 200, 0);
g.fillArc(playerX - 6, playerY - 6, 12, 12, 0, 360);
// Ring glow effect
g.setColor(0, 255, 0, true);
for (int i = 0; i < 3; i++)
g.drawArc(playerX - 15 - i, playerY - 15 - i, 30 + i * 2, 30 + i * 2, 0, 360);
// Story text during gameplay
if (storyText != null && gameState < 4)
g.setColor(0, 0, 0);
g.fillRect(10, 200, 300, 30);
g.setColor(0, 255, 0);
g.drawString(storyText, 160, 210, Graphics.HCENTER);
}
Call to Action
If you successfully downloaded and played the Green Lantern Java game 320x240 UPD, share your setup in the comments below. Which phone or emulator gave you the best experience? And if you encounter a new bug, report it to the J2ME preservation forums – the next “UPD” might come from you.
Article last updated: January 2025
Keywords: green lantern java game 320x240 upd, green lantern java game jar 320x240, download green lantern 240x320 java, green lantern gameloft upd patch, j2me green lantern full version qvga
This article is for educational and preservation purposes. Download and play only if you own a legitimate copy of the original game.
4.4 Audio
- Background MIDI (Green Lantern theme simplified)
- SFX: beam, construct deploy, shield block, hit, power-up
Java ME Source Code (GreenLanternGame.java)
import javax.microedition.lcdui.*;
import javax.microedition.midlet.MIDlet;
import javax.microedition.midlet.MIDletStateChangeException;
import java.util.Random;
import java.util.Vector;
public class GreenLanternGame extends MIDlet implements CommandListener {
private Display display;
private GameCanvas canvas;
private Command exitCommand;
public GreenLanternGame()
display = Display.getDisplay(this);
canvas = new GameScreen();
exitCommand = new Command("Exit", Command.EXIT, 0);
canvas.addCommand(exitCommand);
canvas.setCommandListener(this);
protected void startApp() throws MIDletStateChangeException
display.setCurrent(canvas);
protected void pauseApp() {}
protected void destroyApp(boolean unconditional) throws MIDletStateChangeException {}
public void commandAction(Command c, Displayable d)
if (c == exitCommand)
try
destroyApp(false);
catch (MIDletStateChangeException e)
e.printStackTrace();
notifyDestroyed();
}
class GameScreen extends GameCanvas implements Runnable
private boolean running;
private int width, height;
private int playerX, playerY;
private int score;
private int lives;
private Vector enemies;
private Vector projectiles;
private Random random;
private Graphics g;
// Sprite size
private final int SIZE = 20;
public GameScreen()
super(true);
width = getWidth();
height = getHeight();
// Init game state
playerX = width / 2;
playerY = height - 40;
score = 0;
lives = 3;
enemies = new Vector();
projectiles = new Vector();
random = new Random();
running = true;
Thread t = new Thread(this);
t.start();
public void run()
while (running)
update();
draw();
try
Thread.sleep(30); // ~33 FPS
catch (InterruptedException ie)
// Handle exception
private void update()
// 1. Input Handling
int keyState = getKeyStates();
if ((keyState & LEFT_PRESSED) != 0 && playerX > 0)
playerX -= 5;
if ((keyState & RIGHT_PRESSED) != 0 && playerX < width - SIZE)
playerX += 5;
if ((keyState & UP_PRESSED) != 0 && playerY > 0)
playerY -= 5;
if ((keyState & DOWN_PRESSED) != 0 && playerY < height - SIZE)
playerY += 5;
// Auto-fire logic (Green Energy Constructs)
if (random.nextInt(15) == 0)
projectiles.addElement(new Projectile(playerX + SIZE/2, playerY));
// 2. Spawn Enemies (Yellow Impurity)
if (random.nextInt(20) == 0)
int ex = random.nextInt(width - SIZE);
enemies.addElement(new Enemy(ex, -SIZE));
// 3. Move Projectiles
for (int i = 0; i < projectiles.size(); i++)
Projectile p = (Projectile) projectiles.elementAt(i);
p.move();
if (p.y < 0) projectiles.removeElementAt(i);
// 4. Move Enemies & Check Collision
for (int i = 0; i < enemies.size(); i++)
Enemy e = (Enemy) enemies.elementAt(i);
e.move();
// Remove if off screen
if (e.y > height)
enemies.removeElementAt(i);
continue;
// Check collision with Player
if (checkCollision(playerX, playerY, SIZE, SIZE, e.x, e.y, SIZE, SIZE))
enemies.removeElementAt(i);
lives--;
if (lives <= 0)
running = false; // Game Over
// Check collision with Projectiles
for (int j = 0; j < projectiles.size(); j++)
Projectile p = (Projectile) projectiles.elementAt(j);
if (checkCollision(p.x, p.y, 4, 8, e.x, e.y, SIZE, SIZE))
enemies.removeElementAt(i);
projectiles.removeElementAt(j);
score += 10;
break;
private boolean checkCollision(int x1, int y1, int w1, int h1, int x2, int y2, int w2, int h2)
return (x1 < x2 + w2 && x1 + w1 > x2 && y1 < y2 + h2 && y1 + h1 > y2);
private void draw() Graphics.RIGHT);
// Draw Player (Green Lantern Symbol simplified)
g.setColor(0, 255, 0); // Bright Green
g.fillRect(playerX, playerY, SIZE, SIZE);
g.setColor(0, 100, 0); // Darker circle
g.fillArc(playerX + 2, playerY + 2, SIZE - 4, SIZE - 4, 0, 360);
// Draw Projectiles (Green Light)
g.setColor(0, 255, 100);
for (int i = 0; i < projectiles.size(); i++)
Projectile p = (Projectile) projectiles.elementAt(i);
g.fillRect(p.x, p.y, 4, 8);
// Draw Enemies (Yellow Impurity)
g.setColor(255, 255, 0); // Bright Yellow
for (int i = 0; i < enemies.size(); i++)
Enemy e = (Enemy) enemies.elementAt(i);
g.fillRect(e.x, e.y, SIZE, SIZE);
flushGraphics();
// --- Helper Classes ---
class Projectile
int x, y;
public Projectile(int x, int y)
this.x = x;
this.y = y;
public void move()
y -= 8; // Speed of light!
class Enemy
int x, y;
public Enemy(int x, int y)
this.x = x;
this.y = y;
public void move()
y += 3; // Descending speed
How to Install on Original Java Phones (Nokia, Sony Ericsson, Samsung)
If you still own a classic feature phone, follow these steps:
- Transfer the .JAR file – Use Bluetooth (OBEX) or a microSD card. Put the file in the
Other or Applications folder.
- Disable Verification – On some Nokia phones, you must go to Settings > App Manager > Software Installation > All.
- Install – Open the file via the file manager. Accept permissions (often “Allow” for network access).
- Set Screen Size – If the game offers a resolution choice at startup, select 320x240 (not “Full screen” unless tested).
Known device compatibility:
- ✅ Nokia N95, N82, 5800 XpressMusic
- ✅ Sony Ericsson K810i, W910i, C905
- ✅ Samsung D900i, U600
- ❌ Older 128x160 devices (will crash)
Where to Download the Green Lantern Java Game 320x240 UPD
Warning: Many “free Java game” sites are filled with malware or incorrect files. The following sources are community-recommended as of this 2025 UPD:
- Dedicated J2ME Archives – Sites like Phoneky.com or Dedomil.net often host verified 320x240 conversions. Search for “Green Lantern 240x320” (note: the order sometimes flips).
- Internet Archive (archive.org) – Look for the “J2ME Game Preservation Project” which includes an UPD folder with screen-fixed versions.
- Reddit r/J2MEgaming – Users frequently share Google Drive or Mediafire links to the patched .JAR file.
File check: A legitimate Green Lantern Java game (320x240 UPD) should be approximately 650KB to 1.2MB in size. If your file is smaller, it’s likely a demo or broken export.
Note: Due to copyright, I cannot provide direct links, but the above sources are widely used by the preservation community.