MazeGame | aframe implementation for a maze game | Game Engine library

In your game scene file, you are creating and presenting a GameScene2 object:

The method FileReader (whose name should start with a lower case letter), returns Maze.
However, this is the property on class level since the local variable with the same name, declared within the try-catch, is out of scope.
This class-level property has not been assigned yet and is therefore equal to null.

I beg you will laugh,

hard code to read, but easy to solve problem

in your public boolean out you check b>0 instead of b<0

with this, everything is working :)

In Addition:

class names should start with capitol letter

i did some code formatting stuff, too. if you want to take a look...

MazeGame

The differences I see:

• A tiny difference in the moment of initializing room: With (A), it's initialized after finishing the super constructor Object() call, inside the MazeGame() constructor. With (A2) the initializing takes place after finishing the super constructor Object() call and before the first line of any MazeGame(...) constructor. In your case, it doesn't make a difference.
• The initialization from (A2) applies to all constructors that MazeGame will ever have, while the (A) approach only initializes room in this single MazeGame() constructor, not affecting any constructors you might add in the future.
• Moving the initialization to the room field "allowed" you to remove the constructor from your source code and to rely on the default constructor that the compiler generates in case there is no constructor. I don't see that as a benefit, but as a maintenance risk, because if in the future you want to add some e.g. MazeGame(Room room) constructor, this not only adds the new constructor (the expected result), but also removes the default one - might be quite unexpected.

The advantage of using the factory method pattern is that you decouple the business logic of creation of a class from the actual logic of the class, because if you don't have that factory method, every class that you add on your system needs to have a factory method inside, and when you have to change something about the creation you may have to deal with all of that set of classes ( bad for the open-closed principle )

Method overloading works only if the overloaded and overloading methods have the same signature, meaning the same parameter types and same return type.

The method in Snake has two arguments, while the method in Monsters has no parameters at all, so it is not overloaded.

When you call Snake.fight(), such a method is searched for but not found (no method is called fight() and accepts zero arguments), so the parent method is called.

Bonus:
The Monsters class looks like a simple parent class for all the monster types such as snake, skeleton, goblin or whatever, which should never be instantiated. In such case it's probably better to make it abstract, with no method implementations at all, so you won't invoke it's methods by mistake.

This code will iterate through the elements in your board.

If the element is a 0, it will check if the element at the same position in the clicked board is true (it has been clicked), if it is not, the loop will be interrupted and false will be returned.

If all zeroes are true in the corresponding clicked board, the loops will run through completely and the method will return true.

Code:

My plan is to define cloneIt in MapSite and give a default implementation (simply calling Object.clone()), which can be overidden in the concrete classes.

Be aware : the default implementation of Object.clone() makes a shallow copy of the cloned object and you should also implement the Cloneable interface if you don't want to see a CloneNotSupportedException be thrown.

So you should override both clone() and cloneIt(). It is confusing because a single method is enough. Just keep cloneIt() and forget the clumsy clone() method.

Is there a way to 'force' Java to return the concrete class type (Room, Door, Wall) eventhough the method from the abstract class is used? This may avoid castings.

With Generics yes you can do it.

For example :

Place a break command just after executing the desired function in choices 1, 2 and 3. In other words,