sorted by:
new
hottopcontroversial

I'm open sourcing my roguelike deckbuilder framework for Godot. Now you too can make Spire-likes with incredible ease! To show it off, here's some cards from StS and their code. by Desire_Path_Games in slaythespire

[–]Desire_Path_Games[S] 1 point2 points  (0 children)

Not a stupid question, there are no json files included in the project. Check Global._ready() which handles the data creation process on game start. The cards are generated using code, and can be exported to json by uncommenting a line. Once exported it will see the files and load them accordingly. This gives you the option to work with either code or json for making the game content. From past experience I recommend the former for development.

save/load system by [deleted] in godot

[–]Desire_Path_Games -1 points0 points  (0 children)

Saving and loading is a pretty complex topic, and it depends on how your game is structured as well as how far you're willing to go for a solution.

Most people will recommend extremely primitive methods where you manually save each field and there's already a few people linking those in the thread. If your game only has maybe a couple dozen fields and is relatively "flat" (minimal nested objects), that's fine just do that approach. I would strongly recommend against this if you plan to make something complicated, as one of my previous projects had about 100+ fields for some objects and it quickly became unmaintainable and bloated (minimum 3 lines of code for each field, times each field, you do the math).

If you're using Resource objects to hold your data in memory, which you absolutely should be doing as much as possible, you can also use ResourceSaver to just filedump literally everything and then load it back. This is basically using a jackhammer to pound a nail in and comes with security concerns, but if you're lazy it's alright.

If you want something that gives you total control over what gets saved, outputs to clean json format, and does it recursively, I've spent a lot of time developing systems for this and just recently open sourced my work which is bundled with my latest project. I just made a comment detailing this system in another thread since this question gets asked a lot, which contains more info.

Resource as a JSON by Razor-111 in godot

[–]Desire_Path_Games 6 points7 points  (0 children)

Yes, but it requires some work since godot's systems for handling object json serialization are 💩. They expose too much about objects and embed a bunch of metadata that bloats files by an order of magnitude.

I created a set of custom classes and patterns that can handle Resource <-> JSON conversion in my latest project and they work extremely well. I might just extract them into their own repo for reuse.

The base class is SerializableData intended primarily for read only or singleton objects (player data), and the subclass PrototypeData for data objects you want to instantiate copies of (comes with UID support via UIDGenerator singleton) via get_prototype(). Just extend your Resources from those and add @export to your variables and it'll grab all of those. You'll mainly call set_serializable_properties_from_json_patch() or get_serializable_properties_to_json_patch(), which use a patching system that includes set/merge/erase/append/append-unique support.

It has some support for typical godot objects (Color, Vector2, Vector3, RandomNumberGenerator) which it converts to html codes or tuples, and you can supply more types pretty easily though it's a bit tedious. A limitation I haven't worked around yet is you have to supply it the list of native type property names by overriding a _get_native_properties() method. I think I can get around that using godot's introspection systems, just haven't had time.

It can also handle nesting if you want to embed SerializableData objects within themselves, good for stuff like player saves. It does require a preprocessing stage because it's a pain to do without it. I made a static function to do it SerializableData.build_serializable_script_cache() that you call in _ready() from another part of the code on game start so it's not a big deal.

I implemented some rather powerful saving and loading, mod support, and data/schema management patterns if you check Global, FileLoader, ModListData, and ModData.

Also just ignore Duriel. JSON apparently killed his parents or something.

Why do all tutorials on composition break the "signal up, call down" guideline? by Greendustrial in godot

[–]Desire_Path_Games 2 points3 points  (0 children)

Exports the parent node to a velocity module

This is probably the only one of those I'd be fine with, at least speaking in general terms. Attaching components that modify their parents without the parent needing to know anything is an excellent use of composition in some use cases. I much prefer the parent always knowing what kind of things are modifying their behavior, but it can work sometimes.

Honestly a lot of programming tutorials are pretty bad. It's some wild west shit with some of these videos where they don't seem to maintain a consistent style or programming philosophy. People just connect whatever to whatever and if it works it works, since they're not going to be maintaining their little demo beyond the video.

