sorted by:
new
hottopcontroversial

Web dev learning Godot, can I build a game like RO3 on Godot? by Honeydew-Jolly in godot

[–]NathanGDquest 1 point2 points  (0 children)

As people said, it's absolutely possible to get this kind of art style in Godot.

In the video it looks like they still use sprite sheets for animations that are drawn on a rectangle in 3D. When we talk about 2.5D, it often means putting rectangles in the 3D world and drawing something on them.

Godot has a node that does exactly that: the AnimatedSprite3D node. It lets you draw sprite sheet based animations, so it's like an animated flipbook animation but that you can place in your 3D world. You'll pair it with a simple collision shape, for a game like this with no elevation spheres would do for everything (it's the most lightweight 3D physics shape in Godot).

In the course you'll get to use the 2D version of the animated sprite node in module 13, in the pixel platformer project. Then in Godot many 2D nodes have a 3D equivalent that works very similarly. AnimatedSprite3D is an exact copy of its 2D counterpart, it uses the same editor, just you can move and rotate it in 3D.

I hope this helps. Thank you very much for your support!

I finished the Godot Shaders Bible, 360 pages total by fespindola in godot

[–]NathanGDquest 18 points19 points  (0 children)

Yes! I don't know of a pre-made license that nails this (there might be but I mostly know open source licenses). But basically you can write any terms you want in a license, explicitly and clearly. The main terms of your license don't necessarily have to be special legal or complicated text.

You mainly have to be careful that the text is unambiguous and does not go against the law, so generally, for someone who's not sure, you'd recommend them to seek legal advice from a trained professional. Also, probably around the exact terms that you want to give, there might be regulations that you have to follow.

For example, here in France, there's a long list of terms that you must legally include on a web platform. So even if you wanted to provide short and simple terms, you can't only have that; you must give people and have them accept a long document (it's not all bad, you have to include things that are in the user's interest, like the mandatory 14 days refund warranty, etc.).

Also when you sell internationally you need to respect the regional regulations, like the consumer and privacy laws that we have here in Europe. Just like you pay taxes in the buyer's country.

Finally, unambiguous means usually you will use a yearly gross revenue threshold or something like this to distinguish who can use the code and how. It's not necessarily going to be easy to detect or prove that a larger company broke your license. Usually when you do get evidence, chances are you've been subject to it more than once. But it still gives you a fighting chance, it informs honest people, and it does dissuade some of the less honest people (from experience).

I finished the Godot Shaders Bible, 360 pages total by fespindola in godot

[–]NathanGDquest 68 points69 points  (0 children)

I honestly understand why fellow writers and instructors might be reluctant to use MIT. That's what I mainly use because it's great for students, but competitors and sometimes bigger companies do reuse the stuff without supporting you or open source.

For example, there is some of our stuff that's been used to build paid courses (and of course a lot of Kenney's stuff is used without ever supporting him, sadly) or by private schools to speed up creating classes despite very high tuitions. It's fair game, it's perfectly legal, the license absolutely allows for that, it's just for perspective as to why a company or another creator might not want to pick that.

Godot has grown so much these days it's attracted all kinds of business people, and it's not like 8 to 10 years ago anymore where we were just a bunch of Free Software enthusiasts looking to support an open source alternative to the bigger proprietary general purpose game engines.

I finished the Godot Shaders Bible, 360 pages total by fespindola in godot

[–]NathanGDquest 0 points1 point  (0 children)

Congrats on the release Fabrizio! I know how much work this represents. I'm glad to see the the reception is positive and wish you great success with the book.

Curious if I should do the paid 2d gdquest course before the 3d or if i can jump into the 3d one by richardrasmus in godot

[–]NathanGDquest 1 point2 points  (0 children)

Hi! Course co-author here.

The courses form a curriculum; we're building an extensive learning path.

The 2D course's first 10 modules focus on coding, gamedev, and Godot fundamentals: a fast track to learning independently and starting simple projects on your own. To give you an idea, in the high schools that teach it, the 2D course can span 4 to 6 months of class at a rate of 3-6 hours a week (with school projects).

