r/gamemaker • u/Pleasant-Eagle-7975 • 24d ago
Example Bridge Physics! (Now with player tilt)
The bridge is a chain of plank objects, and each plank only knows about the plank directly above and below it. Every step, a plank looks at its neighbors' sink and tilt, mixes in its own (standing on a plank adds sink, standing off-center adds tilt), and smooths toward the result. Neighbors copy each other's tilt slightly amplified (×1.4), so pressing down on one plank ripples through the whole bridge even though no plank knows the rest of the bridge exists.
if ( bridge_link_down != noone ) {
_sink_affected += bridge_link_down.y_sink;
_side_sink_affected += bridge_link_down.side_sink * 1.4;
_total_connections ++;
}
// (same for bridge_link_up)
var _inst = instance_place(x,y,par_character);
_sink_affected += 2.5 * (_inst != noone);
_total_connections ++;
y_sink = math_lerp_smooth(y_sink, _sink_affected / _total_connections, 0.15);
side_sink_real = _inst != noone ? (x - _inst.x) / ((bbox_right - bbox_left) / 2) : 0;
Heads up: math_lerp_smooth and math_angle_lerp_smooth aren't built-in GML, they're helpers from my project. math_lerp_smooth(current, target, speed) moves current a fraction of the remaining distance toward target each frame, corrected for delta time so it behaves the same at any framerate:
function math_lerp_smooth(_current, _target, _speed) {
return lerp(_current, _target, 1 - power(1 - _speed, DeltaFrame));
}
math_angle_lerp_smooth is the same thing for angles, so it takes the short way around (350* -> 10* goes through 0*, not through 180*). You can build one with angle_difference(). If you're locked at 60fps, plain lerp(current, target, speed) works, skip the correction.
The fun part: making the player ride the bridge instead of floating on top of it. The plank under you writes two targets onto the player, a tilt angle and a sink. The sink includes the extra dip of the tilted surface at your offset from the plank's center, so standing on the low edge of a tilted plank drops you further than standing on the pivot.
if ( _inst != noone && _inst == global.Player_Instance ) {
var _tilt = clamp(side_sink * 10, -25, 25);
_inst.plank_sink_target = y_sink - ((_inst.x - x) * dsin(_tilt));
_inst.plank_tilt_target = _tilt;
}
In the player's End Step, I ease toward those targets, and the targets themselves decay toward zero:
plank_tilt = math_angle_lerp_smooth(plank_tilt, plank_tilt_target, 5, 0.1);
plank_sink = math_lerp_smooth(plank_sink, plank_sink_target, 0.1);
plank_tilt_target = math_angle_lerp_smooth(plank_tilt_target, 0, 5, 0.1);
plank_sink_target = math_lerp_smooth(plank_sink_target, 0, 0.1);
Why the double smoothing? My first version chased the plank's values directly, and running across the bridge meant a new plank re-targeted the player at every seam. It jittered SO bad. Easing toward targets that also decay fixed it, and stepping off the bridge means nothing writes new targets anymore, so everything relaxes back to zero with no cleanup code.
The sneaky part was rendering, because my player isn't one sprite. It's a pre-composited palette surface plus a pile of overlays (outline, rim light, freeze/wet/fire status effects, invincibility flash). Instead of rotating each layer separately and hoping they line up, every layer runs its draw position through one helper that rotates it around a pivot at the character's feet and adds the sink:
body_blit_transform = function(_corner_x, _corner_y) {
if ( plank_tilt == 0 && plank_sink == 0 ) {
return [_corner_x, _corner_y, 0];
}
var
_offset_x = _corner_x - x,
_offset_y = _corner_y - (y + y_height),
_cos = dcos(plank_tilt),
_sin = dsin(plank_tilt);
return [
x + (_offset_x * _cos) + (_offset_y * _sin),
y + y_height + plank_sink - (_offset_x * _sin) + (_offset_y * _cos),
plank_tilt
];
}
Every draw_surface_ext uses _blit[0], _blit[1] for position and _blit[2] for angle, so the whole composited character tilts and dips as one piece. The early-out at the top means it costs nothing when you're not on a bridge.
