[Droid803]

"Gun convergence" disables autoaim.
That's kinda dumb.
I would expect autoaim to override gun convergence, and have it only occur in absence of a target.

That, and using "gun convergence" for off-axis secondary banks ruins primary bank autoaim which sux.

Any chance of a fix, or is this intended behavior?
Also, would it be possible for secondary banks to obey their normal without requiring "gun convergence"? :/

[Nuke]

way i see it if you can have convergence you have all the mechanical workings for autoaim anyway, so therefore i think autoaim should supersede convergence. just my opinion. of course i never liked the implementation of autoaim. i think it should include a delta value to control lockon speed. mechanical systems are far from instantaneous, and there should be some time lag for the guns to actuate onto the target. say it takes half a second for the gun to rotate 30 degrees, shots should arc over to that over time. but im currently drunk so what do i know.

[chief1983]

Lockon delay is still an anticipated feature, actually.  I'd like ships in FotG to eventually have variable lock on delays based on targeting computer strength, as another way to differentiate the craft.  The delay isn't probably the worst part, I was trying to figure out a way to present it to the user.  Can't really use the secondary lock mechanism because then you'd have two different reticules trying to lock on to the ship.  My other thought was using the scan line system to show a lock in the target cam box somehow, or some sort of indicator by the primary weapon list.

The actual mechanical display you refer too really only works if the guns are actually relying on a mechanical targeting system (in Star Wars it's more about electrical voodoo focusing shots different leaving the barrel, so it can be instantaneous), but even a non-mechanical firepoint adjustment could probably get closer to the target as the computer tracks for a lock.

[Dragon]

Could be 2 vertical lines moving onto the middle of the target (in target view), with something (for example 4 triangles pointing to it) appearing when locked?
IMHO, this would look rather SW-ish.

[Nuke]

Lockon delay is still an anticipated feature, actually.  I'd like ships in FotG to eventually have variable lock on delays based on targeting computer strength, as another way to differentiate the craft.  The delay isn't probably the worst part, I was trying to figure out a way to present it to the user.  Can't really use the secondary lock mechanism because then you'd have two different reticules trying to lock on to the ship.  My other thought was using the scan line system to show a lock in the target cam box somehow, or some sort of indicator by the primary weapon list.

The actual mechanical display you refer too really only works if the guns are actually relying on a mechanical targeting system (in Star Wars it's more about electrical voodoo focusing shots different leaving the barrel, so it can be instantaneous), but even a non-mechanical firepoint adjustment could probably get closer to the target as the computer tracks for a lock.

i dont necessarily want a delay where you cant fire until it locks on, that reduces the probability of pilot error. i like to give the pilot a chance to waste energy or ammo by being impatient. if i were to pick a game to emulate it would be starlancer. if the gun is not locked on you are still allowed to fire, it will just not be on target. essentially it acts like a turret. when not locked on to anything it is kept at or returned to center. this is the gun normal or 0'0'1 if normal is not used. when you lock on to a target or a subsystem, and the target is in the guns field of view, then the gun will rotate from its current position onto the target at the appropriate rate. rate would just be a float, probibluy representing time it takes to go from center to its max angle. then 0 would be instantaneous. perhaps negatives could be used if you want the gun to lockout the fire command if the gun is not on target, so you could get all desired behaviors in that way, while only adding one additional value to the table.

displaying the current position of the gun could just be as simple as drawing a second reticle indicating the current direction of fire. from the huds point of view optimal firing angle is when the reticle and the lead indicator are in alignment. it is technically not a lock because the tracking rate is limited. if the target is moving faster than the guns ability to track then the ship can escape the gun.

[chief1983]

I was never planning on preventing firing, just using a default convergence until auto-aim lock is achieved.  I also want to be a be able to allow disabling auto-aim, and switching to fixed convergence or convergence directly ahead at the target's range.

[Nuke]

i still think auto aim should not be a lock on kinda behavior because that would make it too similar to missile behavior. guns should try their best to follow the target's lead. instead of firing straight for a time, and then snap to target once it has been in the field of view long enough, it should be an animated progression from default position to target position, and shots fired during that progression would draw closer to the target as aim becomes more accurate.

autoaim guns should always try to converge, probibly at max weapon range if no target is selected (different linked banks would coverge at a distance based on maximum range for that weapon), target range if one is, and only tracking when target is within the guns field of view. guns that only converge but dont track would have 2 types. static gun convergence where convergence range is set at mission start based on the weapon's maximum range, but cannot change in game, as if the guns were adjusted in preflight ops. you could also have dynamic convergence, where convergence is adjusted based on target range.

so it would go in order static convergence->dynamic convergence->full autoaim bot, where each one has all the features of the previous mode. idea is guns manually adjusted before launch->1 axis (axis being paralell to the cross of the gun direction and the gun position) actuator converges guns->2 axis gimbal aims guns, each one being a more complex system that can do everything of the previous system and more. when you get a starwarsish voodoo insta snap weapons, meh, just set your lock time to zero. but dont make the system universe centric, make it moddable to any configuration possible with the least amount of data to edit.

[chief1983]

A behavior like you described could also be nice, but there are very clear portrayals of primary weapon locking in the Star Wars movies, so it is something FotG would like to be able to replicate if possible.  And you're right, a configurable system could probably provide all the features we're both looking for, I'm not asking it to be set up any particular way and only that way.

User-controlled ability to disable this is probably a necessity for multiplayer, when you have fast ships, because it's almost certainly going to keep you from being able to compensate for lag.

[Nuke]

yea some people may just want tot urn off the whole thing if its doing something they dont like. so maybe a key to cycle convergence/autoaim modes? of which there would probably be 4, no convergence, max range convergence, target distance convergence, and full aimbot. of course if your ship/weapon does not support one of those modes, it would be omitted from the list.

[Droid803]

I would be very happy if any of this is implemented

[chief1983]

So would I, as it's on the FotG request list still

[Droid803]

BABUMP

No awesome new features, but at least i got priorities sorted out.

OLD BEHAVIOR
'gun convergence' disables autoaim/autoconvergence/table-defined fixed convergence. always use gunpoint normal for primaries.
use gunpoint normal for secondaries.

NEW BEHAVIOR
with 'gun convergence' activated, autoaim/autoconverge is active as long as target is in autoaim FOV, otherwise, follow gunpoint normal.
table defined convergence overrides pof-based 'gun convergence' for primaries.
use gunpoint normal for secondaries.


I feel the second behavior is closer to what one would want (seeing as if you go out of the way to define table-based convergence/autoaim for primaries, you probably want them to actually work eh?). You can always have your regular gun convergence simply by *not defining* any of the table based convergence options and leaving "gun convergence".

Also, it is now it is possible to have autoaim and off-axis secondaries, which was previously impossible. This was the primary motivation for me to create this patch.

It's a bit messy looking since I had to remove an entire conditional level and clear a bunch of indentations. (manually, oops)

I've tested the following scenarios
Autoaim Active with "gun convergence", target in FOV -> AUTOAIM behavior (tracking)
Autoaim Active with "gun convergence", target out of FOV -> firepoint normal
Autoaim Active no "gun convergence", target in FOV -> AUTOAIM behavior (tracking)
Autoaim Active no "gun convergence", target out of FOV -> straight forward

Secondaries with "gun convergence" -> firepoint normal
Secondaries no "gun convergence" -> straight forward

Thus I presume it should work with everything else
Though do test if you doubt me~

Code: [Select]

Index: ship.cpp
===================================================================
--- ship.cpp (revision 7759)
+++ ship.cpp (working copy)
@@ -1,4 +1,4 @@
-
+
 /*
  * Copyright (C) Volition, Inc. 1999.  All rights reserved.
  *
@@ -9756,123 +9756,68 @@
  vm_vec_add(&firing_pos, &gun_point, &obj->pos);
 
  matrix firing_orient;
- if (!(sip->flags2 & SIF2_GUN_CONVERGENCE))
+
+ if ((sip->aiming_flags & AIM_FLAG_AUTOAIM) &&
+ aip->target_objnum != -1)
  {
- if ((sip->aiming_flags & AIM_FLAG_AUTOAIM) &&
- aip->target_objnum != -1)
+ // Fire weapon in target direction
+ vec3d target_position, target_velocity_vec, predicted_target_pos;
+ vec3d firing_vec, last_delta_vec, player_forward_vec, plr_to_target_vec;
+ float dist_to_target, time_to_target, angle_to_target;
+
+ // If a subsystem is targeted, fire in that direction instead
+ if (aip->targeted_subsys != NULL)
  {
- // Fire weapon in target direction
- vec3d target_position, target_velocity_vec, predicted_target_pos;
- vec3d firing_vec, last_delta_vec, player_forward_vec, plr_to_target_vec;
- float dist_to_target, time_to_target, angle_to_target;
+ get_subsystem_world_pos(&Objects[aip->target_objnum], aip->targeted_subsys, &target_position);
+ }
+ else
+ {
+ target_position = Objects[aip->target_objnum].pos;
+ }
 
- // If a subsystem is targeted, fire in that direction instead
- if (aip->targeted_subsys != NULL)
- {
- get_subsystem_world_pos(&Objects[aip->target_objnum], aip->targeted_subsys, &target_position);
- }
- else
- {
- target_position = Objects[aip->target_objnum].pos;
- }
+ target_velocity_vec = Objects[aip->target_objnum].phys_info.vel;
+ if (The_mission.ai_profile->flags & AIPF_USE_ADDITIVE_WEAPON_VELOCITY)
+ vm_vec_sub2(&target_velocity_vec, &obj->phys_info.vel);
 
- target_velocity_vec = Objects[aip->target_objnum].phys_info.vel;
- if (The_mission.ai_profile->flags & AIPF_USE_ADDITIVE_WEAPON_VELOCITY)
- vm_vec_sub2(&target_velocity_vec, &obj->phys_info.vel);
+ dist_to_target = vm_vec_dist_quick(&target_position, &firing_pos);
+ time_to_target = 0.0f;
 
- dist_to_target = vm_vec_dist_quick(&target_position, &firing_pos);
- time_to_target = 0.0f;
+ if (winfo_p->max_speed != 0)
+ {
+ time_to_target = dist_to_target / winfo_p->max_speed;
+ }
 
- if (winfo_p->max_speed != 0)
- {
- time_to_target = dist_to_target / winfo_p->max_speed;
- }
+ vm_vec_scale_add(&predicted_target_pos, &target_position, &target_velocity_vec, time_to_target);
+ polish_predicted_target_pos(winfo_p, &Objects[aip->target_objnum], &target_position, &predicted_target_pos, dist_to_target, &last_delta_vec, 1);
+ vm_vec_sub(&plr_to_target_vec, &predicted_target_pos, &obj->pos);
 
- vm_vec_scale_add(&predicted_target_pos, &target_position, &target_velocity_vec, time_to_target);
- polish_predicted_target_pos(winfo_p, &Objects[aip->target_objnum], &target_position, &predicted_target_pos, dist_to_target, &last_delta_vec, 1);
- vm_vec_sub(&plr_to_target_vec, &predicted_target_pos, &obj->pos);
-
- // minimum convergence distance
- if (sip->minimum_convergence_distance > dist_to_target) {
- float dist_mult;
- dist_mult = sip->minimum_convergence_distance / dist_to_target;
- vm_vec_scale_add(&predicted_target_pos, &obj->pos, &plr_to_target_vec, dist_mult);
- }
+ // minimum convergence distance
+ if (sip->minimum_convergence_distance > dist_to_target) {
+ float dist_mult;
+ dist_mult = sip->minimum_convergence_distance / dist_to_target;
+ vm_vec_scale_add(&predicted_target_pos, &obj->pos, &plr_to_target_vec, dist_mult);
+ }
 
- // setting to autoaim to converge on to the target.
- if (sip->aiming_flags & AIM_FLAG_AUTOAIM_CONVERGENCE)
- vm_vec_sub(&firing_vec, &predicted_target_pos, &firing_pos);
- else
- vm_vec_sub(&firing_vec, &predicted_target_pos, &obj->pos);
+ // setting to autoaim to converge on to the target.
+ if (sip->aiming_flags & AIM_FLAG_AUTOAIM_CONVERGENCE)
+ vm_vec_sub(&firing_vec, &predicted_target_pos, &firing_pos);
+ else
+ vm_vec_sub(&firing_vec, &predicted_target_pos, &obj->pos);
 
 
- // Deactivate autoaiming if the target leaves the autoaim-FOV cone
- player_forward_vec = obj->orient.vec.fvec;
- angle_to_target = vm_vec_delta_ang(&player_forward_vec, &plr_to_target_vec, NULL);
+ // Deactivate autoaiming if the target leaves the autoaim-FOV cone
+ player_forward_vec = obj->orient.vec.fvec;
 
- if (angle_to_target < sip->autoaim_fov)
- {
- vm_vector_2_matrix(&firing_orient, &firing_vec, NULL, NULL);
- }
- else
- {
- firing_orient = obj->orient;
- }
- }
- else if ((sip->aiming_flags & AIM_FLAG_AUTO_CONVERGENCE) && (aip->target_objnum != -1))
+ angle_to_target = vm_vec_delta_ang(&player_forward_vec, &plr_to_target_vec, NULL);
+
+ if (angle_to_target < sip->autoaim_fov)
  {
- //Write automatic convergence code here!
- //If set, switch to manual if automatic fails
- //better idea.. mix it with the above... assume autoaim takes precedence
-
- // Fire weapon in target direction
- vec3d target_position, target_vec;
- vec3d firing_vec, player_forward_vec, convergence_offset;
- float dist_to_target;
-
- // If a subsystem is targeted, fire in that direction instead
- if (aip->targeted_subsys != NULL)
- {
- get_subsystem_world_pos(&Objects[aip->target_objnum], aip->targeted_subsys, &target_position);
- }
- else
- {
- target_position = Objects[aip->target_objnum].pos;
- }
-
- dist_to_target = vm_vec_dist_quick(&target_position, &firing_pos);
-
- if (sip->minimum_convergence_distance > dist_to_target)
- dist_to_target = sip->minimum_convergence_distance;
-
- player_forward_vec = obj->orient.vec.fvec;
- // make sure vector is of the set length
- vm_vec_copy_normalize(&target_vec, &player_forward_vec);
- vm_vec_scale(&target_vec, dist_to_target);
- // if there is convergence offset then make use of it)
- vm_vec_unrotate(&convergence_offset, &sip->convergence_offset, &obj->orient);
- vm_vec_add2(&target_vec, &convergence_offset);
- vm_vec_add2(&target_vec, &obj->pos);
- vm_vec_sub(&firing_vec, &target_vec, &firing_pos);
-
- // set orientation
  vm_vector_2_matrix(&firing_orient, &firing_vec, NULL, NULL);
-
  }
- else if (sip->aiming_flags & AIM_FLAG_STD_CONVERGENCE)
+ else if (sip->flags2 & SIF2_GUN_CONVERGENCE)
  {
- vec3d player_forward_vec, target_vec, firing_vec, convergence_offset;
- player_forward_vec = obj->orient.vec.fvec;
- // make sure vector is of the set length
- vm_vec_copy_normalize(&target_vec, &player_forward_vec);
- vm_vec_scale(&target_vec, sip->convergence_distance);
- // if there is convergence offset then make use of it)
- vm_vec_unrotate(&convergence_offset, &sip->convergence_offset, &obj->orient);
- vm_vec_add2(&target_vec, &convergence_offset);
- vm_vec_add2(&target_vec, &obj->pos);
- vm_vec_sub(&firing_vec, &target_vec, &firing_pos);
-
- // set orientation
+ vec3d firing_vec;
+ vm_vec_unrotate(&firing_vec, &pm->gun_banks[bank_to_fire].norm[pt], &obj->orient);
  vm_vector_2_matrix(&firing_orient, &firing_vec, NULL, NULL);
  }
  else
@@ -9880,12 +9825,73 @@
  firing_orient = obj->orient;
  }
  }
- else
+ else if ((sip->aiming_flags & AIM_FLAG_AUTO_CONVERGENCE) && (aip->target_objnum != -1))
  {
+ //Write automatic convergence code here!
+ //If set, switch to manual if automatic fails
+ //better idea.. mix it with the above... assume autoaim takes precedence
+
+ // Fire weapon in target direction
+ vec3d target_position, target_vec;
+ vec3d firing_vec, player_forward_vec, convergence_offset;
+ float dist_to_target;
+
+ // If a subsystem is targeted, fire in that direction instead
+ if (aip->targeted_subsys != NULL)
+ {
+ get_subsystem_world_pos(&Objects[aip->target_objnum], aip->targeted_subsys, &target_position);
+ }
+ else
+ {
+ target_position = Objects[aip->target_objnum].pos;
+ }
+
+ dist_to_target = vm_vec_dist_quick(&target_position, &firing_pos);
+
+ if (sip->minimum_convergence_distance > dist_to_target)
+ dist_to_target = sip->minimum_convergence_distance;
+
+ player_forward_vec = obj->orient.vec.fvec;
+ // make sure vector is of the set length
+ vm_vec_copy_normalize(&target_vec, &player_forward_vec);
+ vm_vec_scale(&target_vec, dist_to_target);
+ // if there is convergence offset then make use of it)
+ vm_vec_unrotate(&convergence_offset, &sip->convergence_offset, &obj->orient);
+ vm_vec_add2(&target_vec, &convergence_offset);
+ vm_vec_add2(&target_vec, &obj->pos);
+ vm_vec_sub(&firing_vec, &target_vec, &firing_pos);
+
+ // set orientation
+ vm_vector_2_matrix(&firing_orient, &firing_vec, NULL, NULL);
+
+ }
+ else if (sip->aiming_flags & AIM_FLAG_STD_CONVERGENCE)
+ {
+ vec3d player_forward_vec, target_vec, firing_vec, convergence_offset;
+ player_forward_vec = obj->orient.vec.fvec;
+ // make sure vector is of the set length
+ vm_vec_copy_normalize(&target_vec, &player_forward_vec);
+ vm_vec_scale(&target_vec, sip->convergence_distance);
+ // if there is convergence offset then make use of it)
+ vm_vec_unrotate(&convergence_offset, &sip->convergence_offset, &obj->orient);
+ vm_vec_add2(&target_vec, &convergence_offset);
+ vm_vec_add2(&target_vec, &obj->pos);
+ vm_vec_sub(&firing_vec, &target_vec, &firing_pos);
+
+ // set orientation
+ vm_vector_2_matrix(&firing_orient, &firing_vec, NULL, NULL);
+ }
+ else if (sip->flags2 & SIF2_GUN_CONVERGENCE)
+ {
  vec3d firing_vec;
  vm_vec_unrotate(&firing_vec, &pm->gun_banks[bank_to_fire].norm[pt], &obj->orient);
  vm_vector_2_matrix(&firing_orient, &firing_vec, NULL, NULL);
  }
+ else
+ {
+ firing_orient = obj->orient;
+ }
+
  // create the weapon -- the network signature for multiplayer is created inside
  // of weapon_create
 

[attachment deleted by ninja]

[chief1983]

From your description, that does sound like it's what FotG would want, although I probably want to play it just to make sure it doesn't break anything for us.

[Droid803]

Bubump.
I want this in trunk.
I don't want to keep basing my code off like two different patches >.> this, and nuke's armor.tbl upgrades, but they both fix issues critical to a number of missions I have >.>

Damage scaling before cutoff made things too easy on not-insane.
No autoaim with off axis missiles makes things too hard not-very-easy (you try hitting a 8m ship flying at 400m/s circle strafing you unassisted :/)

A Test Build: http://dl.dropbox.com/u/126554/FS2/fs2_open_3_6_13r_INF_SSE2.exe

[Alan Bolte]

Can't really use the secondary lock mechanism because then you'd have two different reticules trying to lock on to the ship.  My other thought was using the scan line system to show a lock in the target cam box somehow, or some sort of indicator by the primary weapon list.

You could also just copy x-wing and change the color or intensity of the boresight reticule. Alternately, take a feature from the modern FPS world and use variable-separation crosshairs.

(Yes, I know I'm replying to a month-old post)

[zookeeper]

BABUMP

No awesome new features, but at least i got priorities sorted out.

OLD BEHAVIOR
'gun convergence' disables autoaim/autoconvergence/table-defined fixed convergence. always use gunpoint normal for primaries.
use gunpoint normal for secondaries.

NEW BEHAVIOR
with 'gun convergence' activated, autoaim/autoconverge is active as long as target is in autoaim FOV, otherwise, follow gunpoint normal.
table defined convergence overrides pof-based 'gun convergence' for primaries.
use gunpoint normal for secondaries.


I feel the second behavior is closer to what one would want (seeing as if you go out of the way to define table-based convergence/autoaim for primaries, you probably want them to actually work eh?). You can always have your regular gun convergence simply by *not defining* any of the table based convergence options and leaving "gun convergence".

Doesn't this mean that now autoaim settings would simply disable convergence settings, instead of converge settings disabling autoaim settings? Here's a flowchart of sorts of how I think they should work and which should satisfy everyone.

Frankly, I think autoaim and gun convergence should be two completely separate settings. Autoaim should control only the direction of fire, and convergence should control convergence, and neither should affect the other.

EDIT: Nevermind the inconsistent use of arrows and that I forgot one "No" bubble.

[attachment deleted by ninja]

[Droid803]

The flowchart is what it should be doing.

I just removed the check that disables all autoaim/autoconverge if the "gun convergence" flag is used, and told it to use gunpoint normals only if no other convergence/autoaim is currently active (ie, nothing tracking), and then shoot straight forwards otherwise.

Firepoint normal gun convergence still works with converging autoaim tabled as long as target is not in autoaim FoV. As soon as the target enters autoaim FoV, all the gunpoints will start "tracking" it.

I tested it with a POF that has primary points at 90 degrees from forward, so it was pretty obvious what was happening XD

[Nuke]

i really dont see why you wouldn't want convergence with autoaim. if each gun is on its own gimbal then each gun would be able to track any point in space, and to intentionally making the shots maintain their spread doesn't make a lot of sense, unless of course you were independently targeting individual subsystems with each of your guns. i could understand any other scenario but that one.

also curious if your patch allows for tracking rate or if its still insti-snaps.

[chief1983]

But if the ship jukes just enough, you would miss all 4 shots.  If you fire them parallel, and your ship has a naturally wide coverage, you end up with good coverage at the target distance.  Maybe all won't hit, but one might be likely to.  It would probably come down to ship design and could affect pilot preference for one ship or another if you mix it up, or even find a way to make it selectable.

[CaptJosh]

Perhaps a method for primary fire lock-on that can be enabled or disabled to enable or disable convergence/auto-aim? Just a random idea.