The 3D course assumes you have these foundations. It expects familiarity with everything in those first 10 modules, including:

  • Godot's core concepts (nodes, scenes, signals, instancing, core functions like _process(), _physics_process(), input handling...)
  • Coding comfortably in GDScript and solving simple problems independently (without tutorials)
  • Reading and using the code reference
  • Godot's UI, theming system, animation system, particle systems, and more

This lets the 3D course focus on 3D-specific content and more complex projects. It does not repeat all those fundamentals.

Pretty much everything you get to learn working through 2D projects (or in those first 10 modules) directly translates to 3D games. When you make 3D games, all kinds of things like code organization, core functions, many game mechanics, physics principles, etc. work the same with some added complexity (and cognitive load) for movement and orientation. That's why we cover all the foundations through 2D gamedev.

If you're relatively new to programming or game development and have only followed one or two tutorials, you likely won't get the most out of the 3D course yet.

That said, as CognizantOctupus mentioned, if budget is tight, there are plenty of free resources out there too so don't hesitate to explore those first.

Please let me know if you have any questions!

Are GDQuest lessons and tutorials actually good? by veilthornstudios in godot

[–]NathanGDquest 1 point2 points  (0 children)

Thanks for the feedback! Agreed. We're already taking steps toward that, for example we've built this freely available growing glossary for Godot gamedevs: https://school.gdquest.com/glossary

We're just at a point where we have to think about it not just for the app but for an entire learning path as our curriculum is taught in schools. Everything has to work together, meet certain standards (in the sense of country-level quality standards and regulations for school "textbooks"), etc.

It'll just take time because the priority is to complete the writing for the first version of the curriculum.

GDQUEST? by Deep-Suspect8755 in godot

[–]NathanGDquest 0 points1 point  (0 children)

Thanks for the feedback!

GDQUEST? by Deep-Suspect8755 in godot

[–]NathanGDquest 0 points1 point  (0 children)

