finepointcgi / finepointcgi-suggestions Goto Github PK

Small but very handy two tutorials for those who want to learn some patterns, It can be as short as 6-10 mins. One video with C# and one with GDScript.

1. Autoload.
2. Adding new signals.
3. Emitting signals.
4. Naming convension, like past tense and adding on_ prefix for connected functions.
5. Passing args in signals.
6. Using new syntax like EventBus.item_spawned.connect(on_item_spawned) and EventBus.item_spawned.emit().

This is more good practise tutorial, but still can be helpful for viewers. The video can elaborate about memory leaks, how to find them, how to fix them and how they can impact the game and gameplay if not treated properly. It could also include information about using Memory Profiler in Godot 4.

As followup to suggestions with Epic Online Services, I found this repo.

It's maybe a good idea to investigate since Playfab has something like Free to Start tier. Playfab looks more "friendly" to use than EOS.

That suggestion can be a part of whole Multiplayer series, including said EOS suggestion and LAN suggestion. It's can be for example creating same project with different approaches - LAN, P2P, client-server.

That can show differences in multiplayer topologies, Also as a conclusion it could show developers how to create more non provider-locked game. By seeing changes you have to do to switch between for example transforming LAN game into p2p game not experienced devs can take into consideration that to do and that not to do having possible future switch in their games in mind.

This suggestion is all about using the viewport texture with hooked camera and simple pc monitor or tv screen to show camera feed. It's interesting feature for some games like e.g. horror game when player discovers the hidden security room with the feed from cameras in all of the rooms, that shows there is a real person behind all odd events.

The other example of using this feature is for more strategic games in which player needs to has control over rooms simultaneously.

I want to add another suggestion what can be helpful and handy while developing games.

Tutorial could show, how to create simple and universal console. Console can be based on Singleton / Custom Node / Scene with something like pseudo-code below:

signal help()

var functions_dict : Dictionary = {
    "help": {
        "number_of_args": 0,
        "context": self,
        "signal": "help"
    }
}



func register_function(name : String, number_of_args : int, context : Node2D, signal : String) -> bool:
    if name in functions_dict: return false
    functions_dict[name] = {number_of_args, context, signal}
    retrun true
    
func unregister_function(name : String) -> bool:
    if name not in functions_dict: return false

    functions.dict.erase(name)
    return true
    
func _on_command_submitted(cmd_line : String):
    var args : Array = cmd_line.split(" ")
    var cmd = args.pop_front()
    if cmd not in functions_dict:
        output_line("Command "+str(cmd)+" not found.")
        return
    if args.size() < functions_dict[cmd].number_of_args:
        output_line("Not enough arguments for "+str(cmd)+" ("+str(args.size())+" instead of "+str(functions_dict[cmd].number_of_args)+").")
        return

    if args.size() > functions_dict[cmd].number_of_args:
        output_line("Too many arguments for "+str(cmd)+" ("+str(args.size())+" instead of "+str(functions_dict[cmd].number_of_args)+").")

    functions_dict[cmd].context.emit_signal(functions_dict[cmd].signal)

func get_commands():
    output_line("List of the commands:")
    for cmd in functions_dict:
        output_line(str(cmd) + " (number of args "+str*functions_dict[cmd].number_of_args+")")

func output_line():
    # add text line at the bottom of the rich text / add label to vboxcontainer and scroll down in scrollcontainer    

1. We keep track of available commands with default help command.
2. User can register functions/commands from own nodes by DebugConsole.register_function and remove it by DebugConsole.unregister_function, e.g.:

# Player.gd

var health = 100
signal heal

func _ready():
    DebugConsole.register_function("heal", 0, self, "heal")
    heal.connect(_on_heal_called)

func _on_heal_called():
    health = 100

func _exit_tree():
    DebugConsole.unregister_function("heal")

3. Then command is submitted with some UI like TextEdit, the TextEdit is cleared and .text content is passed into _on_command_submitted().
4. If command exists in dictionary then signal is emitted on given context (Node2D).

We can also use functions instead of signals for simplicity.

Now that Godots support for C++ modules work a tutorial on how to use it would be useful.

