The oldest methods use a function called step_towards to loop the projectiles. Effectively, each turf the bullet uses Byond's built in movement code to make it move in the best direction towards the target. This method is clunky and cumbersome and has a large number of drawbacks, foremost is that the pathing more heavily weighs towards the east and west rather than north and south- meaning that facing east and west and shooting follows different paths than shooting north or south. Step_towards handles diagonals extremely badly and does weird things around adjacent targets.
This leads to some odd stuff around corners, for example:
There should be no line of sight from the red to blue due to the walls in the way (black squares) but because of the east-west bias the bullet can magically bend around the corner. There's a lot more examples of this which I'm sure many players have seen themselves. Bullets just travel oddly, like to bounce around tiles. It's not natural looking at all.
Us and TG are the only codebases as far as I know that still use the step_towards method, and it's probably pretty likely TG will switch at some point.
Baystation, Paradise, and Goon use 3 other different methods of bullet pathing, all more or less similar to each other. Baystation uses a type of variable called a datum to store a bullet's flight path info, such as its angle of attack and the turfs it has to go through. Paradise skips that and has their bullets generate the flight path on the fly, but their simpler version lacks a lot of features of Bay's. Goon's is almost identical to Baystation's. Most of these codebases use what's known as "pixel projectiles" -- not only does it try to aim the bullet exactly where a person clicked, it subtly manipulates the bullet sprite's icon along the way so it looks like it's travelling a smooth line. Pretty clever, and it looks nice.
All these pathing methods have their merits and downsides, but I think what most people are interested in is CM's.
As you might have guessed, CM has always used the original step_towards pathing method and most of the projectile code itself is extremely old. In a big coming update, I've completely rewritten everything there is about CM's projectile system, foremost of which is the outdated pathing. Instead of using an existing codebases I've written my own pathing methods from scratch.
Effectively, what it does is use Bresenham's line drawing algorithm to generate a line of turfs going from point A to point B. It then sends the bullet along that flightpath, and halts it if it scans the next turf and hits something. You've seen Bresenham's before -- it's the same turf generator that I added to the flamethrower.
Bresenham's algorithm is fast and super efficient at generating these turfs, and it does it very neatly and logically. It handles corners pretty well and if the bullets using my method run out of "flight path" turfs, it spontaneously takes the angle of its current path and generates a new one on the fly at the tail turf of the last one- thus being scalable to fire at any range. Rather than prefer a specific direction like step_towards, Bresenham's method prefers to just travel as straight as possible, but will do angled shots as you'd expect.
What does this mean for you, the player? It means a lot of your old strategies for avoiding and giving fire will no longer work or may work in unexpected ways, like hiding/shooting from around doorways. It will however feel a lot smoother and more intuitive to shoot at things. Generally, with Bresenham's algorithm, if you can see something, then logically you should be able to shoot it.
Hopefully this all makes sense. TLDR: Bullet pathing will be changing soon. So, expect that.