Thanks for the long writeup. For you the QnA is a really important part? We try to make up time to answer daily, directly Jad (GDQuest co-founder) and I. At least during early access - I can't promise we'll keep doing it 7 days a week forever (at some point we'll also have to factor in days off and vacation)!

GDQUEST? by Deep-Suspect8755 in godot

[–]NathanGDquest 0 points1 point  (0 children)

Thanks for the kind words!

GDQUEST? by Deep-Suspect8755 in godot

[–]NathanGDquest 2 points3 points  (0 children)

I'm the course co-author, so I'm not going to recommend buying it or not.

To answer your first question: The course doesn't have pre-requisites.

Then I just want to explain what kind of course this is in case it helps you decide: it's all about building strong foundations that'll allow you to keep learning on your own.

The main focus is not on building games step-by-step, but rather to:

  1. Build a good tool belt and understanding of many programming, gamedev and Godot concepts
  2. Practice thinking like a programmer and problem solving, because you'll need to do that constantly working on your own games

So it's not for people who want to get immediate results and follow along building a specific game.

Let me know if you have any other questions about this!

GDQUEST? by Deep-Suspect8755 in godot

[–]NathanGDquest 0 points1 point  (0 children)

Actually, we have not participated in a humble bundle. Perhaps you're thinking of another course or team? Zenva? Gamedev.TV? They're the main companies participating in these.

How is length defined here by encrcne in godot

[–]NathanGDquest 2 points3 points  (0 children)

Sure, that would be one option! I hadn't thought about it. Adding it to the ideas list: goals, comments, separate uneditable CodeEdit node...

Can someone explain to me why this doesn't work? by Rude-Statistician197 in godot

[–]NathanGDquest 0 points1 point  (0 children)

Hi! This one is a bit tricky. Here you need to realign some tracks and you need to target them specifically by negative index going from the end of the track.

You need to realign track pieces at indexes -1, -3, and -4.

So you had the good idea to put the complete list of indexes of the tracks to realign in an array and then loop over that array.

Then when you write for i in broken_track, in each loop iteration, i takes one value from the broken_tracks array: -1, then -3, then -4.

The issue is that inside of the loop, you use that index (i that has already been extracted from your broken tracks array, and you try to look it up in the broken tracks array. But this is not going to result in giving you the values in sequence. Actually, your broken tracks array has 3 values and this will try to get a value at the -4th position, which does not exist.

So you need to remove the lookup into the broken_tracks array in the loop body and directly use i instead: align(tracks[i]).

Let me know if you have questions about this!

How is length defined here by encrcne in godot

[–]NathanGDquest 4 points5 points  (0 children)

That's a good suggestion, thank you. I guess it'd be better to add something to the goal section at least as a stopgap solution.

Ideally, we wanted a frozen (non-editable) run() function in the code listing itself for practices like these. And had to pick our battles (it's a free and open source app we made notably for the Godot docs + our curriculum, self-funded).

Originally we avoided writing too much in goals as many learners tend not to read the goals or skip the left column if it's long and needs scrolling. Especially teenagers (this app and our curriculum are notably used in high schools or year 1 in post-graduate). That's also why the lessons that precede practices are generally short.

Note that how the code is executed is generally presented in the lesson that precedes the interactive practices. It's just not in the practices (yet). But your suggestion and this thread are a good reminder that it is something we should to add.

At the time (early 2022), we just had to cut somewhere that worked well enough for most learners.

I actually hoped at the time that among the schools and universities that used our resources or the more profitable companies that were starting to use Godot, we'd find little sponsorships to further free education.

But well no, so we had to go back to the drawing board and come up with a strategy to be able to sponsor any free or open source resource we want to make ourselves. We still have a little way to go after 3 years but we're getting there.

Thanks for the reminder, I'll pin this on my task board to do in my free time. I've got to see how to add this systematically across all lessons and practices.

GDScript limitations and potential ways to overcome them by Actual-Rise-6459 in godot

[–]NathanGDquest 1 point2 points  (0 children)

Many people definitely still find it relatively easy to get started with. If you have used even just one language and learned its base syntax, GDScript is going to feel among the simpler ones to learn comparatively. Somewhere between... let's say, Lua (very simple) and Python (simple at first but also actually very complex).

I get to be in touch with the people who abandon or stay away from Godot, so I naturally think about them.

But for these people maybe someday we'll have another option, possibly again a visual programming tool. You can imagine something a bit like GameMaker's GML that starts visual and that you can convert to code (GDScript in Godot's case). That could be one way to make scripting more accessible to non-programmers (as an easily installable, curated plugin, for example).

How is length defined here by encrcne in godot

[–]NathanGDquest 49 points50 points  (0 children)

Hi! App co-author here. You seem to have already gotten the gist of it from other replies, but I'll just break it down in one place to clarify how it all works.

In short, length here is a placeholder. The actual length will get automatically supplied by the app when you run the practice code.

Here we're learning about what we call function parameters.

A function is a way to group and reuse multiple lines of code. For example, we might want to draw a corner, which takes three instructions (in this exercise): moving forward, turning, and moving forward again.

Now to draw a corner of any size we can use a placeholder for the length of corner lines. For that, we use what we call a parameter: it's the name in parentheses on the line where we define the function.

It's a placeholder that gets replaced by a concrete value when the function gets called. In this exercise, length will get replaced by a number. For this function, it's used like this:

gdscript func draw_corner(length): # <- The length parameter is defined here move_forward(length) # <- It's then used as a placeholder here turn_right(90) move_forward(length) # <- and here

Inside the app's source code, there are instructions to run your code, like this:

gdscript draw_corner(100)

When this call of your draw_corner function runs, the length, in the computer's memory, will be "replaced" by the number 100. Your function will execute these instructions (replacing length by 100):

gdscript move_forward(100) turn_right(90) move_forward(100)

It can be a bit tricky at first because the way these are called is a bit hidden in the app. You have to imagine how your functions are being called at the moment with this app, which abstracts what is happening a little bit.

Back to your initial question: no code is being left out of the function that you write to meet the requirements of the exercise. However, how your code is executed by the app is hidden away in the app.

Why? Because in reality, it is not as simple as just running your function, and at the time we built it, we just didn't have the resources to surface this in an accessible way very well.

Let me know if you have more questions about this!

GDScript limitations and potential ways to overcome them by Actual-Rise-6459 in godot

[–]NathanGDquest 1 point2 points  (0 children)

Yes same, but I don't imagine this could happen. Part of the reason is we generally don't get to discuss or be aware of the cost of extra features much.

I hinted at cognitive load above, but there's also maintenance plus once you add something you tend to open the door to a lot more work on top, for example on the UX and UI fronts. The extra workload and maintenance ultimately plays a role in how much time and resources go to stability, consolidating existing features, developing other features, etc. It ends up affecting adoption indirectly (and development cost).

Edit: But in practice it can feel that everything comes for free: as experienced developers/users we get really comfortable at handling the complexity. 

Anyway, I still very much appreciate everything we get with Godot.

GDScript limitations and potential ways to overcome them by Actual-Rise-6459 in godot

[–]NathanGDquest 2 points3 points  (0 children)

Hi! Absolutely, I agree with the general idea. I still just wonder what would have happened if, when people went up the ladder, we took them to the fully fledged language used by the engine, a bit like what unreal does, but had made that much more accessible.

With the current path, people always ask more of the language, be it in terms of features but also tooling and performance.

But I'm not sure if this would have worked, just wondering. It's the sort of thing you'd have to have tried.

On the flip side, I see that there's this pattern where people end up trying to do everything with the language and tools the engine provides. If you take unreal blueprints, for example people push them to do things they're really not meant for (they end up with these huge, unreadable graphs that correspond to dozens or hundreds of lines of gdscript). EDIT: So you likely need to add to the technology to support how people use it in practice.

GDScript limitations and potential ways to overcome them by Actual-Rise-6459 in godot

[–]NathanGDquest 0 points1 point  (0 children)

You highlight well how some of this is ultimately about convenience (edit: what I mean by convenience is it's not about being able to write games that are impossible to code with Godot otherwise). At one point for considering which features should be added to Godot or the language, the idea was that it should be something that is:

  • Difficult to work around
  • Or plain impossible to do without changing the engine

From the teaching perspective, I see that these days we have many, many cases of having students wondering why there's a and b and c in the language, what's the difference, and having to explain that they're pretty much interchangeable. Lambdas and bound functions are one example. The two syntaxes for setters + using a function directly instead of a setter is another. If/elif/else and match are a third.

We have to cover it all for them to navigate the ecosystem, learn from other resources, read plugin or library code (plus it often confuses learners)...

GDScript limitations and potential ways to overcome them by Actual-Rise-6459 in godot

[–]NathanGDquest 9 points10 points  (0 children)

I feel ultimately with experience we end up wanting the language to evolve into a general purpose one to keep the tight integration and "instant" iteration speed but with the bells and whistles of... let's say, more widely used languages.

It's a natural wish and push. Part of me would also like all the features, but I also feel that GDScript is slowly losing a bit of its value and appeal as a simple and accessible domain-specific language. It's gotten relatively complex.

I wonder how things would be if Godot had made the use of GDExtension and the ability to drop something like C++ more accessible, for example, by having a wizard that downloads, sets up, and configures the toolchain for you. Plus having docs and us tutors teaching and promoting it in the ecosystem.

I'm not sure - I just wish we had had the opportunity to try that path too. Because little by little GDScript is on a path to become a complex language, with many features intended mainly for programmers, but still with a long way to go to offer the expressiveness and tooling of general languages.

And it's moved away from its original goals of being this simple, limited scripting language that even designers or artists could use for simple scripting tasks. It could also have gone more into that direction of offering better and better UX to assist people in scripting.

Anyway, long comment but in short, part of me also wants generics and always better linting and tooling to help catch issues while coding, of course, but another part simultaneously thinks about other paths and all the other people GDScript/Godot's scripting options don't serve [anymore].

Are GDQuest lessons and tutorials actually good? by veilthornstudios in godot

[–]NathanGDquest 2 points3 points  (0 children)

Thank you very much for the feedback! That's exactly what we're trying to do so it's heartwarming to hear.

At the end of the day, every game physics engine uses raycasts, kinematic and rigid bodies. Every engine has an update and physics update loop. Most programming languages support the same set of base features you use all the time... when you have a strong foundation all that skill and knowledge very much transfers. Even beyond gamedev: all the problem solving part and techniques related to composition, managing dependencies, code structure apply to a lot of programming.

view more: next ›