There would need to be a code to link the targets and they should be identified by randomish numbers so u cant just put
target.set(0) //grab a target without scanning it :)
If you would like to refer to this comment somewhere else in this project, copy and paste the following link:
I do not like the idea. I think it would unbalance the game way to much.
One fighter could sweep in and grab the enemy cruiser's position, and the whole fleet could constantly pass the target lock around. In effect they would never have to scan the cruiser again to track it. Part of the game is being able to retreat, and this would eliminate that possibility.
If you would like to refer to this comment somewhere else in this project, copy and paste the following link:
What if there are two types of locks? One active type and one shared. For any ship to get a shared lock of an enemy at least one other ship must have an active lock.
In that case the shared lock would be either void or left as last known position if the last ship with an active lock is destroyed.
If you would like to refer to this comment somewhere else in this project, copy and paste the following link:
Well, I wouldn't exactly say that it is already possible...
What I am suggesting is the ability to pass your target to another ship, so that if the locator gets killed, the fleet can continue to hunt the enemy. This can not be accomplished in any way with the current version.
But I think Calash brings a point, it would make evasive strategies almost useless, and your fleet doesn't stand a chance unless it is superior in numbers (in which case you don't need this feature).
So I'm sorry to say that I'm voting down my own suggestion :)
But another suggestion: What about the ability to keep a target, like; Target.Keep, or, Target.Preserve (whatever). This would be really cool. One good example of this is my Coop Gunships fleet, if you have seen it's tactic in action, you can imagine how much this would help the locator-gunship.
The scanner should still move, so we could have:
<Ship>.On_Scan {
If (Math.Less(Target.Type,3)) {
< Ship will revert back to previous target >
Target.Keep
} Else {
< Routine >
}
}
I like this idea. Another useful option would be to know how many ships are in your scanfield at any time. Then your fleet would know if it has found a lost fighter or a attacking fleet. Knowing what types of ships that are would be nice to.
<ship>.On_scan
{
If (math.greater(scancount.cruiser(),0))
{
<Code to attack cruuser>
} else {
<Code to attack smaller fleets>
}
}
Or somthing similar would be nice and would work well with a target.keep command. Making it target.lock may be a bit easier to understand, but that is not that big of a issue.
Jason
If you would like to refer to this comment somewhere else in this project, copy and paste the following link:
We have been discussing this for a time now, and I still don't know where I stand in this issue.
Knowing how many ships you scanned is ofcourse an advantage, but the question is if the fighters and gunships should be capable of this (?). I think not.
If the feature is to be implemented, it should only count for cruisers, and should be accessed like TK says, as an array.
And so comes the other problem, the command. This is how I imagine it:
Target.Scanned(X) - would return number of X type ships in the cruisers scan triangle. Target(X).<xxxxx> would work as the normal Target.<xxx> would.
Then, how should the Target.Lock(Keep) command work with this? Should it lock all the targets? Or should we have Target.Lock(X) - where X is number in array.
Or maybe be able to lock only fighters, gunships or cruisers (filter the other out), like Target.Lock(X) - where x is ship type to preserve.
I have a request.
Did you ever want to pass a target to another ship? I think this should be possible. We could do it as this:
Target.Transfer <Shared Variable>
or
<Shared Variable>.Set Target.Target
Then this could be accessed by other ships using
Target.Set <Shared Variable>
Just a thought...
Vidar Braut Haarr
AmigoSoft Productions
folk@popmail.com
Interesting idea.
You could have
var.set(target.get)
target.set(var.get)
There would need to be a code to link the targets and they should be identified by randomish numbers so u cant just put
target.set(0) //grab a target without scanning it :)
I do not like the idea. I think it would unbalance the game way to much.
One fighter could sweep in and grab the enemy cruiser's position, and the whole fleet could constantly pass the target lock around. In effect they would never have to scan the cruiser again to track it. Part of the game is being able to retreat, and this would eliminate that possibility.
What if there are two types of locks? One active type and one shared. For any ship to get a shared lock of an enemy at least one other ship must have an active lock.
In that case the shared lock would be either void or left as last known position if the last ship with an active lock is destroyed.
t
At present its done by sharing coordinates
cx.set(target.x)
cy.set(target.y)
so the question becomes does it allow interesting new algorithms?
Well, I wouldn't exactly say that it is already possible...
What I am suggesting is the ability to pass your target to another ship, so that if the locator gets killed, the fleet can continue to hunt the enemy. This can not be accomplished in any way with the current version.
But I think Calash brings a point, it would make evasive strategies almost useless, and your fleet doesn't stand a chance unless it is superior in numbers (in which case you don't need this feature).
So I'm sorry to say that I'm voting down my own suggestion :)
But another suggestion: What about the ability to keep a target, like; Target.Keep, or, Target.Preserve (whatever). This would be really cool. One good example of this is my Coop Gunships fleet, if you have seen it's tactic in action, you can imagine how much this would help the locator-gunship.
The scanner should still move, so we could have:
<Ship>.On_Scan {
If (Math.Less(Target.Type,3)) {
< Ship will revert back to previous target >
Target.Keep
} Else {
< Routine >
}
}
And Target.Clear would ofcourse clear it.
Vidar Braut Haarr
AmigoSoft Productions
folk@popmail.com
I like this idea. Another useful option would be to know how many ships are in your scanfield at any time. Then your fleet would know if it has found a lost fighter or a attacking fleet. Knowing what types of ships that are would be nice to.
<ship>.On_scan
{
If (math.greater(scancount.cruiser(),0))
{
<Code to attack cruuser>
} else {
<Code to attack smaller fleets>
}
}
Or somthing similar would be nice and would work well with a target.keep command. Making it target.lock may be a bit easier to understand, but that is not that big of a issue.
Jason
What would a simple syntax for lists be?
eg for a list of scanned objects
Could be accessed just like arrays?
I like target.lock better :)
We have been discussing this for a time now, and I still don't know where I stand in this issue.
Knowing how many ships you scanned is ofcourse an advantage, but the question is if the fighters and gunships should be capable of this (?). I think not.
If the feature is to be implemented, it should only count for cruisers, and should be accessed like TK says, as an array.
And so comes the other problem, the command. This is how I imagine it:
Target.Scanned(X) - would return number of X type ships in the cruisers scan triangle. Target(X).<xxxxx> would work as the normal Target.<xxx> would.
Then, how should the Target.Lock(Keep) command work with this? Should it lock all the targets? Or should we have Target.Lock(X) - where X is number in array.
Or maybe be able to lock only fighters, gunships or cruisers (filter the other out), like Target.Lock(X) - where x is ship type to preserve.
Well, there is something to chew on :)
Vidar Braut Haarr
AmigoSoft Productions
folk@popmail.com