|
|
Post by beatle on Oct 20, 2016 13:42:22 GMT
Is it just me or are flares much too effective in this game? I completely agree that here is a need to simulate soft countermeasures, decoys and jamming in some abstract way - giving some probability to confuse every missile so it doesn't do what is intended, but in my experience the current system - flares - are close 100% effective. That is way too much! The poor missiles are already dumb enough and should get some help not extra nerfing. Currently they basically just home on to the brightest IR source in the universe. Meaning that it is not only impossible to purposefully command missiles to engage targets of our choosing, but also, when attacking a single target, they are as dumb as very early Korea war era heat seeking missiles, that had rear aspect only target engagement - basically single IR pixel. IRL today we have imaging mm wave radar / multi spectral imaging CCD etc that can discern different parts of target and distinguish between the real thing and decoys much, much better. It is real, proven IRL tech - some AA missiles can be set to target the pilot or other extra vulnerable spots on planes, we should be able to do that in the future too. There is also a discrepancy in situational awareness. As a part of the "no stealth in space" assumption, there is (rightly so, imho) the abstraction of total sensor fusion, innumerable distributed tiny remote sensor platforms etc that allows ships to know the precise location of enemy from the other side of the solar system, target specific external modules from hundreds of km away and basically have no fog of war. And I think that this is a very necessary abstraction and the right way to do it. But, at the same time, missiles do not share this level of situational awareness, not even close. I agree, that missiles are smaller and cheaper and can't duplicate the sensor capability and relayed data collection capability of capital ships to use this directly, but why then capital ships can't relay this info to them or directly control nearby missiles? If the engagement is thousands of km away, transmission is easily disrupted and light lag becomes a problem, but in close ranges this can be solved by targeted laser coms or trailing fiber optics wires and other means that are used now IRL for this purpose. The 'close enough range' could be assumed to be tactical battles - if the launcher ship and missile is in one real time battle session together, than it could be assumed that launcher ship can intelligently control the missiles as precisely as it can control it's own gun turrets. A specific example, where this situation is extra painful, was when I was trying out very close range point defense missiles as a hard kill anti-missile defense. In one scenario, I was launching my CIWS missiles in hopes that they would engage the swarm of incoming flak missiles just a couple of klicks away, but instead they where more interested in a flare launched by the parent of said incoming flak missiles more than 150 (!!) km away. So they just zipped right past the incoming threat. Because of this I am forced to ignore flares completely in my designs, as using flares really feels like cheating compared to trying to find good balance of armor, dodging and active defenses. But even then, the lack of ability to set missile targets is quite limiting. There are many levels of possible mitigation for this problem. Some that I can think of : - Simply nerfing the effectiveness of flares
- Allow to select the desired target ship and module for missiles just like any other weapon - at least if missile is close to the parent ship (this wold be comparatively simple change, but would suddenly allow for many realistic and interesting scenarios that are currently unfeasible to varying degrees, like point defense missiles)
- Require flares to be close to the intended target from the missiles point of view to be able to distract it. Close both in the way of angle (as missile can be thought as having a narrow angle of detector's view with resulting high decoy rejection) and distance (as missile could triangulate to distinguish between target 2 or 200 km away)
- Allow for scripting API for remote control / drone objects (huge job, but with so much potential! I would buy a DLC for that in a heartbeat!)
Certainly, the concerns about performance are very valid, but even limited system where only a limited small amount of missiles can be 'smart' at any one time, possibly using 'flocks with leaders' systems suggested by other forum members, could be very effective. Or having the 'smart' remote control be a very expensive component. And some improvements would not have any real performance penalties at all - like just allowing close missiles to target specific user selected ships and modules like regular weapons do. I would be glad to help, if I can. Test for bugs, work as free part time slave programmer for the Dev, buy expansions, make extension mods if API is provided! I think it very likely that there are quite a few people in this community with both the interest and the ability to contribute to this, if given the chance with powerful mod support. The example of Kerbal Space Program is very relevant and encouraging. Sorry about the rant! I am not trying to put down this game or the Developer, on the contrary! I am quite obsessed with this game and enjoy it a lot and am very thankful to the Developer for making this wonderful product! I just would like to see it grow even more! |
|
|
|
Post by redparadize on Oct 20, 2016 14:52:23 GMT
Good post! I agree completely.
I have few things to add to your wish list. After work...
|
|
|
|
Post by ross128 on Oct 20, 2016 15:09:18 GMT
One thing that would help missiles while being theoretically light on processing power would be a target-allocation algorithm. Basically, instead of everything focusing the hottest target and only dividing evenly when they're all the same temperature, the swarm would assess how many targets are in front of it and how many missiles it has to hit them with. It would then weight the targets by heat signature (assuming that hotter stuff is bigger and more expensive, therefore deserving of more missiles), allocate missiles to each target by weight, round off any fractions, and re-allocate the leftovers to the top weight.
This algorithm would only have to run when the number of targets changes, or it could run on a periodic interval on the assumption that targets aren't going to change much and a recently-appeared target is probably not important (which of course means a flare would only work if it's launched early enough to get picked up by a targeting pass).
By simply allocating targets, the swarm would render flares only partially effective. A hot flare may draw a disproportionate number of missiles, but it won't be able to vaccum up all of them. It would also mean a sufficiently large swarm could split up and annihilate an entire fleet in one volley, which would make them even more terrifying, but it would be kind of realistic.
Of course, that targeting algorithm wouldn't play well with combat-launched missiles or gyrojets because in those situations the number of missiles is constantly changing. Only running it periodically would help because it could grab chunks of missiles and put them in groups, though realistically the missiles should be getting their targeting data from the ship that launched them if it's in the same battlespace. Which means combat-launched missiles and gyrojets should ignore heat entirely and home in on their parent ship's target.
|
|
|
|
Post by captinjoehenry on Oct 20, 2016 15:25:38 GMT
One thing that would help missiles while being theoretically light on processing power would be a target-allocation algorithm. Basically, instead of everything focusing the hottest target and only dividing evenly when they're all the same temperature, the swarm would assess how many targets are in front of it and how many missiles it has to hit them with. It would then weight the targets by heat signature (assuming that hotter stuff is bigger and more expensive, therefore deserving of more missiles), allocate missiles to each target by weight, round off any fractions, and re-allocate the leftovers to the top weight. This algorithm would only have to run when the number of targets changes, or it could run on a periodic interval on the assumption that targets aren't going to change much and a recently-appeared target is probably not important (which of course means a flare would only work if it's launched early enough to get picked up by a targeting pass). By simply allocating targets, the swarm would render flares only partially effective. A hot flare may draw a disproportionate number of missiles, but it won't be able to vaccum up all of them. It would also mean a sufficiently large swarm could split up and annihilate an entire fleet in one volley, which would make them even more terrifying, but it would be kind of realistic. Of course, that targeting algorithm wouldn't play well with combat-launched missiles or gyrojets because in those situations the number of missiles is constantly changing. Only running it periodically would help because it could grab chunks of missiles and put them in groups, though realistically the missiles should be getting their targeting data from the ship that launched them if it's in the same battlespace. Which means combat-launched missiles and gyrojets should ignore heat entirely and home in on their parent ship's target. The only issue I see with that is the fact that the missiles would need to network with each other in order to figure out which ones are targeting which target. I don't think it is a huge issue but it is definitely not a trivial issue to be dealt with. |
|
|
|
Post by goduranus on Oct 20, 2016 16:59:48 GMT
While AI missiles can't be helped, you can manually fly your own missiles with the move order, and try to eyeball an intercept. Works well enough with nukes.
|
|
|
|
Post by nivik on Oct 20, 2016 18:57:58 GMT
The only issue I see with that is the fact that the missiles would need to network with each other in order to figure out which ones are targeting which target. I don't think it is a huge issue but it is definitely not a trivial issue to be dealt with. This is a matching between missiles and targets, which makes it a type of bipartite graph matching problem. The Hungarian method can be used to give an optimal solution, but it's computationally expensive. It'd enable you to set "prices" on each pairing, which would let you do clever things like using delta-V costs, missile warhead size, and target heat signatures to automatically assign missiles of different capabilities to different targets based on what they can hit, how much overkill it'd be, and how valuable the target is. That said, I don't think it'd be worth it for large missile swarms, the loading time/computational cost would be pure insanity. I'd probably recommend a simpler auction-based heuristic which can run "on-line" while the missiles are in-flight to refine their final terminal target choices. The missiles wouldn't make their final targeting decisions until they were part of the way to the target, and could take the changing dV requirements to intercept a different target into account when making re-targeting decisions...which would prevent missiles from going after a big honking flare or a super-hot drone if they're too far into a dV hole against their current target. It would increase the computational burden, though. Probably pretty significantly, even for an auction: most task allocation problems aren't in a problem space where the decisions are being made on-line and the tasks take less than a minute. Latency is a huge consideration in this particular problem space, which makes it pretty interesting. I'll follow up if I think of any other solutions which are more clever than "split the missiles evenly" but run quickly and refine their answer over time instead of figuring it out all at once. |
|
|
|
Post by pishtaco on Oct 20, 2016 19:22:27 GMT
The only issue I see with that is the fact that the missiles would need to network with each other in order to figure out which ones are targeting which target. I don't think it is a huge issue but it is definitely not a trivial issue to be dealt with. Each missile can choose a target randomly, weighted by target size. That is, if you see one target size 10, and two size 5, you choose the big one with probability 1/2 and each of the small ones with probability 1/4. This needs no communication and will distribute them well enough, if there are plenty of missiles. |
|
|
|
Post by ross128 on Oct 20, 2016 19:31:54 GMT
Well, what I had in mind was a relatively naive targeting algorithm. It's based on a few assumptions, first that a naive targeting algorithm should produce better results than no targeting algorithm. Even if a good chunk of the missiles are wasted, killing two or three targets will be less wasteful than reducing a single target to sub-atomic particles. The second is that all the missiles should more or less have enough dV to reach all the targets (or none of them), because the targets and the missiles both start out in fairly tight clusters. As long as you don't re-target during the terminal phase at least. Third, is that collision between missiles should be very unlikely even if their flight paths do cross.
So, based on those assumptions we can get away with targeting the missiles more or less arbitrarily with little concern for optimization. Therefore, the target set can be represented as an array, with each element having a value of NT/S where N is the total number of missiles in the wave, T is the thermal signature of the target, and S is the sum of all hostile thermal signatures in view. Each element would then be truncated to an integer, missiles would be allocated sequentially, and left-over missiles would be allocated to the highest value element, with no concern for those missiles' states.
It's crude and likely to waste missiles in dumb ways, but should work as a quick-and-dirty way to divide up the missiles in a way that will be vaguely proportional to the target's value most of the time. Obviously it shouldn't be run too frequently and it shouldn't be run during terminal approach, because re-targeting too frequently would waste dV and re-targeting too late will just cause missiles to self-destruct.
Edit: Random allocation would work too, once you've generated the value map. For a large enough swarm it'd more or less even out most of the time by sheer weight of statistics. One thing that would be helpful is for subsequent iterations to check if the target map has changed since the last iteration, and if it hasn't don't re-allocate any missiles (to avoid wasting dV unnecessarily).
|
|
|
|
Post by nivik on Oct 20, 2016 20:35:20 GMT
Well, what I had in mind was a relatively naive targeting algorithm. It's based on a few assumptions, first that a naive targeting algorithm should produce better results than no targeting algorithm. Even if a good chunk of the missiles are wasted, killing two or three targets will be less wasteful than reducing a single target to sub-atomic particles. The second is that all the missiles should more or less have enough dV to reach all the targets (or none of them), because the targets and the missiles both start out in fairly tight clusters. As long as you don't re-target during the terminal phase at least. Third, is that collision between missiles should be very unlikely even if their flight paths do cross. So, based on those assumptions we can get away with targeting the missiles more or less arbitrarily with little concern for optimization. Therefore, the target set can be represented as an array, with each element having a value of NT/S where N is the total number of missiles in the wave, T is the thermal signature of the target, and S is the sum of all hostile thermal signatures in view. Each element would then be truncated to an integer, missiles would be allocated sequentially, and left-over missiles would be allocated to the highest value element, with no concern for those missiles' states. It's crude and likely to waste missiles in dumb ways, but should work as a quick-and-dirty way to divide up the missiles in a way that will be vaguely proportional to the target's value most of the time. Obviously it shouldn't be run too frequently and it shouldn't be run during terminal approach, because re-targeting too frequently would waste dV and re-targeting too late will just cause missiles to self-destruct. Edit: Random allocation would work too, once you've generated the value map. For a large enough swarm it'd more or less even out most of the time by sheer weight of statistics. One thing that would be helpful is for subsequent iterations to check if the target map has changed since the last iteration, and if it hasn't don't re-allocate any missiles (to avoid wasting dV unnecessarily). Yeah, there's a pretty wide band of heuristic solutions to the weapon assignment problem. I think the Hungarian algorithm is almost certainly overkill, but I wanted to present it as the "logical extreme" to show how sophisticated we could get. I'd like for delta-V to be weighted, but I think that might be easily accomplished by assigning missiles only to targets within their performance envelope, and in order from lowest dV to highest dV. That would naturally allow missiles with less fuel or heavier payloads pick the largest targets they can hit, then the other missiles would fill in the gaps. I think once a missile has been allocated in your solution, the missile should only change targets if the original target has been destroyed, or if another heat signature diverges from it (either a ship snapping in half, or a flare being launched). Missiles would then only require a recalculation in the event that their specific target had a divergence event, and other missiles wouldn't even need to be part of that recalculation/reassignment. |
|
|
|
Post by captinjoehenry on Oct 20, 2016 20:41:56 GMT
Well, what I had in mind was a relatively naive targeting algorithm. It's based on a few assumptions, first that a naive targeting algorithm should produce better results than no targeting algorithm. Even if a good chunk of the missiles are wasted, killing two or three targets will be less wasteful than reducing a single target to sub-atomic particles. The second is that all the missiles should more or less have enough dV to reach all the targets (or none of them), because the targets and the missiles both start out in fairly tight clusters. As long as you don't re-target during the terminal phase at least. Third, is that collision between missiles should be very unlikely even if their flight paths do cross. So, based on those assumptions we can get away with targeting the missiles more or less arbitrarily with little concern for optimization. Therefore, the target set can be represented as an array, with each element having a value of NT/S where N is the total number of missiles in the wave, T is the thermal signature of the target, and S is the sum of all hostile thermal signatures in view. Each element would then be truncated to an integer, missiles would be allocated sequentially, and left-over missiles would be allocated to the highest value element, with no concern for those missiles' states. It's crude and likely to waste missiles in dumb ways, but should work as a quick-and-dirty way to divide up the missiles in a way that will be vaguely proportional to the target's value most of the time. Obviously it shouldn't be run too frequently and it shouldn't be run during terminal approach, because re-targeting too frequently would waste dV and re-targeting too late will just cause missiles to self-destruct. Edit: Random allocation would work too, once you've generated the value map. For a large enough swarm it'd more or less even out most of the time by sheer weight of statistics. One thing that would be helpful is for subsequent iterations to check if the target map has changed since the last iteration, and if it hasn't don't re-allocate any missiles (to avoid wasting dV unnecessarily). Yeah, there's a pretty wide band of heuristic solutions to the weapon assignment problem. I think the Hungarian algorithm is almost certainly overkill, but I wanted to present it as the "logical extreme" to show how sophisticated we could get. I'd like for delta-V to be weighted, but I think that might be easily accomplished by assigning missiles only to targets within their performance envelope, and in order from lowest dV to highest dV. That would naturally allow missiles with less fuel or heavier payloads pick the largest targets they can hit, then the other missiles would fill in the gaps. I think once a missile has been allocated in your solution, the missile should only change targets if the original target has been destroyed, or if another heat signature diverges from it (either a ship snapping in half, or a flare being launched). Missiles would then only require a recalculation in the event that their specific target had a divergence event, and other missiles wouldn't even need to be part of that recalculation/reassignment. This does sound really great and with an abstract system like we are working with it is fairly easy to do. But I can't help but think that implementing this into missiles and having them need to network and figure things out from processors located separately in each missiles would make it rather more difficult to implement. So the guidance is fairly straightforward but getting the separate missiles to network and figure out who should do what is a non minor issue for a real life implementation and as this is a real life sim it needs thinking on. I mean I could be wrong as I don't really know the details about this kind of stuff but it is my best guess  |
|
|
|
Post by ross128 on Oct 20, 2016 20:59:21 GMT
Well, worst-case, the missiles are already networked with the ship (for the remote guidance stage, and to relay telemetry ie hit confirmation). So they could pass their targeting information to the ship, the ship's computer crunches the numbers, then gives the missiles their orders. It would just cost a bit of light-speed delay.
With random allocation they can just pick their target and they don't need to know what the other missiles picked, so no networking necessary. It'd be a bit more wasteful than coordinated allocation, but for a large enough swarm that won't be a problem. The weighting algorithm is simple arithmetic, so the only thing that would really strain the missile's on-board processor would be processing the IR field that it sees to determine what's a potential target and what isn't.
|
|
|
|
Post by nivik on Oct 20, 2016 21:25:49 GMT
This does sound really great and with an abstract system like we are working with it is fairly easy to do. But I can't help but think that implementing this into missiles and having them need to network and figure things out from processors located separately in each missiles would make it rather more difficult to implement. So the guidance is fairly straightforward but getting the separate missiles to network and figure out who should do what is a non minor issue for a real life implementation and as this is a real life sim it needs thinking on. I mean I could be wrong as I don't really know the details about this kind of stuff but it is my best guess Well, my master's thesis was related to cooperative coverage of an area by a multi-robot system, so I'm actually sort of qualified to talk about this. :3 Let's assume the following: - A robot is a device which senses its environment, plans based on that data, and takes an action based on that plan.
- A missile also does these things, so a missile is a robot.
- Multiple robots working together to achieve the same goal are a multi-robot system.
- An algorithm which runs on multiple robots communicating with one another is a distributed algorithm.
- Allocating missiles to targets is the same as allocating robots to tasks, so it's a task allocation problem.
Essentially, this paper describes a distributed version of the Hungarian algorithm which runs in O(n 2) time per-robot, or O(n 3) overall, with O(n 3) messages communicated between the robots. In practice, I'd probably recommend an auction-based system instead, for performance reasons. THE AUCTION ALGORITHM: A DISTRIBUTED RELAXATION METHOD FOR THE ASSIGNMENT PROBLEM is a paper from 1987 which describes a distributed algorithm for task allocation via auction. This has an overall time complexity of O(n*m*log(n*c)), where n is the number of missiles, m is the number of targets, and c is the maximum (integer) "value" of a target, and appears to show a more-or-less linear speedup when distributed over multiple threads/processors. There are other papers which present faster algorithms, but in general auction-based heuristics are well-suited for this sort of problem. Another nice attribute about auctions is that they can be performed online, or while the missiles are in flight. That means that the missiles can start out just seeking towards toward the hottest target, but while in flight they can argue among themselves and figure out who gets what target and adjust course once they get it figured out. This means that the game doesn't have to stop and process everything all at once, then continue. Instead, a relatively small amount of the auction code can run each physics tick, spreading things out so it doesn't cause the game to choke and stutter, but instead just takes a little more time every game tick. Auctions also don't have to be run synchronously. You can use a message-based system, which means if you launch a bunch of missiles and it's slowing down your computer, the auction code can be run less often. That means targeting decisions will be less optimal, and will occur later in the missiles' flight, but it also means that you can scale the algorithm according to how much CPU you have available. Auctions are the way to do this if you want something that isn't naive. The work can be multithreaded, spread out, and scaled back, which makes auctions extremely flexible and able to be tuned to balance algorithmic effectiveness against computer performance. That's my semi-professional opinion. Given that these algorithms are used in real life, with real robots, for real task allocation problems, by real AI researchers, it also meets the realism requirement!  |
|
|
|
Post by captinjoehenry on Oct 20, 2016 21:48:08 GMT
This does sound really great and with an abstract system like we are working with it is fairly easy to do. But I can't help but think that implementing this into missiles and having them need to network and figure things out from processors located separately in each missiles would make it rather more difficult to implement. So the guidance is fairly straightforward but getting the separate missiles to network and figure out who should do what is a non minor issue for a real life implementation and as this is a real life sim it needs thinking on. I mean I could be wrong as I don't really know the details about this kind of stuff but it is my best guess Well, my master's thesis was related to cooperative coverage of an area by a multi-robot system, so I'm actually sort of qualified to talk about this. :3 Let's assume the following: - A robot is a device which senses its environment, plans based on that data, and takes an action based on that plan.
- A missile also does these things, so a missile is a robot.
- Multiple robots working together to achieve the same goal are a multi-robot system.
- An algorithm which runs on multiple robots communicating with one another is a distributed algorithm.
- Allocating missiles to targets is the same as allocating robots to tasks, so it's a task allocation problem.
Essentially, this paper describes a distributed version of the Hungarian algorithm which runs in O(n 2) time per-robot, or O(n 3) overall, with O(n 3) messages communicated between the robots. In practice, I'd probably recommend an auction-based system instead, for performance reasons. THE AUCTION ALGORITHM: A DISTRIBUTED RELAXATION METHOD FOR THE ASSIGNMENT PROBLEM is a paper from 1987 which describes a distributed algorithm for task allocation via auction. This has an overall time complexity of O(n*m*log(n*c)), where n is the number of missiles, m is the number of targets, and c is the maximum (integer) "value" of a target, and appears to show a more-or-less linear speedup when distributed over multiple threads/processors. There are other papers which present faster algorithms, but in general auction-based heuristics are well-suited for this sort of problem. Another nice attribute about auctions is that they can be performed online, or while the missiles are in flight. That means that the missiles can start out just seeking towards toward the hottest target, but while in flight they can argue among themselves and figure out who gets what target and adjust course once they get it figured out. This means that the game doesn't have to stop and process everything all at once, then continue. Instead, a relatively small amount of the auction code can run each physics tick, spreading things out so it doesn't cause the game to choke and stutter, but instead just takes a little more time every game tick. Auctions also don't have to be run synchronously. You can use a message-based system, which means if you launch a bunch of missiles and it's slowing down your computer, the auction code can be run less often. That means targeting decisions will be less optimal, and will occur later in the missiles' flight, but it also means that you can scale the algorithm according to how much CPU you have available. Auctions are the way to do this if you want something that isn't naive. The work can be multithreaded, spread out, and scaled back, which makes auctions extremely flexible and able to be tuned to balance algorithmic effectiveness against computer performance. That's my semi-professional opinion. Given that these algorithms are used in real life, with real robots, for real task allocation problems, by real AI researchers, it also meets the realism requirement! That is awesome! Ok so as I said I don't really know about it that much so thanks for educating me. It definitely is a very interesting thing and it would be great if we could get this in game! |
|
|
|
Post by trevlite on Oct 20, 2016 22:24:29 GMT
Adding sensors to the missiles that lets them see more than one pixel and maybe a communication system that lets them network with each other could be an idea?
|
|
|
|
Post by redparadize on Oct 20, 2016 22:40:09 GMT
If flare are to be nerfed, then alternative defense need to be allowed.
As:
-More accurate CIWS
-Ability to target multiple target with multiple CIWS
-Electronic warfare? (sensor/communication jamming)
-Less expensive laser
-Combat formation
Most of these point are obvious. But I want to expand on the latest one. Basically it would be like modern days carrier battle group. I would like to have the ability to specify formation prior to the combat. A deployment phase if you prefer. A alternate solution would be to specify group in ship design. Simple flag like (core) (front) (rear) (periphery) would do. That would allow player to place CIWS several km ahead of valuable ship and drasticly improve their chance of destroying them.
|
|
