Swarm UAV Simulation

Creator: Scotty Black

The basic concept of swarm UAV tactics involves utilizing small, low-cost, expendable UAVs in order to overwhelm and confuse the enemy. Swarms are generally characterized by many agents that each only possess a few simple behaviors from which, through interactions with each other, yields a more complex group behavior. Unlike a missile, rocket, or bomb which, once launched, can only proceed directly to the target with at most a list of preplanned waypoints, a UAV would have the ability to loiter, find, fix, track, target, and engage an enemy asset on its own timeline.

This simulation is based on the concept of UAV swarming on a Surface Action Group (SAG), represented in this simulation as a single frigate. The UAVs are assumed to be semi-autonomous, small, low-cost, expendable systems that would be equipped with limited sensors and a small warhead. Attacking UAVs execute "kamikaze" attacks on the enemy warship. The Defending UAVs execute kinetic attacks against the attacking UAVs, i.e. defenders attempt to run into attackers.

This scenario consists of a friendly carrier (a Russian model is all I could find) with the friendly UAVs loitering overhead awaiting orders. The enemy frigate is located to the North (rotate to the right on scene load) with the enemy UAVs loitering over the frigate. this warship also has a radar-directed, auto-targeting, self-defense gun with a max range of 3,000 ft. The Figure below shows a general overview.

The camera is controlled with the mouse:

• Hold down the left-mouse button and drag to rotate
• Hold down the right-mouse button and drag to pan
• Scroll in/out with mouse wheel to zoom in/out

You will be able to give commands to each of the swarms and change some of the parameters. To change the number of UAVs, user the slider to set the desired number and hit "Reset Simulation". Due to performance issues, only up to 75 UAVs per side are allowed.

Options and command can be given/input via the user interface. Keyboard input is also allowed with the following inputs supported:

Project Features

• Underlying Offensive Logic:
• Attacking UAVs loiter over the carrier until instructed to attack
• Five different attack options are available
• Attackers proceed to Initial Point (IP) and wait for all attackers to arrive to their respective IPs before attacking
• Attackers stay out of the threat range as they proceed to the IP
• Only after all attackers are at their respective IPs does the attack begin
• Attackers execute "kamikaze" attacks
• Underlying Defensive Logic:
• Defending UAVs loiter over the defensive position until attackers are within threat range (3,000 ft)
• Each defender targets the closest attacker unless every attacker is targeted, then it will randomly choose one targeted attacker to target
• Defenders will attempt a kinetic kill on the attackers, i.e. running into them.
• A direct hit has a Pk = 1.0
• If the defender's target dies, it will re-target the next closest attacker
• Underlying Warship's Self-Defense Gun Logic:
• Gun automatically targets the nearest attacker
• Every 10 seconds, the gun re-prioritizes the threats and re-targets if necessary
• One gun fires one gun burst every 0.7 seconds
• Probability of kill for the gun depends on the range
• Max effective range = 3,000 ft
• 2,000 ft to 3,000 ft: Pk = 0.05
• 1,000 ft to 2,000 ft: Pk = 0.15
• 150 ft to 1,000 ft: Pk = 0.25
• Min lock dist = 150 ft
• Min engagement dist = 50 ft
• Tracking rate = 'quick'
• UAVs implement an aircraft-banking algorithm I created to allow the turns to look more realistic
• Still instances where it is not working correctly
• Banking is for visual purposes only
• UAVs navigate via a waypoint generator
• Different generation process depending on phase of flight
• Implements a threat avoidance algorithm I created
• UAV behaviors are based on the different modes they can be in:
• Attack
• Defend
• Enroute
• Deception
• At IP
• Loiter
• Collision Checking
• Raycasting is only used when absolutely necessary to optimize browser performance
• Position checking is used for UAV to UAV situational awareness
• UAVs implement a friendly deconfliction algorithm I created
• First it figures out who is within a min distance
• Then it turns away to avoid a friendly collision
• Models used that I created
• Unicorn UAV (Attacking UAVs)
• Zephyr UAV (Defending UAVs)
• Models imported from free online sources
• Carrier (http://tf3dm.com/3d-model/admiral-kuznetsov-class-carrier-19210.html)
• Frigate (http://tf3dm.com/3d-model/hamina-35750.html)
• Gun (http://tf3dm.com/)
• The ocean and the skybox were imported from the http://threejs.org demos section
• All sounds were imported from free freesound.org
• Ocean (https://www.freesound.org/people/Corsica_S/sounds/174763/)
• Splash (https://www.freesound.org/people/soundscalpel.com/sounds/110393/)
• Explosion (https://www.freesound.org/people/ryansnook/sounds/110113/)
• Warning siren (https://www.freesound.org/people/AntonioBuscaglia/sounds/234506/)
• Collision (https://www.freesound.org/people/qubodup/sounds/157609/)
• DAT-GUI library was used for the interface
• angleBetweenQuats(), lookTowards(), play*Sound(), and particleSystems used from Dr. Chris Darken's code examples from http://www.graphic-sim.com/
• Simulation Development
• The majority of the work in this simulation went into programming the underlying logic of all of the systems used. A lot of effort also went into attempting to reorganize the code so that it is better organized.
• A lot of effort went into the development of the banking method, the different waypoint generation methods, the threat avoidance methods, collision detection methods, collision avoidance methods, the visualization methods of the lines displaying some of the logic, and the different targeting methods. Most of this required hours and hours of drawing lots of vectors, figuring out quaternions, along with other 3D movement research
• A significant amount of time was also put into figuring out how to code lead pursuit. Because of the maneuvering nature of the targets, I deemed it that pure pursuit was a better 80% answer in the end. I was not able, however, to come up with any good algorithms that would take into account both target aspect and distance.
• I also invested a lot of time in determining the best way of organizing all of the objects so that they could be accessible when necessary.
• The simulation was initially written with each UAV using raycasting for collision detections. This, however, resulted in very low frame rates. A lot of effort went into rethinking different ways to increase frame rates. In the end, raycasting is used only when necessary, such as to detect the ship since it is of irregular shape. Raycasting, however, is only turned on when inside of a bounding box that surrounds the ship.
• An interim version of the simulation was adapted to conduct a Design of Experiments. It was modified so that it could take coded values in and convert them to actual values, and then ouput the results in a pop-up window.