keycode | keyboard keycodes and keynames and vice versa

i'd highly recommend on using JFrame.dispose() ONthe old Game as long as it expanding JFrame. If not you can add a method to the Game class that will dispose the JFrame it contains. A method as such will look like that:

this in your code is not what you expect it to be. If block1 etc are local variables, reference them without this.. If they are members of your encapsulating object, change your callback function to use arrow syntax to let this reference your object: document.addEventListener('keydown', event => { /*...*/ })

First of all, you should not update the coordinates of the crates from the movement of the camera. Instead, let the camera have its own position in 3D space, update that position when you want the player to move, and then subtract the camera position from the crates' positions when calculating the 2D space coordinates. This will make things much easier when you later want to add, for example, the ability for the camera to rotate or the crates themselves to move.

Now to add a rotation capability to the camera, you will need to define a rotation matrix for it in addition to a position. Then, when rendering the crates, you transform the crate coordinates (after subtracting the camera's position) using the inverse of the camera's rotation matrix. This will give you the view space coordinates of the crates, which should be projected onto the 2D space for rendering.

There are many ways to create a rotation matrix depending on what parameters you have. A common one is the Rodrigues rotation formula or "axis-angle" formula, which is used when you have an axis of rotation and an angle to rotate about that axis. Another one is from Euler angles. And if you aren't familiar with matrices and linear algebra, I would recommend you to learn it (there are a lot of free resources available online) as it is used extensively in 3D game development.

With regards to the image analysis resolution, the documentation of ImageAnalysis.Builder.setTargetResolution() states that:

The maximum available resolution that could be selected for an ImageAnalysis is limited to be under 1080p.

So setting a size of 2560x800 won't work as you expect. In return CameraX seems to be selecting the maximum ImageAnalysis resolution that has the same aspect ratio you requested (2560/800 = 1280/400).

Preloading is usually the best thing to do (at least for frequently used assets, such as animation sprites), for these reasons:

• Fetching resources over a network has a latency cost associated with it. When you are doing it during a game that should be running at 30-60 frames per second and responding to user inputs quickly, it may significantly degrade the player's experience.
• If you are loading images on demand, you will need to consider the possibility that the image loading may fail (because of a network failure, for example) and what should be done in such a situation. An advantage of preloading is that you can choose to not let your game start if important assets are not available.

In addition, the code you have posted will not work as you may have expected it to. It will only display frame3.png. This is because JavaScript in the browser is single-threaded: update and the keydown listener will never run concurrently, so the ctx.drawImage call in update will not see frame.src set to frame1.png or frame2.png.

First of all keypress event is deprecated. I am not sure what the nature of your assignment is, but you might go ahead with keydown instead.

Also keydown is the event you want your code to watch for and use its properties. I presume KeyboardEvent.code is what you want.

More details on MDN Web Docs: https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent

Okay, so one of the issues I have with the code you've presented is the fact that you're leak responsibility. It's not the responsibility of the NavigationAction to register key bindings or modify the state the of UI. It should only be responsible for generating a notification that the state has changed back to a responsible handler.

This could be achieved through the use of some kind of model, which maintains the some kind of state, which is updated by the NavigationAction and read by the UI or, as I've chosen to do, via a delegation callback.

Another issue is, what happens when the user releases the key? Another issue is, how do you deal with the delay in repeated key press (ie when you hold the key down, there is a small delay between the first key event and the repeating key events)?

We can deal with these things through a simple change in mind set. Instead of using the NavigationAction to determine "what" should happen, it should be used to tell our UI "when" something has happened. In this a directional key has been pressed or released.

Instead of reacting to key stroke directly, we either "add" or "remove" the direction from a state model and allow the Swing Timer to update the state of the UI accordingly, this will generally be faster and smoother.

It also has the side effect of decoupling logic, as you no longer need to care about "how" the state was changed, only that it was and you can then decide how you want to react to it.

This approach is generally commonly used (in some form or another) in gaming engines.

In your event handler you are not calling removeInput that was provided by connect (props.removeInput) but the imported removeInput that doesn't dispatch anything and just returns an action object, so I suggest changing the component definition to: