Add a spawnflag to allow free aiming in side-scrolling mode

diff --git a/qcsrc/client/view.qc b/qcsrc/client/view.qc
index 4f2b43e914fb602d83c6f653a50fb7e2463740d1..57c48572a6b6dc73abd0e08da6d415bd07325bb4 100644 (file)
--- a/qcsrc/client/view.qc
+++ b/qcsrc/client/view.qc
@@ -1479,6 +1479,16 @@ void HUD_Draw(entity this)
        HitSound();
 }
 
+void ViewLocation_Mouse()
+{
+       viewloc_mousepos += getmousepos() * autocvar_menu_mouse_speed;
+       viewloc_mousepos.x = bound(0, viewloc_mousepos.x, vid_conwidth);
+       viewloc_mousepos.y = bound(0, viewloc_mousepos.y, vid_conheight);
+
+       float cursor_alpha = 1 - autocvar__menu_alpha;
+       draw_cursor(viewloc_mousepos, '0.5 0.5 0', "/cursor_move", '1 1 1', cursor_alpha);
+}
+
 bool ov_enabled;
 float oldr_nearclip;
 float oldr_farclip_base;
@@ -1576,6 +1586,11 @@ void CSQC_UpdateView(entity this, float w, float h)
                button_zoom = false;
        }
 
+       // abused multiple places below
+       entity local_player = ((csqcplayer) ? csqcplayer : CSQCModel_server2csqc(player_localentnum - 1));
+       if(!local_player)
+               local_player = this; // fall back!
+
        // event chase camera
        if(autocvar_chase_active <= 0) // greater than 0 means it's enabled manually, and this code is skipped
        {
@@ -1627,10 +1642,6 @@ void CSQC_UpdateView(entity this, float w, float h)
                        }
                        eventchase_running = true;
 
-                       entity local_player = ((csqcplayer) ? csqcplayer : CSQCModel_server2csqc(player_localentnum - 1));
-                       if(!local_player)
-                               local_player = this; // fall back!
-
                        // make special vector since we can't use view_origin (It is one frame old as of this code, it gets set later with the results this code makes.)
                        vector current_view_origin = (csqcplayer ? csqcplayer.origin : pmove_org);
                        if (custom_eventchase)
@@ -2375,6 +2386,8 @@ void CSQC_UpdateView(entity this, float w, float h)
                HUD_Minigame_Mouse();
        else if(QuickMenu_IsOpened())
                QuickMenu_Mouse();
+       else if(local_player.viewloc && (local_player.viewloc.spawnflags & VIEWLOC_FREEAIM))
+               ViewLocation_Mouse(); // NOTE: doesn't use cursormode
        else
                HUD_Radar_Mouse();
 

diff --git a/qcsrc/client/view.qh b/qcsrc/client/view.qh
index ac916a089568f55aa6f4e97e4ba4dc97f7517046..0a2c5c0c7066263f5a893538c5c26c152490f342 100644 (file)
--- a/qcsrc/client/view.qh
+++ b/qcsrc/client/view.qh
@@ -5,3 +5,5 @@
 vector crosshair_getcolor(entity this, float health_stat);
 
 entity viewmodels[MAX_WEAPONSLOTS];
+
+vector viewloc_mousepos;

diff --git a/qcsrc/common/triggers/trigger/viewloc.qc b/qcsrc/common/triggers/trigger/viewloc.qc
index ffc04a0782bf8d0a5b59c00876adf0b8319dc078..a99cdb4f2d4218ead31fa4cbdefbc6fa49123fa9 100644 (file)
--- a/qcsrc/common/triggers/trigger/viewloc.qc
+++ b/qcsrc/common/triggers/trigger/viewloc.qc
@@ -46,6 +46,8 @@ bool trigger_viewloc_send(entity this, entity to, int sf)
        // CSQC doesn't need to know our origin (yet), as we're only available for referencing
        WriteHeader(MSG_ENTITY, ENT_CLIENT_VIEWLOC_TRIGGER);
 
+       WriteByte(MSG_ENTITY, this.spawnflags);
+
        WriteEntity(MSG_ENTITY, this.enemy);
        WriteEntity(MSG_ENTITY, this.goalentity);
 
@@ -143,6 +145,8 @@ void trigger_viewloc_updatelink(entity this)
 
 NET_HANDLE(ENT_CLIENT_VIEWLOC_TRIGGER, bool isnew)
 {
+       this.spawnflags = ReadByte();
+
        float point1 = ReadShort();
        float point2 = ReadShort();
 

diff --git a/qcsrc/common/triggers/trigger/viewloc.qh b/qcsrc/common/triggers/trigger/viewloc.qh
index 167fc218f7707c5f00b2f70d612d654f21ee1999..3181e67b5dd592baacef6cdee10b801777dbfb78 100644 (file)
--- a/qcsrc/common/triggers/trigger/viewloc.qh
+++ b/qcsrc/common/triggers/trigger/viewloc.qh
@@ -2,6 +2,9 @@
 
 .entity viewloc;
 
+const int VIEWLOC_NOSIDESCROLL = BIT(0); // NOTE: currently unimplemented
+const int VIEWLOC_FREEAIM = BIT(1);
+
 #ifdef CSQC
 .entity goalentity;
 .entity enemy;

diff --git a/qcsrc/common/viewloc.qc b/qcsrc/common/viewloc.qc
index d6d7d9facfb2edc3f7f32c39138119723a47f5b0..6eec99ab254d6ba56bf9ee33c666dd9b044390dc 100644 (file)
--- a/qcsrc/common/viewloc.qc
+++ b/qcsrc/common/viewloc.qc
@@ -21,31 +21,38 @@ void viewloc_PlayerPhysics(entity this)
                PHYS_CS(this).movement_x = old_movement_y;
                PHYS_CS(this).movement_y = 0;
 
-               if(PHYS_CS(this).movement_x < 0)
-                       PHYS_CS(this).movement_x = -PHYS_CS(this).movement_x;
-
                vector level_start, level_end;
                level_start = this.viewloc.enemy.origin;
                level_end = this.viewloc.goalentity.origin;
-               vector forward, backward;
-               forward = vectoangles(normalize(level_end - level_start));
-               backward = vectoangles(normalize(level_start - level_end));
-
-               if(PHYS_CS(this).movement_x < 0) // left
-                       this.angles_y = backward_y;
-               if(PHYS_CS(this).movement_x > 0) // right
-                       this.angles_y = forward_y;
+               vector forward = vectoangles(normalize(level_end - level_start));
+               vector backward = vectoangles(normalize(level_start - level_end));
 
-               if(old_movement_x > 0)
-#ifdef CSQC
-                       input_angles_x =
-#endif
-                       this.v_angle_x = this.angles_x = -50;
-               else if(old_movement_x < 0)
-#ifdef CSQC
-                       input_angles_x =
-#endif
-                       this.v_angle_x = this.angles_x = 50;
+               if(this.viewloc.spawnflags & VIEWLOC_FREEAIM)
+               {
+                       if(this.angles_y > 0)
+                               PHYS_CS(this).movement_x = -PHYS_CS(this).movement_x;
+               }
+               else
+               {
+                       if(PHYS_CS(this).movement_x < 0)
+                               PHYS_CS(this).movement_x = -PHYS_CS(this).movement_x;
+
+                       if(PHYS_CS(this).movement_x < 0) // left
+                               this.angles_y = backward.y;
+                       if(PHYS_CS(this).movement_x > 0) // right
+                               this.angles_y = forward.y;
+
+                       if(old_movement_x > 0)
+       #ifdef CSQC
+                               input_angles_x =
+       #endif
+                               this.v_angle_x = this.angles_x = -50;
+                       else if(old_movement_x < 0)
+       #ifdef CSQC
+                               input_angles_x =
+       #endif
+                               this.v_angle_x = this.angles_x = 50;
+               }
 
                //if(!PHYS_INPUT_BUTTON_CROUCH(this) && !IS_DUCKED(this))
 #ifdef SVQC
@@ -77,6 +84,14 @@ void viewloc_SetTags(entity this)
                this.viewloc = findfloat(NULL, entnum, this.tag_networkviewloc);
 }
 
+vector CursorToWorldCoord(vector mpos)
+{
+       vector wnear = cs_unproject(vec2(mpos)); // determine the world coordinate for the mouse cursor upon the near clip plane
+       vector wfar = cs_unproject(vec3(mpos.x, mpos.y, max_shot_distance)); // determine the world coordinate for the mouse cursor upon the far clip plane, with an outrageously large value as a workaround for dp.
+       traceline(wnear, wfar, MOVE_NOMONSTERS, NULL);
+       return trace_endpos;
+}
+
 vector old_camera_angle = '0 0 0';
 bool autocvar_cam_snap_close;
 bool autocvar_cam_track;
@@ -128,18 +143,18 @@ void viewloc_SetViewLocation()
                         * NOTE: bug/feature: this will use non-snaped angles for one frame.
                         * doing this resualts in less code, faster code, and a smoother transisition between angles.
                         */
-                       float camera_angle_diff = max(camera_angle_y, old_camera_angle_y) - min(camera_angle_y, old_camera_angle_y);
+                       float camera_angle_diff = max(camera_angle.y, old_camera_angle.y) - min(camera_angle.y, old_camera_angle.y);
 
                        if ( camera_angle_diff >= 60)
-                               old_camera_angle_y = angle_snap_f(camera_angle_y, 90);
+                               old_camera_angle.y = angle_snap_f(camera_angle.y, 90);
                        else
-                               camera_angle_y = old_camera_angle_y;
+                               camera_angle.y = old_camera_angle.y;
                }
 
                //unlocking this allows the camera to look up and down. this also allows a top-down view.
                if (!autocvar_cam_snap_unlock) {
-                       camera_angle_x = 0;
-                       camera_angle_z = 0;
+                       camera_angle.x = 0;
+                       camera_angle.z = 0;
                }
 
 #if 0
@@ -158,12 +173,23 @@ void viewloc_SetViewLocation()
                        forward = vectoangles(normalize(vec_to_min(position_b, position_a) - vec_to_max(position_b, position_a)));
                        backward = vectoangles(normalize(vec_to_max(position_b, position_a) - vec_to_min(position_b, position_a)));
 
-                       if(input_movevalues_y < 0) // left
-                               view.angles_y = backward.y;
-                       if(input_movevalues_y > 0) // favour right
-                               view.angles_y = forward.y;
+                       if(!(view.viewloc.spawnflags & VIEWLOC_FREEAIM))
+                       {
+                               if(input_movevalues_y < 0) // left
+                                       view.angles_y = backward.y;
+                               if(input_movevalues_y > 0) // favour right
+                                       view.angles_y = forward.y;
 
-                       setproperty(VF_CL_VIEWANGLES, view.angles);
+                               setproperty(VF_CL_VIEWANGLES, view.angles);
+                       }
+                       else
+                       {
+                               //vector fpos = view.origin + view.view_ofs + forward * max_shot_distance;
+                               //vector bpos = view.origin + view.view_ofs + backward * max_shot_distance;
+                               vector mpos = CursorToWorldCoord(viewloc_mousepos);
+                               //vector pos_bounds = vec_bounds_in(mpos, fpos, bpos);
+                               setproperty(VF_CL_VIEWANGLES, aim_vec(view.origin + view.view_ofs, mpos));
+                       }
                }
        }
 }