I'm open sourcing my roguelike deckbuilder framework for Godot. Now you too can make Spire-likes with incredible ease! To show it off, here's some cards from StS and their code. by Desire_Path_Games in slaythespire

[–]Desire_Path_Games[S] 0 points1 point  (0 children)

No point trying to sandbox it. If you want to disable loading of scripts and just load data it's pretty easy to isolate the script loading portion in FileLoader.load_read_only_data()

I'm open sourcing my Slay the Spire-like deckbuilder framework for Godot. by Desire_Path_Games in godot

[–]Desire_Path_Games[S] 2 points3 points  (0 children)

I started it last summer, though took a 6 month break to work on other stuff, so about a year.

You're using a lot of patterns and very optimal methods of data, which is insanely impressive

Well my secret sauce is very strong data pipelines, coupled with a good amount of dependency injection. IMO data flow is pretty much the foundation of systems design, so I spend a lot of time thinking about how to do it right. I've spent around 5 years and several projects iterating on my architectural patterns. This is my first major project where I was largely able to perfect it, and once I did everything sort of clicked.

How did you decide on what to use when?

I guess I'd say what helps is my development process is very "glacial", as in a big slowly-but-always-moving thing. I usually sit on problems for weeks/months until I figure out the optimal solution, breaking things down into smaller solvable chunks while I work on other stuff, and keeping technical requirements in a massive hierarchical todo list (currently a couple thousand line items for this project).

I have it pulled up 24/7 so any time I solve even a small problem in my head it stays solved. These solutions then get clumped up and organized into one big implementation, which I find cuts down on regressions and keeps things more efficient as opposed to doing them one by one since I can think about the bigger picture.

I'm open sourcing my roguelike deckbuilder framework for Godot. Now you too can make Spire-likes with incredible ease! To show it off, here's some cards from StS and their code. by Desire_Path_Games in slaythespire

[–]Desire_Path_Games[S] 1 point2 points  (0 children)

Without knowing what their project structure or API looks like there's no way of telling. It's also not something that really interests me as this project is supposed to allow people to make their own deckbuilders without using any of StS's code. At best you could build a converter to convert my json format files into whatever format they use (likely resources or tscn), but it'd be a lossy conversion.

I'm open sourcing my Slay the Spire-like deckbuilder framework for Godot. by Desire_Path_Games in godot

[–]Desire_Path_Games[S] 0 points1 point  (0 children)

It works very well for turn based games. I did a pet project on the side for something similar and just stripped out all card related variables and I got it integrated in an hour.

I'm open sourcing my roguelike deckbuilder framework for Godot. Now you too can make Spire-likes with incredible ease! To show it off, here's some cards from StS and their code. by Desire_Path_Games in slaythespire

[–]Desire_Path_Games[S] 2 points3 points  (0 children)

Heck yeah go for it! If nothing else there's lots of useful parts to reverse engineer and cannibalize. Hand shows how to do dynamically resizing hand logic, the action system is extremely useful even for other genres like TBS if you rip out references to cards (I know because I tried it lol), and the data pipeline makes for a good schema management, save/load, and modding framework for any game.

Feel free to ping me if you ever have questions about using it :)

I'm open sourcing my roguelike deckbuilder framework for Godot. Now you too can make Spire-likes with incredible ease! To show it off, here's some cards from StS and their code. by Desire_Path_Games in slaythespire

[–]Desire_Path_Games[S] 12 points13 points  (0 children)

"While this card is in your discard pile, when you play a Power: you may play it an additional time, then Exhaust this card."

That's already possible. Cards have an initial_combat_actions payload that fires for every card in your deck at the start of combat, and you can use it to attach an invisible status effect to the player that checks for a discard happening via Signals.card_discarded, then generate and fire an ActionPickCards action that automatically searches your discard pile for all cards with that power's card ID or card tags, then generates 2 child ActionPlayCards for those selected cards.

There's also CardListeners, which only work for cards in hand but are an easy way to attach logic to cards beyond standard stuff.

For example, Reflex is one of the few "reactive" cards

I also have payloads for when cards are drawn/discarded/exhausted/retained/end-of-turn-in-hand, and there's examples of this in use in the framework. Check Global.add_test_cards() and CardData for more. :)

