multiplay | Pointerlock example from mrdoob | Runtime Evironment library

The answer is it depends and it requires several trade-offs to be made for each project

• Performance: RedisJSON uses a tree structure for storing all elements in a document.
  • Comparing to a string: the advantage is that updating sub-elements of a document will be faster than manipulating a string containing a serialised JSON object. But retrieving (reassembling) and writing the entire document will be more expensive compared to Strings. Read more here.
  • Comparing to Hash: when manipulating a flat document (1 level deep), RedisJSON and HSET performance are comparable.
• Maintainability: using several native data types in Redis to represent your object can be really performing, but the code will be more complex to maintain. There can be additional migration/refactoring work when the structure of the document is altered.
• Querying: RediSearch will soon add support for indexing and querying the content RedisJSON documents. This is, of course, if your use case requires secondary indexing and querying documents other than with their key. You can still build your own secondary indexing with Redis data structures, but this is also a trade-off in maintainability

disclaimer: I work for RedisLabs, creator and maintainer of RediSearch and RedisJSON

I found out that that the port 0808 was being used by my servers router as a default gateway, so i changed the port and everything worked (:

I understood that the problem was the Character controller I was using, so in the player script I checked if the player had authority, if not I destroyed the character controller, and if i was destroying it on the server I replaced it with a normal collider without physics, so i could still have collisions

You can show it as a comma separated string in the row by using =>

You could either detect loss of focus using the Unity Event function OnApplicationFocus(bool) (Docs) or by checking the current focus state with Application.isFocused (Docs). Then in your input logic ignore gamepad input if focus is false

I was wondering if the singleton pattern would work as there would be 2 player objects at the same time. I am making a street fighter-type game.

The script you provided is a functional singleton design, for the most part. It would absolutely work depending on your intentions for what you want to do with additional instances of T.

Traditionally in a singleton design any additional instance of T would, instead of creating a new instance, would instead reference or copy the value of the original singleton instance of T.

If we compare the traditional definition, I don't believe the design you have provided would be considered working singleton. This is due to the fact it does not prevent additional instances from being created, it simply destroys any instances that pop up, and doesn't redirect attempts of instantiation of new instances to the original instance of T.

This may be useful in certain situations, and it certainly works, quite well actually.

The only thing I might see as a problem is that, at least in my testing of it, it randomly determines which additional instance to delete. I wasn't able to get it to destroy the same gameobject often when two of the same instance were in the scene at the start.

there would be 2 player objects at the same time

With the singleton-like design that you've provided, any players that derive from the SingletonMonobehaviour must have different generic runtime types of T(since otherwise they would be destroyed).

If your intentions are that they should both have the same generic type constraint as each other this design wont work.

If you wanted to have a traditional singleton pattern you may want to consider relaxing the constraint of MonoBehavior to be more inclusive of other types, or adding an additional constraint to allows anything of type T MonoBehavior can share a different resource. Such as the example below.

You could implement a singleton design that would allow all scripts to share a resource and prevent new instances with a similar pattern you've provided.

You have to clear the display in every frame with pygame.Surface.fill:

Consider checking every now and then if the player is spawned.

You can do this a couple ways.

This post covers a lot of different ways, I would recommend checking every couple frames.

For example you can find any object by it's tag, name, or even stuff like the components it has on it.

One way you could do it is to check for tag for example.

Disclaimer: novice here so take this with a pinch of salt. I've provided a solution below that certainly isn't the most elegant but will help you on your way without altering too much of your code.

• We can take the section of class 'fog' out entirely for the time being to simplify things a little.
• We then take the div of class 'absolute-bg' and place this immediately below the body, making sure that all of your remaining elements are within this div and therefore (visually) 'on top' of your background.
• We then set the 'absolute-bg' class to have a lower z-index than everything else (e.g. -1).
• Next, we can take the div of 'fog-container' and give it two simple CSS properties: position: fixed; top: 0;
• This removes the element from the Document flow and places it in a fixed position relative to the browser window, in this case, top: 0.
• Finally, you want to be able to click-through your div 'fog-container' which now sits 'on-top' of everything else when rendered, therefore, we can add these two properties to .fog-container: pointer-events: none; touch-action: none;

Hope this helps. Elegant, no? A push in the right direction? Hopefully!