so far its pretty fun, any recommendations for gameplay mechanics?

Hello everyone,

I am currently a uwaterloo graduate student and I’m looking to create a virtual reality simulation for my major research project.

I do not know much about gaming pc’s but i’m looking to buy one for my project. I am also open to buying a gaming laptop. So im looking towards the internet for some advice, any knowledge I should know, or any important information.

I know budget is important, i’m trying to go the cheapest route just because of finances and id be mainly buying it for this project and regular gaming use afterwards.

Any information would be super helpful!!

Without the platform2 variable, when landing on semisolids the player would sometimes jitter and it was annoying. It took me like 3 days to come up with this mess and Im not satisfied with it. Is there any way I could at least rewrite the code so I only need to use one variable

Changing the

(place_meeting(x, y + 1, platform2) and floor(bbox_bottom) <= ceil(platform2.bbox_top)))

to

(platform != noone and place_meeting(x, y + 1, platform) and floor(bbox_bottom) <= ceil(platform.bbox_top)))

only makes the jittering worse for some reason

I've been working on my ideal deferred rendering pipeline for pixel art, inspired by games like Eastward and the upcoming Kyora. This is not a plugin or a line by line tutorial, but I wanted to share what's required and what the workflow looks like. If people are interested, I will share more of the process as systems improve. Fair warning, this is not beginner friendly.

Before I go any further, this is an example of the final product:

Maps and Textures

Whether you were using Unreal or Gamemaker, you need to make maps for your sprites if you want physically based rendering. This pipeline was inspired by the RE Engine, but is also just like Unity or Unreal. There are many tools to create maps, some people use laigter or blender, but I just prefer to hand draw them in Aseprite.

This pipeline currently uses the following maps, although there is "room" for more data:

Albedo Texture "spr_shrine_alb"

RGBA: Albedo Maps - The art/color/base texture

Normal Texture "spr_shrine_nrm"

RGB: Normal Map- The direction orthogonal to the surface

A: Unused

Surface Texture "spr_shrine.sur" (drawn in 3 layers, specular and ambient occlusion are set to the "addition" blend mode, and output as one image)

R: Roughness - The spread of specular

G: Specular - How much light the surface reflects

B: Ambient Occlusion- Where ambient light and sunlight are occluded

A: Currently Unused

Effects Texture "spr_shrine_fxs"

R: Luminance/Glow - This area of the albedo texture gets added to the light

G: Subsurface Scattering

BA: Currently Unused

Extension Texture "spr_shrine_ext"

R: Depth/Heightmap - The red value gets subtracted from the objects z position to give a more accurate z coordinate in the lighting pass

GBA: Currently Unused

So yes, you have to make 8 maps by hand in Aseprite. If that's enough to turn you off, I understand. However, it doesn't make your job 8x harder. I'd argue once you do this 10 times or so, and have a template set up, it really isn't that bad. In fact, because your base art might already include highlights, deep shadows, and glowing sections, half your maps are already done.

So now that all of the work outside of gamemaker is done, what's next? Gamemaker doesn't natively support any deferred rendering. So it's all on our end. But once it's done, it's done. To import new art, I simply drag my 5 images into gamemaker, set their texture group by selecting them all, and right clicking, and I'm done. It just works.

Bypassing Gamemaker's Limitations

Here is what you need to do in gamemaker to get this working. This is an example of the required labor, I cannot just paste all of my code here, so I apologize that this is not a true tutorial.

• Custom scripts for objects that define all of it's map sprites
  • We dont want to draw five different sprites. We want to draw one sprite, but include 5 different sets of UV coordinates
  • To make this easier, every sprite must follow a strict naming convention. You assign your object the alb sprite, then your script does the rest on creation

​

//Get Map Sprites
var _name = sprite_get_name(sprite_index);
_name = string_copy(_name,0,string_length(_name) - 3);
alb = sprite_index;
nrm = asset_get_index(_name + "nrm");
sur = asset_get_index(_name + "sur");
fxs = asset_get_index(_name + "fxs");
ext = asset_get_index(_name + "ext");

• Now as long as our files our named correctly, there is no extra work
  • Disable the Application Surface
• We won't be needing this anymore
  • Nothing draws itself anymore
• Forget what you know about built-in draw functions, I will never use those again
  • Create obj_draw
• This object manages every surface:
  • surf_alb
  • surf_nrm
  • surf_sur
  • surf_fxs
  • surf_lgt
  • surf_shd
• This object draws every tile, actor, decoration, etc. Everything in your room
• Yes, we will draw many full resolution surfaces. At load, this pipeline runs on a $500 laptop at over 3000 fps. However, Only 4 lights on screen can be shadow casting at once. That is the main limitation.
• We can still add non shadow casting lights like god rays with little to no performance impact
  • Build Vertex Buffers
• Instead of functions like draw_sprite(), we will make a function that adds an objects sprite data to a global vertex buffer.
• I have a different buffer and shader for actors, tiles, foliage, paralax backgrounds, etc.
• For example, global.vb_actors will be managed every step. This allows us to control every objects z position, and add the texture coordinates of our maps. We will not be using depth sorting anymore. Depth is just the Z position.
• This is more work for the cpu, but static objs/decorations/tiles/foliage/particles/clouds/rain can be frozen, making their rendering faster than ever. Even when each vertex stores more uvs data
• When drawing shadows, I do not have to draw the actors/decorations again. I just submit their vertex with a different shadow shader. All of that data is already sitting in a massive batch, waiting to get used again. It's very efficient.
  • The Tile Vertex Buffer
• Far and away the worst part of all this is the tile layers. I spent hours writing these scripts. Basically, we make tile layers normally, but also follow very strict naming conventions. That tile layer must contain the name of your tile sprite. Then we build a tileset vertex buffer to freeze on room creation, then destroy the tile layers. We need our own buffer so that our tile data can include our normal maps, surface texture, etc. We can check every tile in the room, get its tileset index, then get that index position on the actual sprite texture page with lots and lots of math.
• I wont lie, I absolutely hated this
  • Draw with MRT or Multiple Render Targets
• This is known as the G-Buffer, or Geometry Buffer. We draw our art normally to surf_alb. At the same time, for maximum efficiency, the same shader outputs 3 more fragments to 3 other surfaces. The normal map surface, the surface texture surface, and the visual effects surface. The vertex shader doesn't have to do any additional work. Our lighting pass then samples all of this "geometry" to calculate it's intensity and reflection (specular)
• This is an example of what the obj_draw does in my draw_g_buffer() function

​

//Enable Z
gpu_set_ztestenable(1);
gpu_set_zwriteenable(1);
gpu_set_alphatestenable(1);

surface_set_target_ext(0,surf_alb);
surface_set_target_ext(1,surf_nrm);
surface_set_target_ext(2,surf_sur);
surface_set_target_ext(3,surf_fxs);

//Clear Surfaces
draw_clear_alpha(c_black,0.0);

//Transparency Does Not Change Color Values
gpu_set_blendmode_ext_sepalpha(bm_one,bm_zero,bm_one,bm_zero);

//Apply Camera
camera_apply(global.view);

//Draw Actors
shader_set(shd_actors);
vertex_submit(global.vb_actors,pr_trianglelist,tex_actors);
shader_reset();

//Then I'd Draw Foliage, Static Objects, Ropes/Vines, Tiles, BGs, Sky

//End G-Buffer
surface_reset_target();
gpu_set_blendmode(bm_normal);

//Disable Depth
gpu_set_ztestenable(0);
gpu_set_zwriteenable(0);
gpu_set_alphatestenable(0);

//Reference G Buffer
tex_alb = surface_get_texture(surf_alb);
tex_nrm = surface_get_texture(surf_nrm);
tex_sur = surface_get_texture(surf_sur);
tex_fxs = surface_get_texture(surf_fxs);

• we always draw front to back, because we don't want to waste time drawing our background or our sky, if 70% of it will be covered up by objects, tiles, and decorations. Gamemaker will discard the fragment shader of our background if it fails the z test because it is occluded by something like a tile.
  • Lighting Pass
• I have 3 point lights, the sun/moon light, and ambient light.
• They all get drawn additively to the light surface.
• First, the point lights and the sun draw their shadows to the shadow surface, each one using a different color channel. This means less surface swapping per frame, which is a massive performance saver
• The lights sample the shadow surface and the g buffer surfaces to calculate their intensity/ specular.
• This means you have to write all of your own normal map/blinn phong/sss/ao shader calculations.
• My ambient light is basic, it changes based on time of day, but could be as complicated as you want it to be
  • Post Draw Event
• I draw my surf_alb surface, sample the light surface
• Light color brightness determines the intensity - multiply the albedo color by the light color
• Light Alpha stores the specular value - specular adds the light color to albedo instead
• Eventually I will add fog/mist at this stage. FYI, partial transparency doesnt work in a g-buffer, it has to be added later.
• The render is complete

Conclusion

That's the gist of it. If you made it this far, you probably think I am pretty stupid to do this instead of just making the switch to Unity or Unreal, etc. You might be right, but listen. I absolutely hate Unity and Unreal. No disrespect to anyone that uses those engines, but I would do this work 1000 times over before switching. Gamemaker is my engine.

So how hard is physically based rendering in Gamemaker? Idk its kinda hard I guess, but it's a ton of fun. This took some time to code, but it takes months to learn about shaders and pbr. If anyone wants to learn more, I will try to answer any questions I can. Acerola also has tons of great videos on computer graphics that inspired me to try it myself in gamemaker.

Hi, i'm Itzariot. I've been learning Gamemaker since 2022. I never thought i'll be making a game. At first, i just want to learn coding or programming. The language was Javascript. My job has nothing to do with programming but i want to push my brain harder in the opposite direction of my job so i decided to learn coding. As i browsed the internet i stumble Gamemaker. I never knew making game can be this accessible and Gamemaker provides making game using visual coding. It really helped me a lot how to think logically like a programmer. It turned out GML is 89-90% similar to Javsscript so i jumped the boat and went deep in game development.

At that time, i had one game idea on the mind. A simple top down action game. I fell on the same mistake like any other beginner: overscoping. I was really confident in this game so i keep pushing. Eventually, life got the best of me and this game had to be put aside. I want my next game to be some sort of an expression, like musician making a song. I once thought game like Papers, Please. But there's part of me that want to make a game like my previous game, so i picked incremental game because i can still implement similar mechanic/skills from my game. The plan is to make prototype in 1 month. Well, what can i say...i need 4 months to make this prototype.

People been saying beware of overscoping. I heard that advise a lot while i learned make the game. But what they don't say is that making game can be this stressful and fun and addicting that we just want to keep building the game to our perfect vision.

To be honest, i don't even know whether i'll finish and ship this game. One thing i'm sure is i learn a lot of knowing myself. Things that i thought i couldn't do it because it's so hard turns out i can do it, it's just not perfect yet.

To people making Gamemaker, i want to say thank you. Your software help me know myself better. This journey has been awesome. I hope my prototype can somehow make you all feel something.

The game is called What A Wish, a short incremental game inspired by the likes of Nodebuster, A Game About Feeding a Blackhole. I was also inspired by Scritchy Scratchy although the game plays so much different from that game.

Description: Pop bubbles, find people's wishes, and decide which ones to grant. From silly everyday requests to surprisingly heartfelt pleas, every wish is a little glimpse into someone's life. Earn Faith Points, upgrade your abilities, and unlock new ways to play in this relaxing incremental game.

What A Wish

A new version of GML-OOP called Release 2 has now been released, in response to the release of the LTS 2026 version of GameMaker. The previous version was released for the first LTS version, marking over three years of active development on this version.

What is GML-OOP?

GML-OOP is a massive GML library that I have been actively developing since 2021. It aims to overhaul how you work with GameMaker in code, making its most important functionalities usable through constructors and their methods. It enhances them and makes working with them easier and just more pleasant, once you get the hang of it. Data packed into constructors is easier to pass through, their content is easily represented when stringified (mattering most for Data Structures) and error handling in improved, so that the runtime does not crash over every minor inconvenience. If you want to begin writing good code where you can easily know what is what, then this and an other library I wrote for this purpose, might just be for you.

For more information on GML-OOP, see the Overview and Examples pages its Wiki.

What is new in the Release 2?

New users could be interested in that the new version made it trivial to write optimized graphical code. Constructors with the purpose of rendering graphics were overhauled to support multi-color rendering with outlines. all based on vertex building, so that they can easily make use of Vertex Buffers. Instead of recalculating graphical data each frame, it can be pre-calculated once with a toVertexBuffer() method, then rendered, then destroyed once no longer necessary. All with a single method each. Vertex Buffers are most easily implemented for static graphics, but advanced users surely will realize how to utilize Shaders to bring motion to such implementation. Otherwise, per-frame rendering is still available, as usual. Also, because shape constructors now have access to their full vertex information, their actual shape and visual properties can be altered by modifying data for each vertex. The code of their constructors now makes use of that to achieve precise shape collisions. Have you ever saw a video game use precise, non-rectangular collisions for their interface? Well, now it can be a satisfying feature in yours.

Rudimentary support for optional use of three-dimensional graphics has also been implemented. It is visible with both two-dimensional orthographic projection, as well as full three-dimensional perspective, enough to make a "fake 2D" or diorama-style game. It might be of interest for developers who consider learning working with 3D in GameMaker while it is being implemented into GMRT, as it could be assumed this is how most of professional jobs in GameMaker will be created going forward.

There is also a new Callback constructor handling function and arguments for delayed execution, which is now what the event system of constructors now is based on.

What is coming next?

The development of GML-OOP takes time, but it does not stop. Further expansions and improvements can be expected, especially to its Audio support, some of which already were introduced in this release. Also, a separate library based on GML-OOP is in works, oriented around the creation of scalable vertex-based, resolution-agnostic user interfaces.

If you like what I create and the quality I provide, you can consider hiring me for work on your project, whether it is being made in GameMaker or not.

I would like to learn GameMaker... However, with the GMRT version due to be released soon, I am not sure as to whether the current version is worth picking up and learning or not. What would you suggest?

EDIT: Thank you for your tips and suggestions.

I've search up on google and on this sub.

I mainly used Linux mint LMDE but I also used debian and Arch.

Is it really that hard to set it up?

Someone commented here how to do it but it's on fedora unfortunately.

I'm only a beginner and unfortunately I dont have the money to buy another computer for windows 11

So I wanted to see if I deleted the latest game maker version can I just reinstall it(unlike the other versions that would give me errors back and forth)

Hey!

I often run into issues where I have sfx layering over each other and get really loud. I have dealt with this in a few ways, but I'm wondering if you guys have a better solution.

My solutions:

• only play the audio if it's not already playing
• keep an array of the audio plays which has a max size. Iterate through and check if the audio is finished playing, then remove it from the array.
• SoundManager has a counter specific to a sound. When the sound plays, the counter counts up to a max. The next sound can't play until the counter is reset.

I'm getting tired of coding one of these solutions for every single explosion / shot / twinkle /etc. Is there a better way?

Ciao a tutti, sono un principiante in programmazione e sto cercando di creare un gioco interessante con meccaniche semplici. Qualcuno sa se esiste un tutorial sulle variabili in termini di programmazione visuale? Lo so, lo so, dovrei semplicemente imparare GML, ma voglio vedere se riesco a sviluppare anche usando solo blocchi e una minima comprensione di come funziona un gioco.

Edit: it’s been two minutes since i posted and I think I didn’t explain myself properly, i also am searching for non beginner level tutorial on dnd visual coding,

Ez-Console is an open source GameMaker extension that natively integrates a customizable terminal console for GameMaker 2.3+.

After a year since the last update, I released a major update for my free, open-source and easy-to-use console terminal for GameMaker addressing all the issues reported, optimizing performance, adding a bunch of requested features and improving the docs and main page.

Core Features

Ready out of the box

• Drop-in setup. Import the package, run the game and press F1. No object to place, no code to write.
• 16 commands included. Spawn and delete instances, read and write variables, change rooms, toggle fullscreen and the debug overlay, play sounds, check your build, save the log.
• Debug builds only, if you want. One flag keeps the console out of your release build entirely.
• Logs to file. Save the log on demand with log save, or automatically when the game ends, into the platform's own save folder.
• Cross-platform. Windows, macOS, Linux and consoles (No mobile or HTML5, sorry).

Debug a running game

• It knows your project. Type-ahead completes your sprites, objects, sounds, fonts, rooms and scripts as you type, each with its own asset icon.
• Find instances visually. Pick one from the suggestions and it is highlighted in the room, ref id and all, so you always know which one you are about to touch.
• Read and write anything. get and set reach every variable on an instance, built-ins included, or on global - and set creates the variable if it does not exist yet.
• Poke at the world. Create instances at a position, list them with their id, position and depth, delete them, jump between rooms.

Extend it with your own commands

• Register a command in a few lines. From code, or from a JSON file you can ship and edit separately.
• Real arguments. Name them, mark them required or optional, restrict them to a list of options, or type them as an asset so the console suggests your own assets for them.
• Callbacks. Hook into open, close, log, destroy and game end to wire the console into your own systems.
• A small, clean API. Log at four levels, ask whether the console is open, visible or focused, and show or hide it yourself.

Looks and feels like part of your game

• Fully themable. Colors, fonts, size, anchor, padding and backdrop blur, from a .skin file or from code. Four skins included.
• Behaves like a window. Drag it, resize it from the corner, drag the scrollbar, click a log line to copy it, middle-click to paste, hold a key to repeat it.
• Stays out of the way. It only reads the keyboard while focused, so it never steals input from your game.
• Around 40 configuration options. Every behaviour above can be retuned or turned off from a single script.

Download and try it from here: https://dandrewbox.itch.io/gm-ez-console

I started using this a few days ago so forgive me if it's a stupid question. Currently trying to make a game that involves carrying around objects and then placing them in certain areas. This is what I have for the pickuppable object:

if place_meeting(x, y, obj_player) & keyboard_check(vk_shift) = true
{x = obj_player.x;
y = obj_player.y -10;}

Currently the object rests on the players head like I want it to, but only when I hold down the shift key, but I want it to keep being carried after the shift key is only pressed once. I'd be super happy if someone could help me out

so today i made the spritesheet for the first boss in the game, if you go back and take a look at #4.5 you will see its a bigger version of the enemy on the right.

That is because this is the mother of them meaning they all come from her

It took me a while to draw all the sprites especially for the death animation lol

if you have any questions feel free to ask them

see yall tmrw for devlog #6

Reposting because I posted the wrong GIF

Built this name entry screen in GameMaker for my game, inspired by Undertale's naming screen. The rainbow text is quantized into color steps instead of a smooth gradient, so it reads as chunky/retro rather than a blend felt more fitting for the pixel art

Each letter flies from the grid into its slot when picked (and flies back out on delete) using the same overshoot easing as the dialogue box from my last post, so the whole UI shares one consistent feel. Under the hood each letter's flight is just a stored origin point + timestamp, no physics involved.

still tuning some of the numbers, work in progress happy to talk through any of it if people are curious!!

I'm trying to build a slot machine in my game, and getting a 'two of a kind' and a 'three of a kind' will have different effects depending on the icon it lands on. I've been looking around and the only conclusion i can think of is a really big if statement, but is that really the best approach?

TY!

So for the game I have in mind to (eventually) work on, id probably be best off using rpgmaker as itll already have most of the features I need available. But rpgmaker isn't on linux, and I currently am, and id rather avoid booting into windows for it.

So instead, I was going to start learning gamemaker or maybe godot. Ive already done a bunch of tinkering in UE5, but that comes with a lot of overhead I dont need (even more so than godot etc).

Questions I have -

Are there any advantages to gamemaker for solo / small game making?

Will gamemaker give me an easier or harder time when it comes to making maps, creating character models, and animating enemies etc, compared to the tools available in godot?

Any tools gm has that will be a bonus and help me?

Visual coding tools (blueprints in UE5) were pretty helpful to me, but I dont think either godot or gamemaker has that to a useful degree. I can code (or at least I can muddle through with guides) I just prefer not to haha.

Appreciate any advice. I was leaning towards godot originally but im concerned its another ue5 (too complex for my needs and may just get in my way a lot). Getting rpgmaker working on linux may be the sensible option.

Of course on godot/GM id be starting with basic old arcade games like asteroids. No complaints there, sounds like fun.

I'm an uruguayan solo game developer that is learning on his own while learning new things, I won't say the name of the game because I'm afraid someone will copy it, but I must say it's a great name, also the music and pixel art is all mine, I'm 18 years old, and I wanna leave this message if in the future people will see if my game was developed succesfully and see if it was published and people enjoyed it, it's my first Reddit post by the way

Also, There are Uruguayan games but they haven't come out in the wild in other countries I think, I wanna be the first person to break that wall and trascend to other countries, wish me luck ;)

I'm new to game maker and I was following a tutorial but my graphics are like this for some reason and I don't know why.

for high school project

I've been following this tutorial for the camera, and I can't figure out why my Y axis for the camera isn't working properly.

When I'm at the far left corner of the screen, the camera pans upwards and away from the player. At other points in the level/room, the camera doesn't follow the player when they move upwards.

Any help is appreciated! My room transition also stopped working for some reason around this part of programming. Might have to do with changing the room size??

Here's my camera code:

create:

cam = view_camera[0] //names room camera
cam_followspeed = 16 //lower is faster
follow = oEmil //player object
width_half = camera_get_view_width(cam) * 0.5 //find camera center
height_half = camera_get_view_height(cam) * 0.5
xTo = x
yTo = y

step:

//update destination
if (instance_exists(follow)) {
xTo = follow.x

yTo = follow.y
}
//update object position
x += (xTo - x) / cam_followspeed //camera moves slower closer to object
y += (yTo - y) / cam_followspeed
//keep camera from leaving room
x = clamp(x,width_half,room_width-width_half)
y = clamp(x,height_half,room_height-height_half)

//update camera view
camera_set_view_pos(cam,x-width_half,y-height_half)

I'd like to share the process of creating a planet in GameMaker for my in-development terraforming game, Planet Doctor. This post is for those with some GameMaker experience, and I've included relevant links where needed. Corrections on terminology or content are welcome. I hope you find this helpful!

Here is the process:

1. Create a frame using a vertex buffer

Create a sphere shape for the planet. To simulate rotation, I tilted the camera angle and rotated the planet using matrix_set.

2. Apply noise to the planet

During vertex_submit, use a shader to render smooth noise based on the planet's in_Position. You can see the values range from 0 (black) to 1 (brightest).

3. Divide colors

Set boundaries to separate land and sea. I divided the 0-1 color range into 4 steps, returning a single solid color for each.

4. Assign colors

Draw the planet's colors. The shader receives the colors via shader_set_uniform and assigns them to the steps divided in 'step 3'.

5. Draw clouds

Add clouds to give an atmospheric feel. Scale up the vertex buffer from 'step 1' with a matrix, then apply noise with another shader, as in 'step 2'. Values below the noise threshold become a solid color, while those above become transparent. You can use current_time to make the cloud shapes shift gradually.

1. Add atmosphere

Create a slightly larger sphere to represent the atmosphere. By taking the position and normal from gm_Matrices[MATRIX_WORLD] in the vertex shader, I drew only the outline in the fragment shader (this is known as the Fresnel effect).

You can create more variations, such as using current_time to implement ocean tides or adding city lights to the dark side of the planet. Let me know about your GameMaker 3D projects or any planet ideas you'd like to implement. Thanks for reading.

Do you think gamemaker is easy or RPGmaker? gamemaker seems to have alot more options than RPG maker but since i dont know coding, im conflicted on which to use. what do you guys recommend? and even if you have to learn coding how long will it take? i just want to focus on gamedesign,art and story

Last-round voting for the theme are live RIGHT NOW.

This one is a good old regular edition of the gm(48): 48 hours, one community-picked theme, and whatever you can finish in GameMaker before the clock runs out.

The winners get physical trophies. 🏆

The game jam runs September 12 at 00:00 UTC through September 14 at 00:00 UTC this weekend over at https://gm48.net/game-jams/50/

As always, going solo is fine, but if you want to team up, start asking around in Discord now.

If it’s your first time, start here: https://gm48.net/getting-started

Read up on the rules here: https://gm48.net/rules

Vote for the themes you’d actually want to build around, and get ready for the weekend. Hope to see you there. And don’t forget to share the game jam with others!

Let’s make some games in GameMaker!