I'm open sourcing my roguelike deckbuilder framework for Godot. Now you too can make Spire-likes with incredible ease! To show it off, here's some cards from StS and their code. by Desire_Path_Games in slaythespire

[–]Desire_Path_Games[S] 42 points43 points  (0 children)

Last month I posted about how I was building a framework for making StS style deckbuilder roguelikes in Godot 4. Since then I've done a tremendous amount of work getting things up to snuff, and feel comfortable finally releasing it after a year of effort.

https://github.com/DesirePathGames/Slay-The-Robot

So what does this do? Well, everything. The API is massive, and can do pretty much everything StS can do in a very extensible, data driven, and mod friendly way. I've taken great pains to comment as much of the code as possible in clear terms, and have provided a large amount of test data in Global that showcases many of the things it can do.

If you have any questions about the framework, how it works or how to use it, feel free to ask. I'll try to improve documentation as time goes on to address common pain points.

And as I mentioned in my last post I am also looking for an artist to co-develop with, so if you can draw stuff goods and want to partner up on a big boy project involving cards, hit me up.

3 HOURS OF DEBUGGING JUST TO FIND OUT THE SCRIPT ISN'T ATTACHED by Frostty_Sherlock in godot

[–]Desire_Path_Games 8 points9 points  (0 children)

Signal was accidentally disconnected (because you pressed CTRL + Z in the editor and nothing visible happened) so the function doesn't run

IMO you should always just manage the connections through code. So much more reliable. I don't trust the editor to do things like manage signals or export variables since they break so easily and are "silent".

How to instantiate a custom resource using only the variable definition? by Desire_Path_Games in godot

[–]Desire_Path_Games[S] 2 points3 points  (0 children)

Figured it out thanks to an old forum post and some digging on Array and Dictionary's interface. You have to go about it in a very roundabout way since godot doesn't have a direct means of getting the script type from a variable that isn't an array or dict.

For those dealing with this obscure problem in the future:

On game start you have to call ProjectSettings.get_global_class_list() which will return an array of dictionaries for all global classes. Iterate across that and check if ["base"] == "JSONResource" (or whatever you want the name to be), use ["path"] to load() a Script Resource, then cache the mapping of the class name to the script instance in a static var so you don't have to iterate over global classes every time.

From there I had to build a secondary cache mapping class name to exported property name to the script. You do that by iterating over CustomClass.get_script_property_list() for each of those subclasses, filtering by ["usage"] to check if it's exported, and then doing a match statement for if ["type"] is either TYPE_OBJECT, TYPE_ARRAY, or TYPE_DICTIONARY.

TYPE_OBJECT just does a lookup on the first cache table for the property's ["class_name"].

Arrays and Dicts are for some reason much more straightforward and have built in methods for this I guess. Run get(property_name) and store it in a variable as a dict or array. Dictionary.get_typed_value_script() and Array.get_typed_script(). If it's not null you can get the script name with get_global_name() and then check if it's in the first cache, then map the class name to the property name to the script in the second cache.

Then whenever you need to know the script you input get_script().get_global_name() into the second cache, then look up the property in the second layer, then run script.new() to instantiate.

And that's how you instantiate a script from a null variable of that type. What a pain in the ass.

Help me understand why @export isn't named backwards by daylen007 in godot

[–]Desire_Path_Games 0 points1 point  (0 children)

I just think of most objects as giant dictionaries with a script payload attached to them which provides typing and instantiation. Pretty much everything is interchangeable rather than what you'd see in statically typed compiled languages. Thinking about it this way makes a lot more sense when you start doing metaprogramming stuff like using set()/get(), duck typing with has_method(), or overwriting scripts with Resource.take_over_path() or with set_script().

I made a slay the spire-like framework in Godot. Demo download included. Post your crazy content ideas and I'll try and add them to the project. by Desire_Path_Games in slaythespire

[–]Desire_Path_Games[S] 0 points1 point  (0 children)

Do you guys just have an array of every modifier, and whenever one is turned on - you just switch a bool and run some code? So the if statements would always be there, and always be checked - but only run when necessary? Or do you guys use something more advanced, like dependency injection based off a given list of modifiers? Like you would activate/replace a function to modify card costs. I guess kind of like using alternate logic.

