Flight Simulator

After growing increasingly frustrated with the game "War Thunder" for its predatory pricing model and uninspired gameplay, I decided to try my hand at making my own flight simulator game. I'm still far from finished, but I consider what I have so far to be worthy of sharing regardless.

My initial goal for the game was to make a generalized flight model that behaves realistically while being simple enough to quickly tune to many different airframes. I ended up implementing parts of a technique I found in a video by Jump Trajectory. Basically, each wing surface calculates lift and drag forces using these equations:

$L = C_{L} \frac{p v^{2}}{2} S$ $D = C_{D} \frac{p v^{2}}{2} S$

Where:

$L$ = lift

$D$ = drag,

$p$ = air density

$v$ = air velocity (relative to wing)

$C_{L}$ = coefficient of lift

$C_{L}$ = coefficient of drag

$S$ = wing surface area

images/MediaObj_Placeholder.png — Lift coefficient curve. X-axis is angle of attack.

The coefficients of lift and drag are what distinguishes the characteristics of wing surfaces from each other. Angle of attack (the angle between the wing direction and airflow direction) is the main parameter that goes into calculating the coefficients. Generally, as angle of attack increases, lift and drag will also increase until the wing begins to stall and rapidly lose lift.

In the video, Jump Trajectory also describes a method of dynamically calculating the coefficients of lift and drag for a wing surface, but the formulae used are only valid for rectangular wings in the subsonic regime. Instead, I created the lift/drag coefficient curves manually and stored them each as a Unity AnimationCurve in a ScriptableObject. I based the shape of the coefficient curves on whatever publicly available data I could find on the aircraft, but in the future, I'd like to try finding a solution that is less reliant on test flight/CFD simulation data.

The wing area is calculated from the position and chord (length) of the base and tip of the wing. The forces are applied to the wing's aerodynamic center, and the effective angle of attack is optionally modified depending on the amount of flap deflection. This behavior is not entirely realistic, but it works well enough for the purposes of the game. When each wing surface is put together on the aircraft, the result is that it flies semi-realistically.

I also wanted the game to be multiplayer, so I used the Photon Fusion 2.0 networking library to synchronize the game state between a host and multiple clients. The Fusion SDK has some convenient features, such as a networked transform component and a lag compensation system. However, the provided network transform component was not a good solution for synchronizing projectiles across the network. When the plane shoots, hundreds of bullets can be instantiated each second, and if the server has to update position data of thousands of projectiles per tick, it quickly eats up all the network bandwidth. To fix this issue, I created a custom data structure that holds the initial position, velocity, and time of the projectile. This is the only data sent over the network; the position of the projectile each tick is extrapolated from pre-calculated tables of the distance over time for each initial velocity.