The "Diamond Rush" mobile game remains one of the most iconic relics of the pre-smartphone era. Originally developed by Gameloft, this puzzle-adventure title defined the gaming experience for millions of users on Java-enabled (J2ME) devices. Specifically, the 320x240 resolution variant represents a pivotal moment in mobile gaming history, catering to the "landscape" screens of popular devices like the Nokia E-series and BlackBerry models. The Gameplay Mechanic
At its core, Diamond Rush is a brilliant blend of strategy and reflexes. Players take on the role of an intrepid explorer navigating through treacherous environments, including the temples of Angkor Wat, the frozen caves of Bavaria, and the fiery pits of Siberia. The goal is simple yet addictive: collect a specific number of diamonds to unlock the exit while avoiding traps, rolling boulders, and various mythical enemies.
The 320x240 version was particularly praised for its visual clarity. On a wider screen, the level design felt more expansive, allowing players to see approaching threats or hidden secrets more easily than on the cramped 128x160 or 240x320 portrait screens. Technical Nostalgia: The .JAR Format
The mention of a .JAR file (Java Archive) evokes a specific era of digital distribution. Before centralized app stores like Google Play or the iOS App Store, gamers would "sideload" these files onto their phones via Bluetooth, Infrared, or SD cards. A "new" or optimized JAR for 320x240 often implies a version that has been patched for better compatibility with modern emulators or late-stage Java handsets, ensuring that the frame rates remain smooth and the controls responsive. Why It Endures Why do people still search for Diamond Rush today?
Level Design: The puzzles require genuine thought. One wrong move with a boulder can render a level unsolvable, forcing a restart.
Secret Areas: The game is famous for its "hidden" diamonds and secret levels, rewarding players for exploring every corner.
Atmosphere: Despite the pixelated graphics, the soundtrack and environmental sound effects created a surprisingly immersive sense of adventure. Conclusion
The quest for the perfect Diamond Rush 320x240 JAR file is more than just a search for a game; it is a pursuit of digital nostalgia. It represents a time when mobile games relied on clever mechanics and tight level design rather than microtransactions and constant internet connectivity. Whether played on an old Nokia or a modern emulator, Diamond Rush stands as a masterclass in 2D puzzle platforming.
The "Diamond Rush" jar version (320x240) is a specific landscape adaptation of the classic Gameloft mobile adventure originally designed for Nokia feature phones
A standout feature of this particular resolution and version is its optimized landscape exploration
. Unlike the standard portrait versions found on older devices, the 320x240 build (often associated with devices like the Nokia Asha 201) offers a wider field of view that significantly changes how you approach the game's 200+ puzzles. Key Feature: Tactical "True-Landscape" Awareness
In the 320x240 version, the horizontal screen orientation provides unique tactical advantages: Wider Threat Detection
: The extended screen width allows you to see incoming hazards, like rolling boulders or lunging snakes, from a further distance compared to narrower portrait screens. Puzzle Foresight
: Since many of the 40 levels involve complex rock-pushing mechanics, the wider view helps you plan several moves ahead by showing more of the cavern's layout at once. Asha-Specific Optimization
: This specific .jar file is known for being highly optimized for "Asha" class hardware, often running at a stable 20 FPS, which is smoother than many generic emulated versions. Technical Quirks of the 320x240 Build
Because this version was squeezed to fit landscape displays, it includes some "new" or unique characteristics: UI Adjustments
: To save vertical space, the main menu often omits the "credits" tab, and the game typically uses the phone's native font rather than the original custom pixel font. Language-Locking
: This version frequently defaults to the device's native system language with no in-game option to switch, though it supports major European languages. Secret Exit Warning
: A known quirk in some 320x240 builds is that taking a secret exit after grabbing a red diamond may fail to register that diamond on the world map, potentially preventing a 100% completion score. Further Exploration Get a deep dive into the original mechanics and lore on the Diamond Rush Wiki
Read community discussions about finding and running this rare landscape version on Reddit's J2ME Gaming community Check out the Internet Archive
for preserved versions and original descriptions of the game's 40 levels. diamond rush jar 320x240 new
Diamond Rush remains one of the most iconic mobile games from the pre-smartphone era. Originally developed by Gameloft, this puzzle-platformer captured the hearts of millions with its challenging traps, hidden secrets, and addictive gameplay. Even years after the decline of Java-based phones, players are still searching for the Diamond Rush JAR 320x240 NEW version to relive those memories on modern devices or legacy hardware.
The 320x240 resolution was the gold standard for landscape-oriented feature phones, such as the Nokia E-series or various Samsung and Sony Ericsson models. Finding a "new" or optimized version of the JAR file ensures that the graphics are crisp and the controls are responsive, avoiding the stretching or lagging issues common with poorly ported versions. Why Diamond Rush Stays Popular
Intricate Level Design: Explore the ancient ruins of Angkor Wat, the icy caverns of Siberia, and the lava-filled temples of Mexico.
Brain-Teasing Puzzles: Success isn't just about jumping; you must move boulders, use tools, and find keys to progress.
Hidden Secrets: Every map contains secret rooms and extra diamonds that challenge even the most veteran players.
Epic Boss Fights: Each world ends with a unique boss encounter that tests both your timing and strategy. Key Features of the 320x240 Version
The 320x240 resolution offers the best visual balance for this specific game. Unlike the smaller 128x160 or 240x320 portrait versions, the landscape 320x240 view provides a wider perspective of the level. This extra screen real estate is crucial for spotting incoming boulders or hidden traps before they end your run. The "NEW" optimized versions often include:
Improved Frame Rates: Smoother character movement and physics.
Sound Fixes: High-quality MIDI tracks and sound effects that don't crackle.
Emulator Compatibility: Better performance when running on J2ME loaders for Android or PC. How to Play Diamond Rush Today
If you no longer have a physical Nokia or Sony Ericsson phone, you can still enjoy Diamond Rush through emulation.
Android: Download a J2ME Loader from the Play Store. This allows you to run JAR files directly on your smartphone with customizable on-screen controls.
PC: Use KEmulator or MicroEmulator. These tools let you load the 320x240 JAR file and play using your computer keyboard.
Original Hardware: If you have a legacy phone, simply transfer the JAR file via Bluetooth or SD card and install it directly.
Diamond Rush is more than just a game; it is a piece of mobile gaming history. Whether you are looking to complete the game for the first time or aiming for a 100% secret completion run, the 320x240 JAR version provides the most authentic experience possible. To help you get the best experience, let me know:
Are you playing on an Android phone, PC, or original hardware?
Searching for Diamond Rush 320x240 landscape resolution can be tricky, as many older archives primarily hosted the standard portrait version (240x320). Here is the latest information on the 320x240 .JAR file and how to play it. Game Overview
Originally released by Gameloft in 2006, Diamond Rush is a classic 2D puzzle-platformer where you navigate dangerous caverns in Angkor Wat, Bavaria, and Siberia to collect diamonds. 40 levels with over 200 puzzles. Key Items:
Compass (pathfinding), Hammer (enemies), and Hook (distant objects). Cheat Code: at a seal to open a secret menu. 320x240 Version Details
Finding a working 320x240 version (specifically designed for landscape devices like the Nokia Asha 201) often requires looking through specialized archives. 1.1.11 is often cited as the stable 320x240 build. Languages: The "Diamond Rush" mobile game remains one of
Includes English, German, French, Romanian, Hungarian, and Polish (usually defaults to your device's native language). Known Quirks:
Due to the shorter screen height, the "Credits" tab is often missing from the main menu, and the game may use your device's native system font instead of the custom game font. How to Install and Play
Since modern smartphones do not natively support .JAR files, you will need an emulator. For Android: Download the J2ME Loader
from the Google Play Store. It allows you to run Java games and adjust screen resolution settings to 320x240. Download the File: Community members on
Classic mobile gaming fans, this one is for you! If you’ve been hunting for the legendary Diamond Rush in its elusive 320x240 landscape JAR
format, we’ve got the lowdown on why this specific version is such a "gem" to find. 💎 Why the 320x240 Version? While most remember Diamond Rush in its standard portrait mode, the 320x240 resolution
was specifically built for landscape-screen devices like the Nokia Asha 201 Native Landscape Experience:
Unlike stretched versions, this is optimized for the wider screen, though it often lacks a "credits" tab because the interface is vertically compact. Unique Quirks: This version typically uses the device’s native font rather than the custom pixel font seen in other builds. The 100% Bug:
Heads up—some 320x240 versions have a known glitch where red diamonds collected via secret exits don't count toward your total on the map screen, making a 100% completion run tricky. 🎮 What’s the Rush? The core gameplay remains the same classic action-puzzle experience: 40 Levels: Traverse through Angkor Wat 200+ Puzzles:
Navigate falling stalactites, poisonous spiders, and fire traps. Secrets Galore:
Find silver and gold keys to unlock hidden chests for extra lives and rare diamonds. 🚀 How to Play in 2026
Since many original download links are now broken, modern players have a few options: J2ME Loader (Android): Use a Java emulator to run the original file on your smartphone. RetroArch: Enthusiasts often use the J2ME core in to play on handheld consoles like the Miyoo A30. Modern Remakes: For those who prefer a native app, Diamond Rush - Nokia Emulator is available on the Google Play Store , offering the original levels with modern touch controls.
If you have a compatible feature phone or an emulator, follow these steps:
If you want, I can generate specific filenames, sample short/long descriptions tailored to a store page, or produce the manifest in another format.
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
<title>Diamond Rush - Jar Piece Collector</title>
<style>
*
margin: 0;
padding: 0;
box-sizing: border-box;
user-select: none;
-webkit-tap-highlight-color: transparent;
body
background: linear-gradient(145deg, #1a472a 0%, #0e2a1a 100%);
min-height: 100vh;
display: flex;
justify-content: center;
align-items: center;
font-family: 'Segoe UI', 'Press Start 2P', 'Courier New', monospace;
padding: 20px;
/* Main game card container */
.game-container
background: #3c2a1f;
padding: 20px 25px 25px 25px;
border-radius: 60px 60px 40px 40px;
box-shadow: 0 20px 35px rgba(0,0,0,0.5), inset 0 1px 4px rgba(255,255,200,0.3);
border-bottom: 6px solid #1f140c;
/* JAR shaped wrapper - 320x240 viewport */
.jar-wrapper
position: relative;
width: 320px;
height: 240px;
background: radial-gradient(ellipse at 30% 20%, #e9f5e0, #c8dfb5);
border-radius: 0 0 80px 80px;
box-shadow: inset 0 0 0 4px #f9eec1, inset 0 0 0 8px #b98f5a, 0 10px 20px rgba(0,0,0,0.3);
overflow: hidden;
cursor: pointer;
transition: all 0.1s ease;
/* Glassy effect overlay */
.jar-wrapper::before
content: "";
position: absolute;
top: 0;
left: 0;
width: 100%;
height: 100%;
background: radial-gradient(circle at 20% 15%, rgba(255,255,220,0.4) 2%, transparent 70%);
pointer-events: none;
z-index: 2;
border-radius: inherit;
/* Metallic rim top */
.jar-wrapper::after
content: "";
position: absolute;
top: -12px;
left: 15px;
width: calc(100% - 30px);
height: 20px;
background: linear-gradient(135deg, #dbb87c, #b57c48, #e7c68e);
border-radius: 30px;
box-shadow: 0 2px 6px rgba(0,0,0,0.4);
z-index: 3;
/* Canvas inside jar where all diamond pieces live */
.jar-canvas
display: block;
width: 100%;
height: 100%;
background: radial-gradient(ellipse at 50% 60%, #fff7cf, #eedd99);
image-rendering: crisp-edges;
image-rendering: pixelated;
image-rendering: crisp-edges;
/* Score & piece counter - diamond rush style */
.dashboard
margin-top: 18px;
display: flex;
justify-content: space-between;
align-items: baseline;
background: #2d2116;
padding: 8px 20px;
border-radius: 60px;
box-shadow: inset 0 1px 3px #5e3e2a, 0 5px 8px black;
color: #ffecb3;
text-shadow: 2px 2px 0 #5a2e0e;
font-weight: bold;
.score-box
background: #010101aa;
backdrop-filter: blur(2px);
padding: 4px 14px;
border-radius: 40px;
font-family: 'Courier New', monospace;
font-size: 1.3rem;
letter-spacing: 2px;
background: #2a1c10;
box-shadow: inset 0 0 0 1px #f7cf7a, 0 2px 4px black;
.score-label
font-size: 0.7rem;
text-transform: uppercase;
margin-right: 8px;
letter-spacing: 1px;
.diamond-count
font-size: 1.7rem;
font-weight: bold;
color: #ffd966;
background: #1e130b;
padding: 0 12px;
border-radius: 50px;
line-height: 1.3;
.action-buttons
display: flex;
gap: 12px;
margin-top: 14px;
justify-content: center;
.rush-btn
background: #f5bc70;
border: none;
font-family: monospace;
font-weight: bold;
font-size: 0.8rem;
padding: 6px 18px;
border-radius: 40px;
color: #2c1a0c;
cursor: pointer;
transition: 0.05s linear;
box-shadow: 0 4px 0 #8b5a2b;
text-transform: uppercase;
letter-spacing: 1px;
.rush-btn:active
transform: translateY(2px);
box-shadow: 0 1px 0 #8b5a2b;
.reset-btn
background: #c9ae86;
box-shadow: 0 4px 0 #755e3a;
color: #2d2b1f;
.footer-tip
text-align: center;
margin-top: 14px;
font-size: 0.65rem;
color: #f7e3af;
background: #2e241b80;
border-radius: 20px;
padding: 5px 10px;
backdrop-filter: blur(2px);
font-weight: bold;
@keyframes pop
0% transform: scale(0.8); opacity: 0;
80% transform: scale(1.1);
100% transform: scale(1); opacity: 1;
.jar-wrapper:active
transform: scale(0.98);
</style>
</head>
<body>
<div>
<div class="game-container">
<div class="jar-wrapper" id="jarWrapper">
<canvas id="gameCanvas" class="jar-canvas" width="320" height="240"></canvas>
</div>
<div class="dashboard">
<span class="score-box"><span class="score-label">💎 RUSH</span> <span id="scoreValue">0</span></span>
<span class="diamond-count" id="pieceCount">⚡ 0</span>
</div>
<div class="action-buttons">
<button class="rush-btn" id="collectBtn">💎 COLLECT GEM</button>
<button class="rush-btn reset-btn" id="resetBtn">🔄 NEW JAR</button>
</div>
<div class="footer-tip">
🧙♂️ CLICK JAR OR PRESS COLLECT → ADD DIAMOND PIECES! RUSH MODE ACTIVE
</div>
</div>
</div>
<script>
(function()
// ---------- DIAMOND RUSH JAR - 320x240 ----------
// This simulation recreates the feeling of collecting diamond "pieces" inside a glass jar.
// Each diamond piece is a pixel-art style gem with sparkles, randomly positioned but never overlapping too much.
// "Diamond Rush" vibe: many pieces shine, collect more, jar fills with glittering treasures.
const canvas = document.getElementById('gameCanvas');
const ctx = canvas.getContext('2d');
// Dimensions fixed 320x240
const W = 320, H = 240;
// Array to hold all diamond pieces (objects)
let diamonds = [];
// Score / total pieces count
let totalPieces = 0;
// Maximum number of pieces before jar looks full but still can add more (soft limit for visual density)
const MAX_DISPLAY_PIECES = 45;
// Helper: random range
function rand(min, max)
return min + Math.random() * (max - min);
// check collision with existing diamonds (so they don't overlap too much, giving messy look but natural)
function isOverlapping(newX, newY, existingDiamonds, minDist = 24)
for (let d of existingDiamonds)
const dx = d.x - newX;
const dy = d.y - newY;
const dist = Math.sqrt(dx*dx + dy*dy);
if (dist < minDist) return true;
return false;
// Generate a new diamond piece with random style, size, slight rotation, and sparkle factor
function createDiamondPiece(baseId = null)
// types: 0 = classic blue diamond, 1 = pink ruby, 2 = golden topaz, 3 = emerald rush
const type = Math.floor(Math.random() * 4);
// size: varies between 11px to 21px for cute variety
const size = rand(12, 21);
let x, y;
let attempts = 0;
const margin = size/2 + 4;
do
x = rand(margin, W - margin);
y = rand(margin + 12, H - margin - 8); // avoid top rim area (glass effect)
attempts++;
if (attempts > 150) break;
while (isOverlapping(x, y, diamonds, size * 0.85));
// ensure within boundaries
x = Math.min(Math.max(x, margin), W - margin);
y = Math.min(Math.max(y, margin+4), H - margin-4);
// sparkle intensity: random 0-1 for highlight
const sparkle = Math.random() > 0.7 ? Math.random() * 0.8 + 0.5 : 0;
const rotation = rand(0, Math.PI * 2);
return
id: baseId !== null ? baseId : Date.now() + Math.random() * 10000 + performance.now(),
x: x,
y: y,
size: size,
type: type,
sparkle: sparkle,
rotation: rotation,
// little bounce animation offset
bouncePhase: Math.random() * Math.PI * 2,
;
// Add a new diamond piece to jar (increase total)
function addDiamondPiece()
if (totalPieces >= 99)
// Easter egg: jar extreme limit, but we still allow but not over 99 shown
if (diamonds.length < 99)
const newGem = createDiamondPiece();
diamonds.push(newGem);
totalPieces++;
updateUI();
drawJar();
else
// just flash warning but still increase score? No, max 99.
if (totalPieces < 999) totalPieces++;
updateUI();
drawJar(); // just update counter but no visual addition
return;
let newGem = createDiamondPiece();
diamonds.push(newGem);
totalPieces++;
// if pieces exceed MAX_DISPLAY_PIECES we don't remove, but diamonds array holds all.
// but to keep drawing performance and clarity, we don't cap removal, but allow many sparkling gems (max 70)
if (diamonds.length > 72)
// Remove oldest diamond (first element) to keep jar readable, but keep total count correct
diamonds.shift();
updateUI();
drawJar();
addCollectEffect();
// Add multiple pieces at once (rush bonus)
function addRushPieces(amount)
for (let i = 0; i < amount; i++)
if (totalPieces >= 99 && diamonds.length >= 85) break;
let newGem = createDiamondPiece();
diamonds.push(newGem);
totalPieces++;
if (diamonds.length > 75) diamonds.shift();
updateUI();
drawJar();
// Add visual burst effect
createFlashEffect();
// visual flash effect when rushing
function createFlashEffect()
const jar = document.getElementById('jarWrapper');
jar.style.transition = 'box-shadow 0.08s';
jar.style.boxShadow = 'inset 0 0 0 4px #fff3b0, inset 0 0 0 8px #ffd966, 0 0 15px gold';
setTimeout(() =>
jar.style.boxShadow = 'inset 0 0 0 4px #f9eec1, inset 0 0 0 8px #b98f5a, 0 10px 20px rgba(0,0,0,0.3)';
setTimeout(() =>
jar.style.transition = '';
, 100);
, 120);
function addCollectEffect()
const jar = document.getElementById('jarWrapper');
jar.style.transform = 'scale(0.99)';
setTimeout(() => jar.style.transform = ''; , 90);
// Reset jar: clear all diamonds, reset score
function resetJar()
diamonds = [];
totalPieces = 0;
updateUI();
drawJar();
// add a small welcoming diamond maybe?
setTimeout(() =>
addDiamondPiece(); // give one starter diamond
drawJar();
, 40);
// UI update (score and piece counter)
function updateUI()
document.getElementById('scoreValue').innerText = totalPieces;
document.getElementById('pieceCount').innerHTML = `⚡ $totalPieces`;
// ---------- RENDERING ENGINE (Pixel-art / gem drawing with diamond rush style) ----------
function drawDiamond(gem) Math.random() < 0.02)
ctx.beginPath();
ctx.arc(-half*0.2, -half*0.3, size*0.12, 0, Math.PI*2);
ctx.fillStyle = `rgba(255, 250, 180, $0.7 + sparkle*0.3)`;
ctx.fill();
// extra star glint
ctx.beginPath();
ctx.moveTo(-half*0.3, -half*0.45);
ctx.lineTo(-half*0.15, -half*0.55);
ctx.lineTo(0, -half*0.45);
ctx.lineTo(-half*0.15, -half*0.35);
ctx.fill();
// add extra shine reflection
ctx.beginPath();
ctx.moveTo(-half*0.2, -half*0.2);
ctx.lineTo(half*0.1, -half*0.4);
ctx.lineTo(half*0.35, -half*0.1);
ctx.fillStyle = 'rgba(255, 250, 210, 0.45)';
ctx.fill();
ctx.restore();
// small secondary glow (post-render pixel puff)
ctx.save();
ctx.shadowBlur = 0;
ctx.beginPath();
ctx.arc(x, y, size*0.2, 0, Math.PI*2);
ctx.fillStyle = `rgba(255, 235, 120, 0.2)`;
ctx.fill();
ctx.restore();
// Draw subtle background textures, jar bottom, some loose diamond dust
function drawBackground()
// radial gradient inside jar for depth
const grad = ctx.createLinearGradient(0, 0, W, H);
grad.addColorStop(0, '#fff3c9');
grad.addColorStop(1, '#f7e5b5');
ctx.fillStyle = grad;
ctx.fillRect(0, 0, W, H);
// draw tiny sparkling dust particles (static ambient)
for (let i = 0; i < 65; i++)
if (i%2 === 0) continue;
ctx.fillStyle = `rgba(255, 215, 100, $Math.random() * 0.3)`;
ctx.beginPath();
ctx.arc( (i*19)%W, (i*7)%H, 1 + (i%3), 0, Math.PI*2);
ctx.fill();
// "Diamond Rush" watermark subtle
ctx.font = "bold 14monospace";
ctx.shadowBlur = 0;
ctx.fillStyle = "#e6d5a866";
ctx.fillText("⚡ RUSH ⚡", W-78, H-12);
ctx.fillStyle = "#cdb87c44";
ctx.fillText("💎", 12, H-10);
// Draw jar overlays (glass rim reflections)
function drawJarGlassOverlay()
ctx.globalCompositeOperation = 'source-over';
ctx.beginPath();
ctx.rect(0, 0, W, H);
ctx.fillStyle = 'transparent';
ctx.fill();
// add shiny glass arc
ctx.beginPath();
ctx.ellipse(40, 28, 25, 18, 0, 0, Math.PI*2);
ctx.fillStyle = 'rgba(255,250,210,0.1)';
ctx.fill();
ctx.beginPath();
ctx.ellipse(W-45, 35, 30, 22, 0, 0, Math.PI*2);
ctx.fill();
// edge reflection left
ctx.beginPath();
ctx.moveTo(12, 40);
ctx.lineTo(22, 35);
ctx.lineTo(18, 90);
ctx.lineTo(8, 88);
ctx.fillStyle = 'rgba(255, 245, 190, 0.2)';
ctx.fill();
// Main draw function - render all diamond pieces in the jar
function drawJar()
if (!ctx) return;
ctx.clearRect(0, 0, W, H);
drawBackground();
// sort diamonds by y coordinate (to give slight depth)
const sorted = [...diamonds].sort((a,b) => a.y - b.y);
for (let gem of sorted)
drawDiamond(gem);
// If jar empty, show a cute message
if (diamonds.length === 0)
ctx.font = "bold 14px 'Segoe UI', 'Courier New'";
ctx.shadowBlur = 0;
ctx.fillStyle = "#ac8e5f";
ctx.shadowColor = '#fff3bf';
ctx.fillText("✨ tap to add gems ✨", W/2-80, H/2);
ctx.font = "10px monospace";
ctx.fillStyle = "#bfa47a";
ctx.fillText("diamond rush jar", W/2-55, H/2+25);
// draw glass overlay after all diamonds
drawJarGlassOverlay();
// final rim light spark
ctx.beginPath();
ctx.rect(0, 0, W, 6);
ctx.fillStyle = 'rgba(255, 245, 180, 0.3)';
ctx.fill();
// extra edge shine
ctx.strokeStyle = '#ffe6aa';
ctx.lineWidth = 0.8;
ctx.beginPath();
ctx.moveTo(5, 5);
ctx.lineTo(5, H-8);
ctx.moveTo(W-5, 5);
ctx.lineTo(W-5, H-8);
ctx.stroke();
// Animate bouncing effect for diamonds (optional micro movement)
let animationFrame = null;
let lastTimestamp = 0;
function animateDiamonds()
if (!diamonds.length)
drawJar();
animationFrame = requestAnimationFrame(animateDiamonds);
return;
let changed = false;
// subtle floating movement for some diamonds, gives lively rush feel
for (let gem of diamonds)
if (Math.random() < 0.05)
const oldX = gem.x, oldY = gem.y;
let shiftX = (Math.sin(Date.now() * 0.003 + gem.bouncePhase) * 0.6);
let shiftY = (Math.cos(Date.now() * 0.004 + gem.bouncePhase) * 0.4);
gem.x += shiftX * 0.2;
gem.y += shiftY * 0.15;
gem.x = Math.min(Math.max(gem.x, gem.size/2+3), W - gem.size/2-3);
gem.y = Math.min(Math.max(gem.y, gem.size/2+8), H - gem.size/2-6);
if (Math.abs(gem.x - oldX) > 0.1) changed = true;
if (Math.abs(gem.y - oldY) > 0.1) changed = true;
// random sparkle update
if (Math.random() < 0.02) gem.sparkle = Math.random() * 0.9 + 0.2;
if (changed) drawJar();
else drawJar(); // gentle redraw to keep sparkle effect
animationFrame = requestAnimationFrame(animateDiamonds);
// ---------- EVENT HANDLERS (Click on Jar & Buttons) ----------
function handleCollect()
addDiamondPiece();
// bonus: sometimes trigger rush duo if total pieces multiple of 7
if (totalPieces % 7 === 0 && totalPieces > 0 && totalPieces < 85)
addRushPieces(2);
createFlashEffect();
function handleRushCollect()
// rush mode: add 3-5 diamonds
const rushCount = Math.floor(Math.random() * 4) + 2;
addRushPieces(rushCount);
// main initialization
function init()
resetJar(); // starts with 1 diamond piece
const jarDiv = document.getElementById('jarWrapper');
const collectBtn = document.getElementById('collectBtn');
const resetBtn = document.getElementById('resetBtn');
jarDiv.addEventListener('click', (e) =>
e.stopPropagation();
handleCollect();
);
collectBtn.addEventListener('click', () =>
handleCollect();
);
resetBtn.addEventListener('click', () =>
resetJar();
createFlashEffect();
);
// extra: secret double rush if you click reset + collect pattern? but fine.
// start animation loop
animateDiamonds();
init();
)();
</script>
</body>
</html>
Diamond Rush : 320x240 JAR Technical Report Diamond Rush is a classic J2ME (Java 2 Micro Edition) adventure puzzle game developed by Gameloft. The 320x240 resolution is specifically designed for "Landscape" mode feature phones, such as the Nokia Asha 201 or Sony Ericsson devices with wider screens. Core Gameplay & Mechanics
Objective: Players control an explorer navigating dangerous ruins to collect diamonds and reach the exit. Levels: The game features three main locations: Angkor Wat: Jungle ruins with snakes and stone puzzles.
Bavaria: A castle filled with armored knights and complex traps.
Siberia: Ice caves featuring slippery surfaces and falling icicles.
Hazards: Includes falling stalactites, poisonous spiders, rolling boulders, and various mythical enemies.
Puzzle Elements: Success requires a mix of speed, timing, and logical reasoning to move rocks and trigger switches. Technical Specifications File Format: .jar (Java Archive) Resolution: 320x240 pixels (Landscape) /scripts/
Language Support: Historically hard to find in English; versions circulating often include Spanish, Chinese, or Russian.
Emulation: On modern devices (Android/PC), it is best played using a J2ME emulator like RetroArch with a J2ME core or dedicated apps like J2ME Loader. Community Status & Availability
The 320x240 version of Diamond Rush is considered "rare" in English-speaking J2ME preservation circles because many major archival sites primarily hosted portrait (240x320) versions.
Verified Archives: Users have reported success finding English 320x240 versions through community-shared links on platforms like Reddit's J2ME Gaming community or specific Google Drive archives.
Modern Alternatives: A port is available for Android as an APK, though it may vary from the original Java experience.
The Diamond Rush (320x240) JAR version is a specifically optimized release for landscape-oriented Java (J2ME) mobile phones, such as the Nokia Asha 201. While the core gameplay remains a 40-level puzzle adventure across Tibet, Angkor, and Bavaria, this particular resolution version features several unique characteristics due to the screen layout: Key Features of the 320x240 Version
Landscape Optimization: Designed specifically for devices with wider screens, providing a better field of view for tablet or 4:3 ratio devices.
UI Adjustments: The main menu typically lacks a "Credits" tab because the screen height is insufficient to accommodate it.
System Fonts: Unlike standard portrait versions that use custom game fonts, this version often defaults to the device's native font for better readability on smaller horizontal displays.
Language Support: Often includes multi-language support (English, German, French, Romanian, Hungarian, and Polish), typically defaulting to the phone's native system language.
Rarity: This specific 320x240 English version is considered rare and harder to find on standard archive sites compared to common portrait (240x320) versions. Core Gameplay Mechanics Regardless of resolution, the game includes:
Levels & Puzzles: 40 levels of exploration and over 200 distinct puzzles.
Tools: Equipment like the compass (pathfinding), hammer (combat), and hook (grabbing distant items).
Enemies & Hazards: Interactions with poisonous spiders, snakes, falling stalactites, and knights.
If you are looking to download the file, legacy archives like the Internet Archive or community threads on Reddit often host these rarer builds.
The most intriguing part of the keyword is "new." How can a 2006 game be "new"?
The term "new" in this context functions in several ways:
Author: [Generated by AI Assistant] Date: April 19, 2026
When users search for a "new" version of this classic, they are typically looking for one of three things:
If you have typed this keyword into Google, you need to be careful. Many old Java sites are abandoned. Here is the safe path to playing this gem today: