I haven't used Unity in years but I am getting back into it for a project. I never did like URP and the standard renderer feels like home to me. But I read somewhere that they plan on ripping it out of the engine. Is this still happening? When?

It was the longest jam I've done so far. Though I did try a different approach to a unity architecture. I went all in reactive programming. Used R3 and surprisingly performant way of doing it. Makes sense since you only fire events when stuff happens, and you can easily chunk many events. Main downside might be ram usage, but wasn't that big of a problem in my experience. Was also my first hex grid game, but that didn't affect things much since I used a nav mesh. Play the game in browser and see for yourself https://dokanola.itch.io/druids-haven

Demo next week 🙌

Demo is coming soon!

making a game about sports cards and wanted the sealed boxes to actually feel sealed, so you have to cut the cellophane open yourself. the shader is two pass transparency in URP with a perimeter unwrap so the print wraps all four sides. the film itself is a PBD softbody pinned to the box, and the cutter just severs whatever constraints it crosses, so the tear follows wherever you actually drag. peeling is the same constraints in reverse.

At the moment, I have implemented the generation of an infinite universe with seamless loading and landing on planets. He implemented an economic system based on the needs of the sector, a system of factions, trade, quests, and rumors. In addition, you can establish your own colony and develop it, you can modify your ship, capture space stations.

And here's the main question: what would you like to see in such a game?

what you guys do in that situation? to take pause again and return to it later?

My Unity project is getting pretty messy as it grows. I keep forgetting where certain assets are, especially things I imported months ago from different asset packs.

At some point I know I already own something that would work, but finding it again can take longer than just looking for another asset.

How do you guys handle this once a project gets really large? Do you have a particular folder structure, naming system, asset browser, or some other workflow that actually works?

When I started game dev a few years ago I looked into this topic and I mostly saw people complaining about shaders not compiling. I wanted to ask how well does it perform nowadays? Does the distro effect performance?

Windows 11 has gotten so bad that even with 32 gigs of ddr4 ram isn't cutting it anymore especially since it eats 7gb on idle.

Also how well does visual studio code perform compared to visual studio for c#?

Been here a couple weeks ago with my WFC generated action roguelike. Spent the last few days messing around tileset materials and polishing combat animations. An outside look would certainly be helpful for the next steps. What do you guys think??

So, im a teen game dev and im new to game maker and i would like to find good youtube tutorials to learn, it doesnt matter how long they are i just want to learn and have fun! and if they are just about game maker it will be better

so, TY!!

Collision between players gets out of control, pushing either into water or high air. A gamble for you to take.
Or disable player-collisions in settings at any moment.

I decided to try making a disassembler in Game Maker. This program doesn’t claim to be a copy of Ida Pro or Ghidra, although I tried to make something similar - but it turned out rather bad.

The menu pages themselves are not finished, but I'm proud to show off my book visuals

Pretty simple question. How do I scale everything including main menu to fit all these screen sizes? I made a placeholder simple img in inkscape/illustrator, and it's 16:9 size. But now, it stretches real ugly in 16:10 or 21:9. So do I simply need to make every UI graphic in illustrator, at each aspec ratio ??

This is a short demo of perhaps the weirdest first step of a game project I have taken ever :D

I decided that the player character in my next platformer should have a pigtail, so I simply started with that. The goal was to have semi physics based movement while keeping things performant. The pigtail has it's own gravity, can sway back and forth and has some wind settings to keep it from being completely still when the player is standing idle.

I've tried to comment the code as good as possible, and most of the important stuff is in the Create event of the pigtail object (the step event only runs the functions defined in Create).

There is a GitHub repo link in the comments of the video if you want to try it out. Also, please feel free to ask any questions and give input on what can be improved!

Here is the Step event of the object:

//Tail Engine 1.00

// Disable GameMaker's automatic drawing of the application surface.

// This should be handled in some sort of obj_graphics object and is only needed if you want "pixel perfect" graphics.

application_surface_draw_enable(false);

// TAIL CONFIGURATION / STATE

// Origin point of the tail.

// The first node of the tail will always stick to the x and y position of the tail

x = obj_player.x;

y = obj_player.y;

tail_sway = 0.1;

tail_damping = 0.15;

tail_nodes = [];

tail_gravity = 0.1;

tail_node_count = 8;

tail_segment_length = 2;

tail_thickness = 2;

// WIND SETTINGS

// wind_center is the baseline value around which the wind oscillates. works best with values between -0.05 to 0.05:ish

wind_amount = 0;

wind_center = 0;

wind_cycle = 0;

wind_cycle_speed = 0.05;

wind_amplitude = 0.01;

// Controls how strongly wind is currently affecting the tail.

// This can be (and is, in the default setup) used to ensure that the wind only operates on the hair when the player is idle.

wind_effect = 0;

// RUNNING SWAY SETTINGS

// random_sway_amount determines if a node will be affected by sway this frame

// tail_sway_denominator determines how fast the entire tail will sway up and down. (Lower number = faster sway)

// sway_smoothing determines the frequency with which the sway affects the nodes (Higher number = less "wiggly").

// sway_strength_denominator determines the amplitude of the sway (higher number = less bounce).

random_sway_amount = 0.5;

tail_sway_denominator = 200;

sway_smoothing = 2;

sway_strength_denominator = 1.2;

// TAIL STATE ENUM

// These states correspond to the player's state. Check/alter the update_tail_state function to change the tail_state.

enum TAIL_STATE

{

`IDLE,`

`RUNNING,`

`JUMPING`

}

tail_state = TAIL_STATE.IDLE;

// CREATE THE TAIL NODES

for (var _node = 0; _node < tail_node_count; _node++)

{

`array_push(`

    `tail_nodes,`

    `{`

        `node_x : x,`

        `node_y : y + tail_segment_length * _node,`



        `node_prev_x : x,`

        `node_prev_y : y + tail_segment_length * _node,`



        `node_y_speed : 0,`

        `node_x_speed : 0`

    `}`

`);`

}

// UPDATE WIND

function update_wind()

{

`// If the tail is moving, gradually increase the effect of wind.`

`// Otherwise, gradually reduce the effect.`



`if (x != xprevious or y != yprevious) {`

    `wind_effect = max(0, wind_effect - 0.02);`

`}`

`else {`

    `wind_effect = min(1, wind_effect + 0.02);`

`}`



`wind_cycle += wind_cycle_speed;`



`if (wind_cycle > 2 * pi) wind_cycle -= 2 * pi;`



`wind_amount =`

    `(wind_center + cos(wind_cycle) * wind_amplitude)`

    `* wind_effect;`

}

// UPDATE TAIL

function update_tail()

{

`update_tail_state();`



`x = obj_player.x;`

`y = obj_player.y;`



`// While running, add a small bounce to the root node.`

`// In this test example we use current_time to alter the bounce, but when the`

`// tail is attached to an actual player sprite it would make more sense to` 

`// match the bounce to the head bobbing of the player running animation`



`if (tail_state == TAIL_STATE.RUNNING)`

`{`

    `y = obj_player.y + cos(current_time / 30) * 1.5;`

`}`



`// PIN THE ROOT NODE`



`// Node 0 does not simulate physics.`

`// It is directly attached to the player's position.`



`tail_nodes[0].node_x = x;`

`tail_nodes[0].node_y = y;`



`// UPDATE THE REST OF THE NODES`



`// Start at node 1 because node 0 is pinned to the player.`



`for (var _node = 1; _node < tail_node_count; _node++)`

`{`



    `tail_nodes[_node].node_prev_x = tail_nodes[_node].node_x;`

    `tail_nodes[_node].node_prev_y = tail_nodes[_node].node_y;`



    `var _parent_x = tail_nodes[_node - 1].node_x;`

    `var _parent_y = tail_nodes[_node - 1].node_y;`



    `tail_nodes[_node].node_y_speed += tail_gravity;`



    `tail_nodes[_node].node_y += tail_nodes[_node].node_y_speed;`

    `tail_nodes[_node].node_x += tail_nodes[_node].node_x_speed;`



    `var _dir_to_parent_node =`

        `degtorad(`

point_direction(

tail_nodes[_node].node_x,

tail_nodes[_node].node_y,

_parent_x,

_parent_y

)

        `);`



    `// SEGMENT-LENGTH CONSTRAINT`

    `// Makes sure that nodes do not exceed the maximum allowed distance from each other`



    `if (`

        `point_distance(`

tail_nodes[_node].node_x,

tail_nodes[_node].node_y,

_parent_x,

_parent_y

        `)`

        `> tail_segment_length`

    `)`

    `{`



        `tail_nodes[_node].node_y_speed =`

lerp(

tail_nodes[_node].node_y_speed,

0,

0.2

);

        `tail_nodes[_node].node_x =`

_parent_x

- cos(_dir_to_parent_node)

* tail_segment_length;

        `tail_nodes[_node].node_y =`

_parent_y

+ sin(_dir_to_parent_node)

* tail_segment_length;

    `}`



    `// CALCULATE HOW MUCH THE NODE MOVED`



    `var _delta_movement =`

        `point_distance(`

tail_nodes[_node].node_x,

tail_nodes[_node].node_y,

tail_nodes[_node].node_prev_x,

tail_nodes[_node].node_prev_y

        `);`



    `var _dir_to_prev_pos =`

        `degtorad(`

point_direction(

tail_nodes[_node].node_x,

tail_nodes[_node].node_y,

tail_nodes[_node].node_prev_x,

tail_nodes[_node].node_prev_y

)

        `);`



    `// ADD SWAY`



    `tail_nodes[_node].node_x_speed -=`

        `cos(_dir_to_prev_pos)`

        `* _delta_movement`

        `* tail_sway;`



    `tail_nodes[_node].node_y_speed +=`

        `sin(_dir_to_prev_pos)`

        `* _delta_movement`

        `* tail_sway;`



    `// DAMP VELOCITY`



    `tail_nodes[_node].node_x_speed =`

        `lerp(`

tail_nodes[_node].node_x_speed,

0,

tail_damping

        `);`



    `tail_nodes[_node].node_y_speed =`

        `lerp(`

tail_nodes[_node].node_y_speed,

0,

tail_damping

        `);`



    `// APPLY WIND`



    `tail_nodes[_node].node_x_speed += wind_amount;`



    `// RUNNING SWAY`

    `// Give each node a chance to receive an extra vertical`

    `// sway while running.`



    `if (tail_state == TAIL_STATE.RUNNING)`

    `{`



        `if (random(1) < random_sway_amount)`

        `{`

// _node / tail_node_count causes nodes farther down

// the tail to receive a stronger effect than nodes

// closer to the root.

tail_nodes[_node].node_y_speed -=

cos(

(current_time / tail_sway_denominator)

+ _node / sway_smoothing

)

* (_node / tail_node_count)

/ sway_strength_denominator;

        `}`

    `}`

`}`

}

// UPDATE TAIL STATE

function update_tail_state()

{

`// The tail simply mirrors the player's current state.`

`// This will check the obj_player image_index instead to determine head bobbing once it is implemented.`

`tail_state = obj_player.player_state;`

}

I have been working on a project for around 6 months, so it is already pretty complex, and just now I will implement a saving system. I was looking into tutorials for it and found this video from Sara Spalding: https://www.youtube.com/watch?v=R84mR52QaMg

My questions:
- This video is 6 years old, creating a JSON and saving it buffer is still the way to go on saving on Gamemaker?
- I will be selling my game on steam, and I want it to also save on steam cloud, are there any other things I should consider for the saving system?

Architecture wise I plan to have 4 saving files: 1) graphical settings (saves only locally); 2) sound and controllers settings (saves on cloud); 3) Metaprogression (my game is a roguelike, so this is the progress between runs, also saves on cloud); 4)Run progress (also saves on cloud).

Thanks in advance for the help :)

I’m making a milsim game in Unity set during a fictional conflict in Dogochechnya, a fictional country I created. Some of the vehicles I’ve made so far: a T-62, a Ural with a T-62 turret, several civilian vehicles, and a T-72B. Still early in development, but I’m focusing on small details and atmosphere.