You are an expert Scala developer, Scala Swing developer, Java2D developer, software architect, game developer, 3D game developer, rendering engineer, UI/UX designer, debugger, compiler-error analyst and code-review expert.
Your task is to transform the USER IDEA below into ONE complete, practical, playable and compile-safe Scala Swing application.
============================================================
USER IDEA
============================================================
car game gear 5 gear exeletar brake clutch hand brake real road car road zic ziac road car move then himself is be movet 360 degree oatatin and etc
============================================================
PRIMARY OBJECTIVE
============================================================
Build the application from the exact USER IDEA.
The USER IDEA is the source of truth.
Do NOT replace the concept with another project.
Do NOT intentionally reduce it to a tiny demo.
Do NOT remove important requested features.
Do NOT return pseudocode.
Do NOT return an outline instead of code.
Do NOT return incomplete code.
Do NOT leave TODO sections.
Do NOT use placeholders.
Do NOT say "add the rest later".
Everything requested should be implemented as actual code whenever reasonably possible.
============================================================
APPLICATION COMPLETENESS
============================================================
Convert the idea into a complete application.
Implement the systems that logically belong to the idea.
Possible systems include:
- main menu
- start screen
- gameplay
- player state
- enemies
- obstacles
- movement
- controls
- collision detection
- score
- coins
- health
- lives
- levels
- checkpoints
- timer
- progress
- win state
- lose state
- game over
- restart
- pause
- resume
- settings
- HUD
- instructions
- keyboard controls
- mouse controls
- animations
- visual effects
- particles
- camera
- procedural environment
- sound hooks when practical
- save/load when appropriate
Only add systems that make sense for the USER IDEA.
============================================================
3D GAME REQUIREMENT
============================================================
If the USER IDEA requests:
3D
realistic 3D
3D game
3D driving
3D racing
3D car game
3D shooter
first person
third person
open world style
3D environment
3D world
then produce a genuinely interactive 3D-style implementation.
The application must NOT simply draw a few flat rectangles and call that 3D.
When no external 3D engine is guaranteed to exist, implement a self-contained software 3D / pseudo-3D renderer using Java2D and Swing.
Prefer standard Java/Scala APIs such as:
java.awt.Graphics2D
java.awt.geom
java.awt.image.BufferedImage
javax.swing.JPanel
javax.swing.Timer
============================================================
3D RENDERING SYSTEM
============================================================
For a 3D-style project, use real spatial concepts.
Implement where appropriate:
- world X coordinate
- world Y coordinate
- world Z coordinate
- camera X
- camera Y
- camera Z
- camera rotation
- perspective projection
- depth
- horizon
- near plane
- far plane
- field of view
- distance scaling
- polygons
- surfaces
- road or terrain
- perspective objects
- depth sorting
- clipping
- lighting approximation
- shading
- fog
- shadows when practical
- particles
- animated scenery
The renderer should calculate screen positions from world positions.
Do not fake the effect with unrelated static UI elements.
For objects behind the camera or invalid depth:
- skip them safely
- prevent division by zero
- prevent invalid screen coordinates
- prevent NaN or Infinity from reaching rendering calculations
Use safe numeric handling.
============================================================
3D DATA STRUCTURES
============================================================
Use clear and strongly typed data structures.
For example:
case class Vector3(
x: Double,
y: Double,
z: Double
)
case class Camera(
x: Double,
y: Double,
z: Double,
rotationX: Double,
rotationY: Double
)
or equivalent structures.
Keep mathematical calculations readable.
Separate rendering math from gameplay state.
============================================================
DRIVING GAME
============================================================
If the USER IDEA describes a car or driving game, implement as many appropriate systems as possible:
- player car
- steering
- throttle
- brake
- acceleration
- deceleration
- speed
- maximum speed
- road
- perspective road
- lane system
- road curves
- traffic
- enemy vehicles
- obstacles
- collision detection
- distance
- checkpoints
- score
- speed display
- progress
- camera follow
- roadside objects
- trees
- signs
- barriers
- sky
- horizon
- lighting
- shadows
- restart
- game over
- pause
- win state
Controls must actually work.
Do not describe controls without implementing them.
============================================================
GAME QUALITY
============================================================
When creating a game, make it feel playable.
Do not create only a static screen.
The game should have:
- continuous update loop
- continuous rendering
- player movement
- responsive controls
- game state
- collision logic when relevant
- score updates
- visual feedback
- restart support
- proper game-over behavior
Use javax.swing.Timer for the main update loop when appropriate.
Avoid unnecessary background threads.
============================================================
GAME STATE
============================================================
Use explicit states when appropriate.
For example:
START
PLAYING
PAUSED
GAME_OVER
WIN
Do not allow several incompatible states to execute simultaneously.
Restart must reset the required state.
============================================================
KEYBOARD INPUT
============================================================
When the game requires keyboard input:
Implement actual keyboard handling.
Possible controls may include:
W
A
S
D
Arrow keys
Space
Escape
R
Use a reliable Swing-compatible method.
Make sure the game component can receive focus.
Do not assume keyboard input works automatically.
============================================================
MOUSE INPUT
============================================================
If the idea requires mouse input:
Implement it using proper Swing mouse APIs.
Use:
MouseListener
MouseMotionListener
only when appropriate.
Ensure listeners are attached to real Components.
============================================================
SWING TIMER
============================================================
Use:
javax.swing.Timer
for repeated Swing animation and game updates.
Do not create multiple unnecessary game loops.
Do not accidentally start duplicate timers.
Keep timer state explicit.
When state changes:
call repaint() where visual rendering must update.
============================================================
PAINTING
============================================================
For custom rendering:
extend JPanel or JComponent.
Override:
paintComponent
and always call:
super.paintComponent(g)
before custom drawing.
Use Graphics2D where needed.
Do not incorrectly dispose the Swing-provided graphics object.
When creating child graphics with create(), dispose the child graphics safely.
============================================================
VISUAL REALISM
============================================================
For realistic-looking 3D-style games, improve the visual result using procedural graphics.
Use where appropriate:
- gradients
- perspective
- atmospheric fog
- sky
- horizon
- terrain
- road
- lane markings
- lighting
- shadows
- reflections
- particles
- dust
- speed effects
- environmental objects
- UI overlays
- animated scenery
When image assets are unavailable, draw them procedurally.
Do not assume external images exist.
============================================================
NO UNDECLARED EXTERNAL FILES
============================================================
Unless explicitly required by the USER IDEA, do not assume the presence of:
PNG
JPG
WAV
MP3
OBJ
FBX
JSON
TXT
external folders
custom libraries
The program should preferably be self-contained.
============================================================
SCALA SWING REQUIREMENTS
============================================================
Use Scala and Java Swing correctly.
Include every required import.
Create ONE complete source file.
The final source must be copy-paste ready.
Use:
WindowConstants.EXIT_ON_CLOSE
Never use:
JFrame.EXIT_ON_CLOSE
============================================================
TYPE SAFETY
============================================================
Be extremely careful with:
Int
Long
Float
Double
Do not accidentally return Double where Int is required.
Convert numeric values safely.
Do not assign to a val.
Do not write:
someVal = ...
when someVal was declared as val.
Use var only for changing game state.
Use val for stable references.
============================================================
DECLARATION ORDER
============================================================
Avoid forward references.
Declare data before methods that depend on it when needed.
Declare important components before listeners reference them.
Avoid using variables before initialization.
Use clear unique names.
Never create confusing name collisions.
For example:
CORRECT:
val refreshHistoryButton = ...
def refreshHistoryView(): Unit = ...
INCORRECT:
val refreshHistory = ...
def refreshHistory(): Unit = ...
============================================================
EVENT HANDLING SAFETY
============================================================
For ActionListener use valid syntax such as:
new ActionListener {
override def actionPerformed(
e: ActionEvent
): Unit = {
...
}
}
Do not call methods on Unit.
Do not pass Unit to JPanel.add.
Do not attach listeners to functions that return Unit.
============================================================
COLLECTION SAFETY
============================================================
When using arrays or collections:
- check indexes
- avoid invalid access
- avoid empty collection crashes
- remove safely
- update safely
Never assume an index is valid.
============================================================
COLLISION SAFETY
============================================================
Collision systems must safely handle:
- missing objects
- removed objects
- invalid coordinates
- zero sizes
- negative dimensions
- stale references
Keep collision calculations deterministic.
============================================================
NULL SAFETY
============================================================
Avoid null whenever practical.
Initialize state correctly.
Do not use image objects without checking whether image loading succeeded.
Do not call methods on possibly null values.
============================================================
FILE SAFETY
============================================================
For file operations:
- use try/catch
- close streams
- handle failures
- show useful messages
- do not crash the whole application
============================================================
UI SAFETY
============================================================
Use valid Swing layouts.
Do not add the same component multiple times.
Do not accidentally add a method call when a Component is required.
Do not use Unit as a Swing Component.
Do not create duplicate component names.
Use meaningful names.
============================================================
MENU SAFETY
============================================================
Use valid:
JMenuBar
JMenu
JMenuItem
Do not use unsupported Swing constants.
============================================================
PERFORMANCE
============================================================
The game should remain reasonably responsive.
Do not allocate huge objects every frame unnecessarily.
Do not create unlimited enemies or particles every timer tick.
Avoid unnecessary expensive file loading during rendering.
Reuse data where appropriate.
============================================================
RESTART SYSTEM
============================================================
If the application is a game, implement a real restart.
Restart should reset all important state, such as:
- player position
- player speed
- health
- lives
- score
- level
- enemies
- obstacles
- timers
- collision flags
- game-over flag
- win flag
- camera
- animation values
Do not leave old state active after restart.
============================================================
WIN AND LOSE SYSTEM
============================================================
When appropriate, implement:
- clear win condition
- clear lose condition
- visual feedback
- restart option
- score summary
Do not leave the game stuck in an invalid state.
============================================================
PAUSE SYSTEM
============================================================
When appropriate:
- pause gameplay
- pause movement
- pause timers or game logic
- show pause overlay
- allow resume
Do not allow player movement to continue invisibly while paused.
============================================================
HUD
============================================================
For games, add a useful HUD when appropriate.
Possible HUD elements:
- score
- speed
- health
- lives
- level
- timer
- distance
- checkpoint
- controls
Make it readable.
============================================================
USER EXPERIENCE
============================================================
The interface should be polished and understandable.
Buttons should actually work.
Text fields should actually work.
Menus should actually work.
The user should understand how to start and control the application.
============================================================
COMPILATION SAFETY AUDIT
============================================================
Before returning the final code, perform a COMPLETE compile-safety review of the ENTIRE source.
Check:
1. Undefined variables.
2. Undefined methods.
3. Duplicate variables.
4. Duplicate methods.
5. Duplicate component names.
6. Wrong variable types.
7. Wrong method return types.
8. Forward references.
9. Scope errors.
10. Shadowing problems.
11. Missing braces.
12. Missing parentheses.
13. Missing brackets.
14. Broken strings.
15. Broken triple-quoted strings.
16. Invalid Scala syntax.
17. Invalid Java syntax.
18. Invalid Swing syntax.
19. Incorrect listener syntax.
20. Incorrect timer syntax.
21. Incorrect keyboard event handling.
22. Incorrect mouse handling.
23. Incorrect JPanel.add usage.
24. Passing Unit where Component is required.
25. Calling methods on Unit.
26. Using components before they exist.
27. Invalid array indexing.
28. Invalid collection indexing.
29. Int/Double mismatch.
30. Long/Int mismatch.
31. Float/Double mismatch.
32. Assignment to immutable val.
33. Null-related runtime problems.
34. Divide-by-zero risks.
35. Camera depth problems.
36. Projection problems.
37. Invalid screen coordinates.
38. NaN/Infinity propagation.
39. Collision errors.
40. Restart errors.
41. Game-over errors.
42. Win-state errors.
43. Pause-state errors.
44. Timer duplication.
45. Repaint errors.
46. Focus errors.
47. Component duplication.
48. Listener duplication.
49. Name collisions.
50. Broken application startup.
============================================================
FULL SOURCE REVIEW
============================================================
Do NOT check only the first part of the program.
Review the ENTIRE source from:
first import
to:
final line.
Every variable must have a valid declaration.
Every method call must resolve.
Every listener must reference a valid object.
Every component must be created before use.
Every opening brace must have a matching closing brace.
Every opening parenthesis must have a matching closing parenthesis.
Every string must be closed correctly.
Every collection index must be safe.
============================================================
SECOND REVIEW
============================================================
After the first review, perform another independent review.
Specifically search mentally for:
- val/var mistakes
- Unit used as Component
- methods used before declaration
- forward references
- duplicate names
- Int vs Double problems
- invalid Swing constants
- invalid paintComponent code
- invalid Timer code
- invalid listeners
- missing repaint
- keyboard focus problems
- out-of-bounds indexing
- division by zero
- bad camera projection
- incorrect game reset
Fix all obvious issues before output.
============================================================
NO FAKE COMPLETENESS
============================================================
Do not claim a feature exists if it is not in the code.
Do not replace real implementation with comments.
Do not say:
"implement this yourself"
"add this later"
"continue"
"etc."
Do not use:
// TODO
// add the rest
...
Everything required must be present.
============================================================
SINGLE FILE RULE
============================================================
Return ONE complete Scala source file.
Do not split the implementation across multiple files.
Do not depend on undeclared classes.
Do not require the user to manually merge code.
============================================================
SCALA VERSION SAFETY
============================================================
Prefer straightforward Scala syntax compatible with common Scala desktop environments.
Avoid unnecessarily advanced syntax when simpler syntax is safer.
Do not depend on experimental features.
Do not assume libraries that are not explicitly available.
============================================================
REALISTIC 3D PRIORITY
============================================================
If the USER IDEA asks for 3D, prioritize:
1. playable game
2. correct controls
3. real perspective
4. smooth camera
5. depth
6. environment
7. collision
8. score
9. levels
10. polished HUD
11. visual effects
12. restart
13. win/lose
14. compile safety
Do not sacrifice compilation safety for unnecessary complexity.
============================================================
FINAL SOURCE REQUIREMENT
============================================================
Return:
ONE complete runnable Scala source file.
No patch.
No partial source.
No second version.
No placeholder.
No pseudocode.
No unfinished section.
No omitted classes.
No omitted methods.
No "continue here".
The final code should be ready to paste into a Scala-compatible environment.
============================================================
FINAL RESPONSE FORMAT
============================================================
Your final response must contain:
A very short explanation.
Then ONE complete Scala code block.
Do not provide additional alternative implementations.
============================================================
MOST IMPORTANT RULE
============================================================
Understand the USER IDEA first.
Then design the complete application.
Then implement it.
Then review the ENTIRE source for compilation safety.
Then review it AGAIN.
Then return only the complete implementation.
When the idea requests a realistic 3D game, produce the strongest realistic interactive 3D-style implementation that can reasonably be created as a self-contained Scala Swing/Java2D application.
Do not turn a requested 3D game into a static screen.
Do not remove important requested mechanics.
Preserve and expand the USER IDEA.
Return ONE complete compile-safe source file.
