Diamond Rush Jar 320x240 | New
If you have a compatible feature phone or an emulator, follow these steps:
Originally developed by Gameloft, Diamond Rush is a 2D puzzle game that combines elements of Boulder Dash and Tomb Raider. Players control a daring adventurer who must navigate through treacherous temples in three distinct locations: Angkor Wat, Tibet, and Bavaria.
Key Features:
For a generation raised on APKs (Android) and IPAs (iOS), the .jar (Java Archive) file extension is a fossil. However, for Diamond Rush purists, it is the only authentic format.
Searching for a "new" jar file implies the user wants a clean, unmodified, freshly ripped copy of the game that hasn't been corrupted by time or bad transfers.
Diamond Rush is a puzzle-platformer where you collect diamonds while avoiding traps.
Basic Controls:
Key Mechanics:
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.
The early 2000s marked a pivotal era for mobile gaming, defined by the limitations of Java ME (J2ME) technology and the creative ingenuity required to overcome them. At the center of this golden age sat Diamond Rush, an action-puzzle title developed by Gameloft. Specifically, the "320x240" version—designed for the landscape screens of Nokia’s S60 devices and early BlackBerry handsets—remains a landmark of mobile software design. By analyzing the "Diamond Rush Jar 320x240 New" iteration, one uncovers a masterclass in platform optimization, level design, and the nostalgic transition from primitive pixels to modern mobile gaming.
To understand the significance of the 320x240 JAR file, one must first understand the hardware of the era. Most mobile games were played on 176x208 or 240x320 portrait screens. The landscape 320x240 resolution was a premium format, offering a wider field of view that fundamentally changed the gameplay experience. In Diamond Rush, this extra horizontal real estate allowed players to see approaching traps and hidden paths earlier than on smaller screens. This version represented the "definitive" edition for enthusiasts, featuring higher-fidelity sprites and smoother animations that pushed the Kjava virtual machine to its absolute limits.
The gameplay mechanics of Diamond Rush were deceptively simple but layered with complexity. Players assumed the role of an explorer navigating three distinct environments: the ancient Angkor Wat, the frozen Bavarian castles, and the fiery Siberian mines. The objective was to collect a specific number of diamonds to unlock the exit while navigating physics-based puzzles involving rolling boulders, floating logs, and intricate pressure plates. The "New" versions often found in legacy archives typically refer to refined builds that addressed the "lag" issues of older handsets, providing a stable 30-frames-per-second experience that felt remarkably fluid for a .jar application.
What truly elevated Diamond Rush above its contemporaries was its commitment to exploration. Unlike the linear mobile games of the time, Diamond Rush featured "Secret Rooms" and non-linear paths. Reaching a 100% completion rate required backtracking and the clever use of tools like the hammer, the compass, and the freezing ray. The 320x240 resolution enhanced this exploration by providing a crispness to the UI and maps, making the identification of breakable walls and hidden switches a matter of player skill rather than visual guesswork.
Furthermore, the "Diamond Rush Jar 320x240" ecosystem reflects the unique culture of the pre-App Store internet. During this period, games were shared via WAP sites, forums, and Bluetooth. The "New" tag in file descriptions often signified a cracked version that removed trial timers or a "modded" version that included fan-made levels. This era of mobile gaming was defined by community distribution, where the .jar file was a universal currency of entertainment.
In conclusion, "Diamond Rush Jar 320x240 New" is more than just a piece of legacy software; it is a capsule of a time when mobile gaming was finding its identity. It proved that a compelling narrative and challenging mechanics did not require gigabytes of data—only clever code and a well-utilized 320x240 grid. As modern smartphones move toward 4K displays and ray-tracing, the enduring popularity of this Java classic serves as a reminder that great game design is timeless, regardless of the resolution.
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 diamond rush jar 320x240 new
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)
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 Ultimate Guide to Diamond Rush: JAR 320x240 "New" Edition
If you owned a Nokia phone in the mid-2000s, Diamond Rush likely defined your early mobile gaming experience. Developed by Gameloft, this 2006 action-puzzle classic was pre-installed on millions of feature phones. Today, nostalgia seekers are hunting for the 320x240 JAR version—a specific landscape resolution that brings this retro masterpiece to modern handhelds and classic devices like the Nokia Asha 201. Why the 320x240 JAR is Special
The original game was often tailored for 240x320 portrait screens. However, the 320x240 landscape version is highly sought after because:
Wider Field of View: It offers a native look for QWERTY-style feature phones.
Emulator Compatibility: It is the preferred resolution for many J2ME emulators on Android and retro handhelds like the Miyoo A30.
Unique Quirks: Some versions of this resolution, such as the Diamond EUB build, use the device's native font instead of custom game fonts due to the screen height constraints. Core Gameplay: An Archeological Quest
In Diamond Rush, you control an unnamed explorer journeying through three distinct, peril-filled worlds:
Angkor Wat: A jungle temple filled with stone corridors, snakes, and falling boulders.
Bavaria: A castle dungeon guarded by knights, spiders, and fire traps.
Siberia (Tibet): Frozen caves where you must avoid falling stalactites and navigate ice.
To progress, you must collect a specific number of purple diamonds to unlock the exit padlock, while red diamonds (Fire, Silver, and Ice) are required to unlock new worlds. Essential Tools and Hazards
The game is as much about strategy as it is about reflexes. You can find items in chests to aid your progress: Mystic Hammer: Breaks weak walls to reveal secrets. Grappling Hook: Drags objects or helps you reach new areas. Compass: Helps you navigate complex, maze-like stages.
The "Suicide" Button: One of the most famous mechanics is the "asterisk" (*) button. Since you spend hours pushing boulders, it's easy to get permanently stuck. This button allows you to sacrifice a life to restart the level from the last checkpoint. How to Play "Diamond Rush" Today
If you are looking for a "new" way to experience this classic without hunting for obscure .jar files, several modern options exist:
Android Port: A direct adaptation of the original is available for download on platforms like Uptodown , featuring virtual arrow keys and the original 2D graphics.
Google Play Versions: Search for Diamond Rush: Retro Adventure for an emulated Nokia experience on modern smartphones.
Gameloft Classics: Gameloft released a 20th-anniversary collection titled Gameloft Classics: 20 Years on Android, which includes Diamond Rush alongside other hits. If you have a compatible feature phone or
Whether you are downloading the 320x240 JAR to your retro handheld or playing the latest Android remake, Diamond Rush remains a timeless challenge for fans of pixel-perfect puzzles. Diamond Rush: Retro Adventure - Apps on Google Play
The Legacy of Diamond Rush : A 320x240 Mobile Classic In the landscape of mobile gaming history, few titles evoke the same level of nostalgia as Gameloft’s Diamond Rush
. Originally released in December 2006 for Java-based (J2ME) mobile phones, this puzzle-adventure title became a cornerstone of the pre-smartphone era. For many users of early Nokia and feature phones, the 320x240 resolution
version represented the "Gold Standard" of mobile gaming, offering a crisp, widescreen-like experience for handsets with landscape-oriented displays. A Journey Through Ancient Ruins
Diamond Rush follows an intrepid, blonde-haired explorer—clearly inspired by classic archeological figures—on a quest to unlock an ancient seal. The narrative takes players across three distinct and perilous regions: Angkor Wat:
Navigating dense jungles and ancient ruins to find the red Fire Diamond.
Exploring a spider-infested castle to retrieve the gray Silver Diamond. Siberia (or Tibet):
Braving falling stalactites and ice-cold traps to secure the blue Ice Diamond. and approximately 200 puzzles
, the game challenged players to use both speed and intellect to survive. Core Mechanics and Challenge
The game’s brilliance lies in its simplicity and depth. Using basic directional controls, players navigate 2D mazes filled with environmental hazards like rolling boulders, fire traps, and poisonous snakes. A unique "suicide" button (typically mapped to the asterisk key) allowed players to restart a room if they found themselves trapped by poorly moved rocks—a frequent occurrence in its physics-based puzzles. Diamond Rush - Nokia Emulator - Apps on Google Play
The search for "diamond rush jar 320x240 new" is more than a nostalgic tech query; it is a manifestation of a growing movement against "games as a service."
In a world where mobile games demand constant internet, battle passes, and stamina meters, Diamond Rush represents a lost honesty: pay once (or download for free via archive) and play forever.
The "320x240" specification ensures visual authenticity. The "JAR" ensures software purity. And the "NEW" ensures that the legend of the jungle explorer continues to reach new audiences.
If you have a few megabytes of free space on your Android phone and an hour to kill, go find that file. Fire up the emulator. Listen to the 8-bit synthesized soundtrack. And dig for diamonds like it’s 2006.
Just watch out for the boulders. They haven't aged a day.
Further Reading:
Have you found a working "new" version of Diamond Rush for 320x240? Let the retro forums know. The digital ark needs keepers.
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 For a generation raised on APKs (Android) and
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?
<!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)
const x, y, size, type, sparkle, rotation = gem;
// base color palette based on type
let mainColor, lightColor, darkColor, highlightColor;
switch(type)
case 0: // Ice diamond
mainColor = '#b7f0ff';
lightColor = '#e0fcff';
darkColor = '#5fc3e0';
highlightColor = '#ffffff';
break;
case 1: // Pink rush diamond
mainColor = '#ff9eb5';
lightColor = '#ffc0d0';
darkColor = '#c15578';
highlightColor = '#fff0f3';
break;
case 2: // Golden topaz
mainColor = '#f7d44a';
lightColor = '#ffea8a';
darkColor = '#c9931e';
highlightColor = '#ffffbb';
break;
default: // Emerald / jade rush
mainColor = '#6fda6f';
lightColor = '#a3f0a3';
darkColor = '#2b8c2b';
highlightColor = '#dcffdc';
break;
ctx.save();
ctx.translate(x, y);
ctx.rotate(rotation);
const half = size/2;
// draw diamond shape (polygon - 4 point kite shape)
ctx.beginPath();
ctx.moveTo(0, -half * 0.85); // top tip
ctx.lineTo(half * 0.75, 0); // right
ctx.lineTo(0, half * 0.9); // bottom point (longer)
ctx.lineTo(-half * 0.75, 0); // left
ctx.closePath();
// gradient fill for gem shine
const grad = ctx.createLinearGradient(-half*0.3, -half*0.4, half*0.5, half*0.6);
grad.addColorStop(0, lightColor);
grad.addColorStop(0.6, mainColor);
grad.addColorStop(1, darkColor);
ctx.fillStyle = grad;
ctx.fill();
ctx.strokeStyle = '#f9f2cf';
ctx.lineWidth = 1.2;
ctx.stroke();
// inner facet lines (diamond cut effect)
ctx.beginPath();
ctx.moveTo(0, -half*0.4);
ctx.lineTo(0, half*0.5);
ctx.moveTo(-half*0.4, 0);
ctx.lineTo(half*0.4, 0);
ctx.strokeStyle = 'rgba(255,255,210,0.7)';
ctx.lineWidth = 1;
ctx.stroke();
// little sparkling glint
if (sparkle > 0.3
// 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>
The Diamond Rush (320x240) version is a beloved classic originally developed by Gameloft for Java-based phones like the Nokia Asha . While the game itself dates back to 2006, the 320x240 .jar file remains a high-demand version because it is specifically optimized for landscape screens, making it the "gold standard" for retro handhelds and modern Android emulators . Quick Gameplay Review
The Vibe: You play as an Indiana Jones-style explorer navigating three treacherous worlds: Angkor Wat, Bavaria, and Siberia (Tibet) .
Mechanics: It’s a puzzle-platformer where you dodge falling boulders, snakes, and fire traps to collect diamonds and find the exit .
The Challenge: Reviewers often note that while it starts easy, the 40 levels become "borderline frustrating" as they require precise timing and clever puzzle-solving .
Why 320x240? Most original versions were portrait (240x320). Finding a "new" or stable 320x240 .jar is the best way to play on devices like the Miyoo Mini, Anbernic, or Android via the J2ME Loader . Performance on Modern Devices If you're using this .jar on an emulator in 2026:
Visuals: The pixel art holds up surprisingly well, with "fantastic color work" and smooth character animations .
Compatibility: Some 320x240 versions were specifically optimized for the Nokia Asha 201, which can lead to memory errors on lower-end emulators, though J2ME Loader generally handles it at a solid 20 FPS .
Verdict: It’s a 10/10 nostalgia trip. If you find a clean 320x240 file, it is the definitive way to experience one of the best mobile games ever made .
Are you planning to run this on an Android phone or a specific retro handheld?
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.
Inside J2ME Loader, set:
The specific JAR file for 320x240 devices has distinct characteristics:
You might ask: Why is the keyword so specific about the resolution?
During the Java ME (J2ME) era, phones came in two primary resolutions:
The 320x240 resolution (often rotated to 240x320 for portrait mode) provided the definitive Diamond Rush experience. Here is why:
When veterans search for "diamond rush jar 320x240", they are rejecting scaled-up versions that look blurry on modern emulators. They want the native resolution designed for the golden-age hardware.