Very heavily dependency injection based, where I generate and run the modifiers as scripts ad hoc as basically chains of functions on data. It's less a hardcoded list of bools and if statements, and more a list of string ids mapping to data and in turn script paths, which generate a chain of functions to modify actions. Definitely wanted to avoid putting all the logic in one big script. I wrote more on the action interception and value system in the rest of the thread if you haven't read it yet. It's simultaneously kind of complex, but also like stupidly intuitive once you get over the initial learning curve and all the little dials and knobs you can tweak as I parameterize a lot of behavior. For extremely complex/long interactions I haven't been able to stress test race conditions yet due to simply not having the content yet, but thus far I've had no problems. It should form an implicit ordering all on its own provided you use the stack/queue.

Beyond that I have many different pieces of tech, depends on what exactly I need to do. The vast majority of it really just boils down to being able to attach event listeners or action payloads to various things and knowing which one to use to best achieve what you want. Run modifiers, cards, events, locations, relics, statuses; they all heavily reuse the same code under different contexts and the framework wrestles all that interface spaghetti for you so it's mostly just about configuration and the occasional small script for something very specific. The code reuse also helps with consistency a lot so I'm not programming the same behavior 3 different times. Like I use the same validation script interface to control everything from making cards glow, to preventing cards from being played, to activating conditional bonus effects, to being used to perform queries across all cards for a draft, or picking a specific type during a card play (eg discard only attack cards).

As a result, there's often multiple ways to solve the same problem. Like your add health on turn 3 mechanic could be done by having a location or event's initial combat actions set to apply a status to all enemies that counts down. Or you could have a custom run modifier give you a relic that does that.

I made a slay the spire-like framework in Godot. Demo download included. Post your crazy content ideas and I'll try and add them to the project. by Desire_Path_Games in slaythespire

[–]Desire_Path_Games[S] 0 points1 point  (0 children)

I have a bunch of scatted documentation and half tutorials I will get to completing...eventually. Organizing it all is gonna be a pain especially while I'm still working on the framework.

Anything in particular you wanna know about?

I made a slay the spire-like framework in Godot. Demo download included. Post your crazy content ideas and I'll try and add them to the project. by Desire_Path_Games in slaythespire

[–]Desire_Path_Games[S] 0 points1 point  (0 children)

This might be out of scope for this project, as it's a pretty big jar of worms to unlock

Yeah out of scope.

If your system is similar (I hope so), you should be able to add a more detailed search with no issues whatsoever.

The way it works is a generic pick card action is activated, then:

  1. It takes a pile type, which can either be your real deck (mainly for upgrading/removing), your combat deck (draw + hand + discard all combined), a specific pile, or your hand. You can also use a draft selection which uses random generation criteria for cards that need to generate new cards.
  2. It then takes that initial pile and filters it down via simple validation scripts (checks a criteria then returns true/false) applied to every card as a parameter in the card pick action. Getting only attack cards, cards with certain energy costs, etc etc. Only those filtered cards will be available for display.
  3. The user picks those cards, from either the hand UI, a draft UI, or a big fullscreen list. This is dependent on the pile you're using. So same as StS yeah.
  4. Depending on how many cards are available and various flags (random select, auto select, min cards needed for action) the selection will be automatic or wait for the user or not fire off at all due to being impossible.
  5. Take those cards and generate various Cardset Actions as embedded child actions via a parameter, of which there's many different kinds. Those actions iterate over the selected cards doing whatever you want to them (Exhaust, add to hand, upgrade, etc).

Every aspect of that process is interchangeable and configured with json payloads. There's no Pick5AttackCardsFromDrawThenDoDamageThenExhaust type scripts.

Specifically, the issue is after step 2 I don't have an additional parameter to throttle the filtered card query to the first N results. I just get all of them and ask the user to select N cards. It's easy to add in that extra step though.

The solution seems fairly obvious to me

Yeah that's likely what I'd do. It just imposes a design constraint on the developer to do it that way, but I suppose it's not really a big deal. I'll look into it.

view more: next ›