I've some small ideas to expand your mobile series. These are loose suggestions, as content on mobile topics is probably the least available. My suggestions are targeting Godot 4 / 4.1 as 4.1 will be released soon.

Beginners:

• Mobile projects settings.
• Saving config/user data - solutions, encryption.
• Recreating known games (their features or controls, not entire games), for example:
  • Daily reward (simple as saving locally last date then player get reward and compare with actual)
• Optimization.
• Typical problems with mobile builds - how to debug and fix them, for example:
  • Black screen.
  • Gradle errors.
  • Crashes.
  • Logcat.
• In-app rating/review.
• Basic mobile input / virtual joystick.

Advanced:

• Custom export templates
• Update for AdMob (with for example this one with building .aar file for Godot version).
• Update for Google Play Games Services (any of existing plugins, just needs some updates, like package versions and rebuilding, but it works - I've tested it).
• Firebase Realtime Database (maybe small multiplayer project, like Pong)
• Sensor-based project (investigate).
• Screenshot sharing

Some suggestions are based on problems that I encounter in my way to publish game, some not. 😊
If something is already added - I'm sorry. 😉

Your tutorial about Nakama with WebRTC plugin by dsnopek was very great. WebRTC is a good middle-point between p2p with NAT-punch (which can be hard to setup) and autoritative server.

1. Websocket server is listening for connections from Godot clients. Server doesn't know anything, just relays messages.
2. Godot WebRTC creates client and generate peer ID.
3. Godot client connects to WS server with some data, like peer ID, if client want to join or create session and session name.
4. If session exists, then server is adding data sent by client to session and broadcast message about change to others. If session doesn't exist, then server creates it and adds client.
5. The client also receives message from server with information about other players and session.
6. The client sends an offer to the server (for every peer ID) and server sends it to other players.
7. After receiving the offer other clients respond with an answer message with data like network preferences.
8. The server forwards answer messages to the client.
9. The clients are trying to connect with each other using ICE candidates. If success, then clients establish WebRTC connection.
10. All of the clients in the session do the same to establish WebRTC connections (mesh).
11. If all of the players are connected the game can start.

Here we have Minimal WebRTC example in Godot. The example shows two players (Chat instances) in one game communicating via WebRTC through local signaling (also in-game).

Herer we have more real life example for WebRTC with Signaling Server. The example covers separated signaling server. In the example we have two implementations of the signaling server - one in GDScript and one in Node.js.

The server part of that multiplayer topology if fairly simple:

1. Create and expose websocket server.
2. The Node.js implementation has two classes Lobby and Peer.
3. Messages for communication have very simple json object format:

{
  "id": 0,
  "type": 0,
  "data": ""
}

so we have basic validation in place.
4. Then the connection is open the peer is added to players list and server starts to listen for the messages.
5. All incoming messages are parsed and then treated accordingly to the type.
6. Peer is disconnected if invalid message was sent.
7. Additionaly to keep connections established Node.js implementation sends ping to every connected client every 10s.

As there is server variant in GDScript you can just skip Node.js part. If you want to cover it then you can use for example Glitch to host server for free without need to setup whole Node.js env on PC (easier to follow along).

WebRTC is technology created with browsers in mind, so webrtc-native plugin is needed.

This suggestion is for overview of alternatives to Blender.
Blender is a great and powerful tool, but it could be helpful to show alternatives, because Blender can be hard to pick up in short time for example for people that are working on their games 2-4 h per week.

My suggestions are:

• MagicaVoxel (voxel graphics; sadly, no glTF support out of the box)
• Goxel (voxel graphics; with glTF support)
• BlockBench (simple creating and texturing, glTF supported, good for very fast prototyping)
• Dust3D (creating 3D models from kind of 2Dish approach)

It's also a good idea to tell in this context about Godot's CGS and prototyping with them.

This suggestion is about await keyword, as yield is replaced in Godot 4. Bite-sized video can be created with length between 3-5 minutes.

Things to cover:

• await for signals
• await for signals with parameters
• await for coroutines
• differences between yield and await

Simple suggestion for Horror Series. To add some anxiety and confuse player it'll be great to utilize is_visible_in_tree() / is_position_in_frustum() to move or remove certain, small object from the surroundings.

It can be done with for example 5% of chance to some object to dissapear or move or maybe rotate while player is looking in different direction. 😉

compile godot and export templates explicitly for 2d games and the apk size optimisation?

Creating a good fps character controller can be hard that should be on the list

• Series prehaps?

As in the title - tutorial about creating Godot 4 plugin. For example it can be plugin for something reusable from your Horror Game series, like Flexible Level Loading Plugin. Optionally would be great if the process of submitting to Assets Store can be included or just described. 😊

With this whole tutorial some devs (maybe) would be more willing to create more encapsulated code and add their own plugins to the Godot Assets Library.

openai api in pretty good but.. it's not updated to godot 4 and gdscript 2.0, so isn't google bard api would be a better choice?
it's still learning, it's updated to gdscript 2.0 and personally i prefer it
so if it's possible to integrate in in godot can u please make a tutorial about it?, would be pretty useful

Godot 4 multiplayer is important. We should look at Server and Client code

• Perhaps add dedicated server mode
• We may need an api if we are going to do a dedicated server because each game instance would need to be a seperate instance

We should learn the basics of how to build game ready buildings in Blender

Looking at your Survival Game Framework I'm assuming that you're planning to create Survival tutorial series. My suggestion can be a little addition to it.

Creating simple character Creator / Configurator system with for example:

• 2+ simple base body models.
• 2+ haricuts (low/mid poly).
• 2+ clothes / dresses / suits or something similar.

Tutorial can show:

• How to attempt to create this system.
• Preparing and creating models in Blender.
• Setting simple scene with character preview and simple UI, like:
  • < Body Type >.
  • < Hair >.
  • < Clothes >.
• Saving created character locally in format like:

{
    "characterCustomization": {
        "bodyId": 0,
        "hairId": 1,
        "clothesId": 0
    }
}

• Loading saved data and applying it to the player character.

As a 3D tutorial it can connect your Godot tutorials with Blender tutorials. If it's too much for 3D it will also be useful as 2D tutorial.

There are some solutions and ways to create destructible terrain in Godot. It would be great to have one up to date tutorial about this topic.

Some hits:

• Using Geometry class with boolean operations.
• Using Clipper and Triangulator like in this repo.
• Using QuadTrees (I found QuadTree implementation example).
• Using grid/array/tilemap (Cellular Automata).

I'm thinking about destructible terrain like in Soldat or Worms. If you aren't interested in this topic it's ok for me to close suggestion. If you want to go with it, then this suggestion can become a part of Algorithms in Games Suggestion.

Tutorial about creating GDExtension. It can be created like tutorial for Android Plugins:

• Setup
• Configuration
• Creating
• Testing
• Real-life example, like in Android Plugin

This tutorial can be linked with submitting to Assets Library from that suggestion.

projects like zero-shot tortoise-tts and bark.

If you like ML/AI, it can be interesting to create small tutorial about creating voice lines for game character with just own voice and for example said tortoise-tts.

By using a few short audio clips of yourself talking, you can create massive number of voice lines for your character with different intonations. For example it can be used for the blacksmith npc, by generating 5, 10, 15 or even more greetings like:
Hey hero, what do you need?
Do you want to buy something? I don't have nerves of steel.
Take this junk and get out.
Steel, steel, steel, beautiful steel. If you have gold, I'll give it to you.
I'll make you a sword! I give you my word!

PGSGP doesn't show Leaderboard when TranslationServer.set_locale is set to any other language. It only displays the Leaderboard when the locale is set to "en"

I found something like all in one Firebase Godot Repo that can be a good thing to refresh Godot Firebase series.

Repository includes:

• Auth
• Firestore
• Realtime Database
• Storage
• Dynamic Links
• Cloud Functions

Repo is cross-platform, so you can include tutorials like:

• Setting up
• Exporting Project
• Exporting to Android
• Storing and receiving data with Firestore
• Storing optional / on-demand assets with Storage
• Simple Godot app to generate dynamic links
• Multiplayer / communication / chat with Realtime Database

The last one can be also a part of Multiplayer Series.

Please do a tuitorial on offline LAN Multiplayer game connection.Thanks

This suggestion is about adding fog of war effect for 2D games. Fog of war is ofter used in top down strategy/rts/roguelike games.

Fog of war examples:

1. The light attached to player in dark env.
2. The shader that masks terrain based on player vision range.

It's maybe an idea for one long video, but it would be better (and easier to find by searchers) to create new series if you're interested in making tutorials on this topic.

• ANNs
• Minimax Search
• Pathfinding
• Procedural Generation
• Sorting
• Alpha-Beta Pruning
• Monte Carlo Methods

Some of them can be included in maybe turn-based project, or point and click as part of that suggestion.

I don't know why, but it seems like some people like Gappling gun mechanic in 3D games for fast moving or effective traveling with the First Person Controler. In 3D it can be as simple as:

1. Casting ray from camera node.
2. Checking if ray cast is coliding with something after is_action_just_pressed.
3. If ray cast is colliding let's get this point.
4. Disable gravity and move/lerp player to the point.
5. If player is close enough enable gravity and disable moving/lerping.

Tutorial can be also combined with enabling grappling to another point while the player is in air or offseting y of collision point a little to give player the ability to get on the edge of block/element that is grappling to.

As an additional tip you can add that if colliding with ray cast object is for example rigidbody, then the object will be pulled to the player, not the player to the object.

In 2D it can be more challenging because of differences in implementing controls, but it also can be covered as a separated tutorial.

Overview of Tween in Godot 4. Maybe short introducction to changes between 3.x and 4.x approach for animation with Tween and then some examples of it (tweening different properties, tweening to position, etc.).

This idea covers the in-game 3d space screens or something similar that enables player to interact with. For example we can have a touchscreen with numpad to insert the code. Also we can have for example some vitals / stats / health / map / radar shown on the in-game screen (or any kind of surface).

The idea of suggestion is to show how to properly bring the UI elements or interactive UI elements into 3D space.

Tutorial on Composition Design Pattern. This could be a good introduction for a series of texts or videos on design patterns.

• Composition in game dev:
  • Pros, like:
    • Reusability
    • Modularity
    • Easy work with designers
    • Extensibility
  • Cons, like:
    • Code Redundancy
    • Complexity
• Creating simple components:
  • Floating Text component
  • Health component
  • Hitbox component
  • Pickable component
  • Consumable component
• Dealing with dependency with for example signals, @export, etc.

Tutorials like this can be useful for developers who want to improve their skills, or for solo developers who want to start working with teams.

Composition in Godot can also be related to [Creating Godot 4 Plugin}(https://github.com//issues/20) suggestion.

Investigate and create a C# and GD version of the A* navigation system

I absolutely love series, especially short ones.
Would you make a very simple and easy pnc game - including saving, menu, loading, exporting.
Many of those topics were covered but integrating all of them is a bit different.
It would be lovely to see 6 videos, 10min each taking you from nothing to an exported 3d game ready to be played, at least first level.
Why point and click 3D? In my opinion this would be the easiest thing to make in under 1 hour.
Why series? I believe that series attract many people. You can check out other youtubers. Moreover, this could be a standard goto for beginners just starting out with Godot 4, for people that just want to make something quick and easy while also being challenging (making the whole game).
Thanks.

Next suggestion is a day / night cycle in four variants as two or four tutorials, also short and straight to the point.

One option:

1. 2D in C# and GDScript.
2. 3D in C# and GDScript.

or maybe:

1. 2D in GDScript.
2. 2D in C#.
3. 3D in GDScript.
4. 3D in C#.

Include how to rotate pan and zoom both c# GD Script

This suggestion is for future, not now. For now it will be too much work to do.

Epic Online Services are free and are very powerful. Maybe in the near future we will get some good plugins or wrappers aroud EOS SDK for Godot 4. It's a good (and hot) topic to have in mind.

At this moment I found only Epic Online Services Godot by 3ddelano, but I think that more projects like this, or GDExtensions or maybe something from Epic Games can be created.

Epic Online Services used in Godot can overcome popularity of PUN / Photon Fusion for Unity.

Examples or projects created with EOS and Godot 4 can be smaller and easier to explain than for example Nakama, where more aspects of network topology, server code and more hassle is needed.

EOS have very long list of interfaces that could be introduced:

• Achievements
• Anti-Cheat
• Connect
• Invites
• Leaderboards
• Lobbies
• Logging
• Metrics
• NAT P2P
• Player Data Storage
• Reports
• Sanctions
• Sessions
• Statistics
• Storage
• Voice

This could be easy divided into series of tutorials or maybe multiplayer expansion for Horror Game Series.
For example:

1. Configuration and setting up Epic Online Services in Godot 4.
2. Auth with EOS in Godot 4.
3. Lobbies - creating, joining, searching (Lobbies + P2P).
4. Invites and implementation.
5. Sessions and game loop.
6. Leaderboards for end match screen.
7. Player stats after match.
8. Simple economy and storage.
9. Achievemnts for players.
10. In-game voice chat during match.
11. Reporting player - sanctions.

It can be created on top of Horror Game Series, or as a separated project prototype, for example recreations of something very easy, barebones, like Haxballl, Pong. It can be also created on top of Local Area Network from this suggestion. Just to work with EOS and don't have to create game from scratch, but use your existing tutorial / series and link things with each other. 😉

Cross-platform aspect of EOS is also good alternative for Steamworks.

This suggestion can be a small series for recreating game like chrome://dino - endless runner with simple controls (e.x. dodge and jump) and with random generated obstacles.

If suggestion will better fit in standalone video, then it can cover just random gen aspect and spawning->moving->freeing obstacles. If it'll better fit as a series then:

1. Showcase: showing end result with topics which are going to be covered.
2. Scene setup: simple ground sprite, simple two obstacles (for example box and bird), start button.
3. Player setup: sprite, jumping
4. All about obstacles: creating instances, adding movement, as a starting point it can be simple spawning one obstacle every timer.timeout singal.
5. Features: we have player, simple obstacles and start button, so now we can detect collisions and make some logic for game over/restart/score.
6. Random generations of obstacles: Let's now add some replayability and randomness to game. We can add something like increasing obstacles speed multiplier, taking random element from array of obstacles, setting random timer values, etc.

As of number of needed assets is minimal you can just grab for example:

• Ghost sprite as Player
• Tombstone as a grounded obstacle
• Bat as a flying obstacle

And we can have simple and fun example of Halloween game for the future. 😉

You can also export HTML version and host it on your website, because it should be small.

I think it will be worth to keep an eye on W4 Cloud. You for sure heard about it, but I want to add it here as a suggestion for future reference or videos.

• W4 Games website
• Democratizing Multiplayer with Godot

I can see it as low entry level between Nakama and custom backend. As stated in this post early access is starting in July and all multiplayer features should (or will) be ready in Q4 of 2023.

If you're interested, it could be good to join the early access and maybe be ready with tutorials for official launch. 😊

I have read different opinions about this project (mostly on reddit), but the thing about opinions is that everyone has their own. 😉

Some survival games are giving ability for player to place some objects like a tent or a campfire. It'll be great to see tutorial that implements feature like this.

How can it be implemented:

1. Player is choosing what to place, for example the campfire.
2. Casting ray from camera.
3. If ray collides with something, let's get surface normal.
4. If normal is close to y = -1 then we can show the shadow of object as the indicator of possible placement.
5. If step 4th, then we can check for player action just pressed and instantiate the object.

I think that this suggestion is simple, but covering topics like vector math and ray casting on real world example can be helpful.

As said in other suggestions, all multiplayer ideas can be packed into one series. The easiest way to go would be creating one, simple project and then convert it to different multiplayer suggestions or to have one starting project and starting from it.

1. LAN Multiplayer
2. Client-Server with Godot Networking
3. EOS Multiplayer
4. Playfab Multiplayer
5. Firebase (Realtime)
6. WebRTC with Websocket Signaling Server

and so on. 😊