snakegame | An old fashion snake game using different programming

You have to handle the events in the application loop. See pygame.event.get() respectively pygame.event.pump():

For each frame of your game, you will need to make some sort of call to the event queue. This ensures your program can internally interact with the rest of the operating system.

To compile via command-line, use javac rather than java. See the documentation for javac.

The java tool is for running classes that have already been compiled. For multiple classes, you should put them into a Java ARchive file (JAR) file. You include a manifest file that siecifies which class has a main method to be used for launching.

As you discovered, Java 11 gained a convenience feature where a single source-code file with a main method can be compiled and executed by simply calling java. The javac tool is implicitly called on your behalf. See JEP 330: Launch Single-File Source-Code Programs.

FYI, most of use an IDE to do this compiling and packaging for us rather than manually calling the command-line tools. I recommend you do the same.

You have a choice of at least three astoundingly good IDEs, each with a wide-range of features. Listed here in random order:

• NetBeans by the Apache Foundation
• Eclipse by the Eclipse Foundation
• IntelliJ by JetBrains

All three are available free-of-cost, with JetBrains also offering a paid Ultimate edition in addition to their free Community edition.

All three of these tools support using Apache Maven or Apache Gradle as the dependency-management and build-automation tooling. So you can choose to make your project portable across IDEs.

Here is quick tutorial using IntelliJ with Apache Maven.

Choose File > New > Project. In the "New Project" dialog, click Maven on the left. Check Create from archetype. Scroll down to org.apache.maven.archetypes:maven-archetype-quickstart. Expand that item to choose RELEASE. Click Next button.

Name you project something like MyFirstDemo. This is the name of the project folder created on disk. Expand the Artifact Coordinates. Change GroupId to something for you, like com.esau.demo. Convention is to use the reverse of a real domain you own, or invent something unlikely to cause a collision in naming. Change ArtifactId to the name of your .jar file that we will eventually produce. Perhaps just "MyFirstDemo", but it can differ from project name if you want.

Click Next to Maven screen. IntelliJ comes with a copy of Apache Maven bundled. No changes, click Next.

Wait a moment as your project is created. This may take a moment as often a Maven POM (configuration) file expands itself and then creates the project, and downloads needed libraries.

Edit your POM. I suggest changing:

In RunGame these are the steps:

1. Create a new timer
2. 0-N timer callbacks (probably 0).
3. Evaluate the if statement after that, which will be false.
4. 0-N timer callbacks (probably 0).
5. Exit program

Your timer never has a chance to invoke, or if it does, it is only invoked just a few times before the program exits.

You have to wait inside your Main() after step #1. The Timer class documentation shows you a way to do that using AutoResetEvent. Another way you could do that is to do a SpinWait.SpinUntil call. You could change your code to

There are 4 issues:

1. Update the head attribute after in the move() method:

If _play_step gets to the end and the game is not over, it falls through and there is no return statement. That returns None, as it says. You have to return something. Probably add this:

"in this case 4-5 windows reopen"

This suggests that you are probably adding multiple ActionListeners to the replay JButton. A new listener is added each time game over method is called, and this is incorrect. I would not add the ActionListener to the button in the game over method but rather add it once where you create the replay button.

1: Use an absolute path to access the font-resource, like this:

This is a strange problem, and many solutions didn't work.

Useful links:

• https://stackoverflow.com/a/58854685/12393574
• https://github.com/junit-team/junit5/issues/2111#issuecomment-557925312
• https://sormuras.github.io/blog/2018-09-11-testing-in-the-modular-world.html
• https://stackoverflow.com/a/58990250/12393574
• The JavaFX plugin adds the gradle-modules-plugin

My preferred solution would be to use a test module-info.java or module-info.test, but I was not able to get this to work. I ended up simply ignoring modules for tests, which is a passable workaround for the moment, since I'm currently only doing Unit Tests. To ignore modules during testing, add this to the build.gradle:

Generally in GUI applications it's common to want to separate the GUI from the logic. There are benefits to doing this as it means your GUI remains responsive even if your logic is busy. However, in order to run things concurrently there are many drawbacks, including overheads. It's also important to know that python is not 'thread safe', so you can break things (see race conditions) if you're not careful.

Your example is quite complex so lets start with a simple example: A simple pygame setup with a moving dot