Monopoly | Java based object oriented implementation of the Monopoly | Game Engine library

From your code, I assume that the first one's horizontal location is 670 and the width of each box is 30. Then, this should get you to the sixth box:

Does a card need to be able to mutate the cards in self? If you know that execute will not need access to cards, the easiest solution is to split App into further structs so you can better limit the access of the function.

Unless there is another layer to your program that interacts with App as a singular object, requiring everything be in a single struct to perform operations will likely only constrain your code. If possible it is better to split it into its core components so you can be more selective when sharing references and avoid needing to make so many fields pub.

Here is a rough example:

You're looking for Babel.

Babel will basically let you write modern JS code and then it can transpile it to "more primitive" code in order to run on a larger set of devices.

There are a bunch of options and a bunch of ways you can go about using it, but using the env preset and specifying your targets is probably a good place to start.

New Answer based on comments and updated question:

The line ManyDice die = new ManyDice(); is wiping your dice list clean every loop through your program. It's replacing your variable with a new instance of the class, with a fresh list and all.

Simply move that line before the start of the loop:

before the line do {

and then every iteration will use the same instance of ManyDice, and will all share the variable die, without overwriting it.

OLD ANSWER: From what I can see, your program only runs once. And then you need to start it again to put in another dice. Your main function only asks for input once. Whenever you start the program again, all the memory used in the program gets cleared. Unless I’m missing something, that is why your list continues to be reset. You’re actually running a completely new program the next time you try to add dice. So it has no knowledge of the previous runs.

One solution is to say (pseudo code)

You are on the right track with ARRAY_AGG, but just a little over aggressive with the joins. You just need a simple join (1 left, 1 inner) on the 3 tables

Your function isn't returning the new shuffled array and assigning it to Games. Best practice would be to store your array in useState so when it updates it forces a re-render and shows correctly.

I have done a solution for you. It parses the whole JSON you put into the text field and put it into the object, so you can do whatever you want to do with it. Please, have a look at the function parse

The question to ask here is what value you're getting out of the Singleton behavior. You've described this as "only if there is no sense to have more than one, and when there is a need to access them from all over the program". The nuance there is that even if it wouldn't be useful to have more than one, you might choose against Singleton: It might be fine to allow multiple instances to be created if that doesn't have any significant downsides.

Remember, if you implement Singleton well, that object cannot be destroyed throughout the lifetime of the application, and you'll need to synchronize the creation of the object so multiple threads can't create multiple instances. For heavy objects, or objects with heavy dependencies, that might actually lead to greater long-term memory usage because you cannot destroy or garbage-collect the object throughout your app's lifecycle. That leaves a gap between which objects can be Singleton and which objects should be Singleton. It'll require your judgment.

Some factors to consider:

1. Will your application be correct if more than one is created? For something like a DatabaseService or StorageService, the answer might be "no", in which case Singleton behavior is absolutely required.

2. Will your application have good performance if more than one is created? For something like a WebRequestService, there may be some additional value in having one object queue or manage the requests, and that might be a good motivation to make it Singleton.

3. If your object does not have to be Singleton, is it expensive to create, or will it be created often enough to want to reuse the object? In this case you have to weigh the expense of creation versus the expense of the Singleton. Imagine a Dictionary or SpellChecker where the results are correct even if you create a new one, but you want to minimize the number of times you have to read the dictionary file from disk. There are sometimes more options than Singleton, such as Dagger's @Reusable scope, which would give you some of the benefits with fewer costs.

For your Dice class:

• If a Dice class represents exactly one dice roll determined when the object is created, obviously it can't be Singleton, because then you could only roll the dice once and it would always return the same value. You probably don't want that.
• If your Dice class represents a pure (pseudo)random number generator, it generally won't have to be Singleton: It's probably cheap to create, and there's probably no advantage to asking the same object in sequence. You could plausibly make this "reusable" or keep the Dice objects in a pool to avoid recreating them, but if I were writing the code I think it'd be unlikely for that to be worthwhile.
• If you would like your games to be repeatable, such as to have predictable games in integration tests, it might make sense to have the Dice object be Singleton: In that case you might want the single object so it can be called in the same order and receive the same random-seeded results.
• If you're calling out to a random number service like https://www.random.org, it may be important to make the object Singleton so it can batch, cache, and reuse those requests.

For "Dice" I'd make that "scopeless", creating a new instance every time and allowing for its replacement in tests. In contrast, it probably makes sense for your Board, Game, or GameState object to be Singleton across the application.

One issue is you might get duplicates in your randomized gamespicked array. It might be better to shuffle the array (randomize it) and then just get the slice of X items, like this. Notice that I change the numOfGames value from a string to a number by prepending it with +