Gamemaker Studio 2 is very easy to learn…the language they use is not too difficult for some coding. But, if you want to start doing some 3d eventually after making your strategy game, its probably less time consuming to learn some language that can do 2d and 3d. So, unity or Godot.
I’d start by messing around with both (and other engines), do some game jams on itch, etc. Have fun with them before you try making your real game.
Since you’re not a programmer, you won’t be able to work around engine limitations too easily. GMS can do a whole bunch of stuff though. What do you picture the game looking like?
I have a few possible game designs, but like i said, not-a-programmer, so i have to be realistic.
The simplest would be a standard tile-based 4X style game using commercial or freeware assets. If i could just do that, alone, that would be pretty neat. The “better” level would be something like merging Esri ArcGIS with a 4X game, with multiple hidden “layers” of data (x,y,z sets) interacting every turn. The “best” level would be that data influencing the shape and layout of the map.
I’d also like to make a board game using stacked layers (x,y,z) and as i can’t quite think of how to do that in a board game it would probably be better as a video game.
If i had the ability i wouldn’t mind making an iOS version of the medieval logic game of Obligations (278. Sara Uckelman on Obligations | History of Philosophy without any gaps), sort of like Good Sudoku, but it’s not a high priority even though it’s probably the least work and has the most chance of success.
Neither.
Don’t want to be a buzzkill, but if you can’t make this decision yourself, you shouldn’t throw yourself into trying to do this. Making even a simple 4X game is a massive undertaking; hard enough even for an experienced, game developer - “impossible” (nothing is impossible, obviously, but your odds of success are very, very small) for someone who lacks programming experience and experience with the framework used to build the game.
@Gigglemoo 's advice is sound. Start building some small, simple games (i.e., game jam size). Your idea of doing board games (or board game inspired games) is excellent - something with clear and simple defined rules, and limited numbers of assets (though nowadays, its not all that costly to get assets for common indie game genres) is much more likely to be actually something you can complete. The knowledge you’ll gain from building a few of such small games will prove invaluable (and save you tons of time) if you then later decide to throw yourself into the unholy time sink that building a 4X game is.
Finish something extremely basic first to get used to the tools and processes. I would choose something that doesn’t need AI. :)
We are talking something of the complexity of Pong, Breakout, or Space Invaders. Maybe try come up with a quick turn-based version of one of those…
Part of the reason why I suggested that Udemy Godot course is because it steps through a series of progressively more complex projects, starting with a very simple word game.
@Enidigm regardless of what engine you use, there’s a 99% chance you are going to have to learn to do some programming. It’s not that difficulty, in spite of society making people think it is. It’s just a tool, like a hammer. If you know what you’re trying to do, it’s far easier to learn to program towards that goal than it is if you are just wandering around looking for something to hit with a hammer. From that perspective, a course that provides a simple goal for you removes your desire to over complicate from day 1, which is a good thing. As soon as you feel any level of confidence, keep going with the course but simultaneously start your own project.
Whether it’s Godot or GameMaker or Unity, and regardless of what course you take, do what @Profanicus said and keep it as simple as possible at first.
Yes definitely avoid the danger of going down the rabbit hole of never-ending tutorials, where you copy/paste everything and never actually learn much. :)
They’re good to get you going but you need to have your own project too.
Oh yeah…. Never ever copy/paste. Type the code in yourself. It makes you think about it.
I just started that course that Clay recommended. I like GMS but thought I’d look at Godot. I have all these board game ideas and some of them can be decent IOS games so figured it’s now or never.
Took a lot of programming in college 40 years ago and always told my wife I want to spend 6 months learning a game language and after that time, if I can learn enough to actually make a game, cool…if not, at least I tried. Now, I’m trying.
Nice! Since you have prior experience and Godot basically uses Python, 6 months is more than enough. :)
Keep in mind to export to iOS you do need a computer than runs MacOS.
Gotcha…we have a few macs lying around. My kid, at 15, has 3 computers and uses one of my old computers as a server. Uh, nerd to the max. She’d better turn that into something!
With any of these game engines, other than Xcode/SpriteKit, dealing with Apple’s certificates is the hardest part of making the game. 😜
Let me know if you have any questions, @Petey! I’m happy to try to help answer. There are some other people around who know Godot a lot better than me, too, like @jitspoe.
I had to create a series of video tutorials on GameMaker Studio for my design students. It takes them through the basics of building a simple game in GML. I always get requests to just post the code so they can copy/paste and I tell them exactly what you just said.
@Petey I don’t think you need 6 months to learn a GML, C#, or whatever Godot uses. Just start in on a really simple concept. You’ll pick up a few things. On your next small project, you’ll learn a few more. And so on. You’ll also learn better ways to structure your game (not the code per se, but how everything works together) as you move from small project to small project. You’ll look back on your earlier stuff and laugh at how badly built it is.
That’s great advice and what I’ll follow. It seems both engines have very early interactive tutorials that I can try early on.
I have some experience with very, very basic programming (maybe, literally BASIC programming), but I was just afraid of having to learn “career level” programming just to dabble with games. I half heartedly started to try learning Swift but… it was too abstract and career level investment for me without a concrete end goal. Aiming for Game Jam level games / board game prototyping seems a realistic possibility rather than anything more complicated. I don’t really have any hope for “commercial” level. I’ll try the Godot tutorial you referenced as well as the very beginning Gamemaker Studio interactive tutorials before the free 30 days are over just to get my feet wet.
I’ll check back in after a few months and report what progress I’ve made. Thanks all!
You don’t have to do that. Don’t worry about your code being the most performant or having everything perfect. You’re just trying to have things talk to each other: “Ok, button, when clicked, you send this message to that thing.” or “Ok, mouse, when I click here, tell the character to move.” Programming can be overwhelming at first, which is why starting very simple is good. Even just starting with a single image that moves around when you press the arrow keys is a good idea, or having things happen when you press a key. You just need to do enough of that to get the feel for how the code allows you to build instructions.
It’s really fun to see when something clicks with my first year game design students. They don’t have to be expert programmers, but they are required to build their own shit in engine.
In my tutorials, I go over how to make the player shoot in the direction of the mouse cursor when left-clicking. I purposely do not show them how to have enemies shoot at the player. Inevitably, I’ll get asked how to do that. I cryptically respond, “You already have all the information you need to make that happen.” They think on it for a while and then realize they just need to alter the source and target coordinates, and tie shooting to something like a timer (an alarm in GML) instead of a mouse click. The behavior of the projectile doesn’t need to change at all.
Not all of them make the leap, but when they do, they realize how much they can do with a very limited amount of coding.
Argh, I should start working on my game again.
I think that realisation is a critical skill!
You see far too many people on the internet asking for a full tutorial on how to make an extremely specific type of game. It’s all really just a few building blocks put together in different ways.
Interesting news:
A question!
If I were making a Football Manager-style game in Godot and wanted to store ~600 players with their abilities at various different skills and their career histories, what is the best way to do that in Godot?
At the end of the game I’d need to be able to write to this store to increment Games Played, Minutes Played, Goals Scored, etc and then also modify the abilities based on new experience, fatigue and injuries.
Thanks in advance here is a picture of a Pangolin.
Godot can easily read/write from dictionaries/JSON. Here are a few functions that I used when I made Jumpin Jouster. It is not a fully implemented system, but should be enough to get you started.
For saving
func save_game():
var save_dict = {
"version": GAME_VERSION,
"high_score": high_score,
"high_score_kids": high_score_kids,
"high_score_easy": high_score_easy,
"high_score_normal": high_score_normal,
"high_score_hard": high_score_hard,
"horse_dress": horse_dress,
"prefer_fullscreen": prefer_fullscreen,
"speed_s":key_mappings["speed_s"],
"speed_d":key_mappings["speed_d"],
"speed_f":key_mappings["speed_f"],
"lance_angle_up":key_mappings["lance_angle_up"],
"lance_angle_down":key_mappings["lance_angle_down"],
"jump":key_mappings["jump"]
}
var save_game = File.new()
save_game.open("user://JumpinJousterSave.json", File.WRITE)
save_game.store_line(to_json(save_dict))
save_game.close()
For loading:
func load_saved_game():
var save_game = File.new()
save_game.open("user://JumpinJousterSave.json", File.READ)
var save_line = parse_json(save_game.get_line())
var version = int(save_line["version"])
if version < GAME_VERSION:
# Need to reinitialize the save game file
print_debug("UPDATE GAME VERSION FOR SAVED DATA!")
high_score = int(save_line["high_score"])
high_score_kids = int(save_line["high_score_kids"])
high_score_easy = int(save_line["high_score_easy"])
high_score_normal = int(save_line["high_score_normal"])
high_score_hard = int(save_line["high_score_hard"])
prefer_fullscreen = bool(save_line["prefer_fullscreen"])
key_mappings["speed_s"] = int(save_line["speed_s"])
key_mappings["speed_d"] = int(save_line["speed_d"])
key_mappings["speed_f"] = int(save_line["speed_f"])
key_mappings["lance_angle_up"] = int(save_line["lance_angle_up"])
key_mappings["lance_angle_down"] = int(save_line["lance_angle_down"])
key_mappings["jump"] = int(save_line["jump"])
var saved_horse_dress = int(save_line["horse_dress"])
horse_dress = saved_horse_dress
save_game.close()
File verification and/or creating a save file if one doesn’t exist:
func verify_saved_game(reinit=false):
# Check whether there is a saved game fiel
var save_game = File.new()
if save_game.file_exists("user://JumpinJousterSave.json"):
return
else:
create_saved_game_file(save_game)
# Create the saved game file if it does not exist
func create_saved_game_file(save_game):
high_score = 0
high_score_kids = 0
high_score_easy = 0
high_score_normal = 0
high_score_hard = 0
horse_dress = 4
var save_dict = {
"version": GAME_VERSION,
"high_score": high_score,
"high_score_kids": high_score_kids,
"high_score_easy": high_score_easy,
"high_score_normal": high_score_normal,
"high_score_hard": high_score_hard,
"horse_dress": horse_dress,
"prefer_fullscreen": prefer_fullscreen,
"speed_s": KEY_S,
"speed_d": KEY_D,
"speed_f": KEY_F,
"lance_angle_up": KEY_O,
"lance_angle_down": KEY_L,
"jump": KEY_SPACE
}
save_game.open("user://JumpinJousterSave.json", File.WRITE)
save_game.store_line(to_json(save_dict))
save_game.close()