Announcement

Collapse
No announcement yet.

[SOLVED]Zoom from OverShoulder to First Person style??

Collapse
X
 
  • Filter
  • Time
  • Show
Clear All
new posts

    [SOLVED]Zoom from OverShoulder to First Person style??

    I am trying to implement a zoom from OverShoulderCam to A FPS style cam instead of third person to shoulder. I do also have a third person camera class so really I would just need the correct code for implementing the zoom can some one point me in the right direction please. I want the zoom so it is almost like the player is looking down the gun through the sights, common in most fps games.

    My Code is :

    Pawn Class:

    Code:
    class RhonePawn extends UTPawn
        HideCategories(Movement, AI, Camera, Debug, Attachment, Physics, Advanced, Object);
    
    //makes player temporarily invulnerable to the enemy attacks so life depletes slower
    var bool bInvulnerable;
    var float InvulnerableTime;
    var bool bScoreDeaths;
    
    //sprint speed and stamina variables
    var float SprintSpeed;
    var float WalkSpeed;
    
    var float Stamina;
    var float SprintTimer;
    var float SprintRecoverTimer;
    var float Empty;
    var bool bSprinting;
    
    /** Used to decrease the poison length each tick */
    var int                                             PoisonCountdown;
    
    /** Stores our flashlight */
    var RhoneWeaponFlashlight                 Flashlight;
    
    /** Used for flashing damage as pawn's HP drops */
    var float                                         DamageOverlayTime;
    var    LinearColor                             DamageBodyMatColor;
    
    ///***************************************************************************
    //* Tells the pawn to draw all postrender functions
    //* http://forums.epicgames.com/archive/index.php/t-901388.html
    //***************************************************************************/
    //simulated function PostRenderFor(PlayerController PC, Canvas Canvas, vector CameraPosition,
    //vector CameraDir)
    //{
    //local vector ScreenPos;
    //
    //Super.PostRenderFor(PC, Canvas, CameraPosition, CameraDir);    
    //
    //ScreenPos = Canvas.Project(self.Location);     
    ////canvas.setPos(200,200);
    //canvas.SetPos(ScreenPos.X,ScreenPos.Y +100);
    //canvas.DrawText("TEST POST RENDER!");
    //canvas.TextSize(Canvas.TextSize);
    //
    //}
    
    /***************************************************************************
    * Lets us know that the class is being called, for debugging purposes
    ***************************************************************************/
    simulated event PostBeginPlay()
    {
        Super.PostBeginPlay();
        `Log("================");
        `Log("Rhone Pawn up");
        /** Flashlight */ 
        Flashlight = Spawn(class'RhoneWeaponFlashlight', self);            // Spawns the light on the player, setting self as owner
    
        Flashlight.SetBase(self);                                    // Sets the lights base on at the player    
        Flashlight.LightComponent.SetEnabled(false);                // Light is off by default 
        Flashlight.LightComponent.SetLightProperties(0.75);            // Starts at 75% brightness
        FlashDmg();
    
        /** called from UTPawn, spawns the default controller */
        SpawnDefaultController();
    }
    
    /***************************************************************************
    * Called by RhoneWeapon_PoisonDamage when the pawn is shot
    ***************************************************************************/
    function PoisonPlayer()
    {
        PoisonCountdown = 0;                                        // Reset Poison Counter
        SetTimer(0.5, true, 'PoisonDmg');                            // Every .5 seconds PoisonDmg() will be called
    }
    
    /***************************************************************************
    * NES style flashing damage timer to indicate how hurt a pawn is
    ***************************************************************************/
    function FlashDmgTimer()
    {
    
        if (Health < HealthMax /2)
        {
            `log("HP is less than 50%");
            SetTimer(2.2, true, 'FlashDmg');
        }
    
        if (Health < HealthMax /4)
        {
            `log("HP is less than 25%");
            SetTimer(1.5, true, 'FlashDmg');
        }    
    
        if (Health < HealthMax /10)
        {
            `log("HP is less than 10%");
            SetTimer(0.7, true, 'FlashDmg');
        }    
    }
    
    /***************************************************************************
    * Sets the flashing overlay on the pawn to indicate damage taken
    ***************************************************************************/
    simulated function FlashDmg()
    {    
        SetBodyMatColor(DamageBodyMatColor, DamageOverlayTime);        
    }
    
    /***************************************************************************
    * Called when a pawn is hit
    ***************************************************************************/
    function PlayHit(float Damage, Controller InstigatedBy, vector HitLocation, 
    class<DamageType> damageType, vector Momentum, TraceHitInfo HitInfo)
    {
        Super.PlayHit(Damage, InstigatedBy, HitLocation, DamageType, Momentum, HitInfo);                    
        FlashDmgTimer();        
    }
    
    /***************************************************************************
    * Actually does the damage to the pawn
    ***************************************************************************/
    function PoisonDmg()
    {
        Local Pawn P;
    
        P = self;                                        // Set the pawn to yourself
    
        /** Does 5 damage to the pawn of type UTDmgType_Burning */
        TakeDamage( 5, None, Location, vect(0,0,0) , class'UTDmgType_Burning');
        PoisonCountdown=PoisonCountdown+1;                // Increment timer
        `Log("***Pawn Health:" @P.Health);                // Log for debugging
    
        /** clear the infinitely looping 0.5 second timer after 10 counts of damage */
        if(PoisonCountdown >= 10)
        {
            ClearTimer('PoisonDmg');
        }
    }
    
    /***************************************************************************
    * Turns the light on and off
    ***************************************************************************/
    exec function ToggleFlashlight()
    {
        if(!Flashlight.LightComponent.bEnabled)            // If the light is off...    
        {
            Flashlight.LightComponent.SetEnabled(true); // Then turn it on
            `log("TOGGLE FLASHLIGHT ON");
        }
        else                                            // If it's already on
        {
            Flashlight.LightComponent.SetEnabled(false);// Turn it off
            `log("TOGGLE FLASHLIGHT OFF");
        }
    }
    
    /***************************************************************************
    * Forces the flashlight to use our pawn's rotation
    ***************************************************************************/
    event UpdateEyeHeight( float DeltaTime )
    {
        Super.UpdateEyeHeight(DeltaTime);
        Flashlight.SetRotation(Controller.Rotation);    // Flashlight will use our controller's rotation        
    
        /**  Offset the light slightly, so that it looks as though it is coming from our pawn's eyes/helmet */
        Flashlight.SetRelativeLocation(Controller.RelativeLocation + vect(20, 0, 25));
    }
    
    ///***********************************************************************************
    //**USED FOR TOP DOWN Camera**
    //* Forces the weapon to use the pawn's direction for aiming, and not the camera's
    //* shots will be fired in the direction the gun is pointed. Used by PlayerController
    //* Comment this out if you are not using any camera system other than top down. 
    //* @return POVRot.
    //***********************************************************************************/
    //simulated singular event Rotator GetBaseAimRotation()
    //{
    //local rotator POVRot, tempRot;
    //
    //tempRot = Rotation;
    //SetRotation(tempRot);
    //POVRot = Rotation;
    //
    //// Stops the player from being able to adjust the pitch of the shot, forcing the camera to always point
    //// down towards the pawn. We can still rotate left and right, however. 
    ////    POVRot.Pitch = 0;
    //
    //return POVRot;
    //}
    
    /***************************************************************************
    * Returns base Aim Rotation without any adjustment.  We simply use our rotation
    * Only use this if you want your weapon trace to follow where your gun is 
    * pointed. Projectiles will now follow your trace.  Comment out if you want
    *  to fire in middle of screen.
    * @return    POVRot
    ***************************************************************************/
    simulated singular event Rotator GetBaseAimRotation()
    {
        local rotator    POVRot;
    
        // We simply use our rotation
        POVRot = Rotation;
    
        // If our Pitch is 0, then use RemoveViewPitch
        if( POVRot.Pitch == 0 )
        {
            POVRot.Pitch = RemoteViewPitch << 8;
        }
    
        return POVRot;
    }
    
    
    event Bump(Actor Other, PrimitiveComponent OtherComp, vector HitNormal)
    {
        if(RhoneEnemy(Other) != none && !bInvulnerable)
        {
            bInvulnerable = true;
            SetTimer(InvulnerableTime, false, 'EndInvulnerable');
            TakeDamage(RhoneEnemy(Other).BumpDamage, none, Location, vect(0,0,0), class'UTDmgType_LinkPlasma');
        }
    }
    
    function EndInvulnerable()
    {
        bInvulnerable = false;
    }
    
    exec function startSprint()
    {
        GroundSpeed = SprintSpeed;
        bSprinting = true;
        if(GroundSpeed == SprintSpeed)
        {
            StopFiring();
            SetTimer(SprintTimer, false, 'EmptySprint');
        }
    }
    
    exec function stopSprint()
    {
        GroundSpeed = WalkSpeed;
    }
    
    simulated function EmptySprint()
    {
        Stamina = Empty;
        GroundSpeed = WalkSpeed;
        bSprinting = true;
        SetTimer(SprintRecoverTimer, false, 'ReplenishStamina');
    }
    
    simulated function ReplenishStamina()
    {
        Stamina = 20.0;
        bSprinting = false;
    }
    
    simulated function PlayFootStepSound(int FootDown)
    {
        super.PlayFootStepSound(FootDown);
    }
    
    defaultproperties
    {
        /** AI and navigation */
        bAvoidLedges=true                // don't get too close to ledges
            bStopAtLedges=true                // if bAvoidLedges and bStopAtLedges, Pawn doesn't try to walk along the edge at all
            bUpdateEyeHeight=true            // Updates eye height so that the flashlight can become dynamic
    
            /** Used for flashing damage as pawn's HP drops */
            DamageOverlayTime=.1            // The flash lasts this long (float)
            DamageBodyMatColor=(R=10)        // Sets the pawn to flash red (hence the R=10)
    
            /** PostRender functions */
            bPostRenderIfNotVisible = true    // IF true, may call PostRenderFor() even when this actor is not visible 
            bPostRenderOtherTeam=true        // If true, call postrenderfor() even if on different team
    
        //invulnerable 
        bScoreDeaths=false
            bCanPickupInventory=True
            InvulnerableTime=0.6
    
            //sprint and stamina settings
            GroundSpeed=200.0
            AirSpeed=200.0
    
            WalkSpeed=220.0
            SprintSpeed=500.0
            SprintTimer=12.0
            SprintRecoverTimer=8.0
            Stamina=10.0
            Empty=1
    }
    PlayerController Class:

    Code:
    class RhonePlayerController extends PlayerController;
    
    // Reference to the camera properties
    var const RhoneCameraProperties CameraProperties;
    
    /** Array used for setting the number of spawned companions */
    var Pawn                           Companions[3];
    
    var Actor CurrentPickup;
    
    /************************************************************************************
    * Rotator where the pawn will be aiming the weapon, forces the game to use the pawn's 
    * direction for aiming, not camera's
    ************************************************************************************/
    function Rotator GetAdjustedAimFor(Weapon W, vector StartFireLoc)
    {
        return Pawn.GetBaseAimRotation(); 
    }
    
    /************************************************************************************
    * Spawns companion pawns
    ************************************************************************************/
    function PlayerSpawned(NavigationPoint StartLocation)
    {
        Companions[0] = Spawn(Class'RhonePawn',,, StartLocation.Location - vect(75,100,0), StartLocation.Rotation);
        Companions[1] = Spawn(Class'RhonePawn',,, StartLocation.Location - vect(150,120,0), StartLocation.Rotation);
        Companions[2] = Spawn(Class'RhonePawn',,, StartLocation.Location - vect(200,280,0), StartLocation.Rotation);
    }
    
    
    /*
    ================================================
    ValidPickup()
    
    Checks whether or not a certain actor is actually something we can pickup or not.
    Rather bad way to go about it, but since PickupFactories, DroppedPickups etc
    don't share and common parent class, aside from Actor, I'm unsure what to check for yet...
    ================================================
    */
    function bool ValidPickup(Actor Pickup)
    {
        // all dropped pickups can be picked up, else they wouldn't exist
        if (DroppedPickup(Pickup) != None)
        {
            return true;
        }
        else if (PickupFactory(Pickup) != None)
        {
            // If a pickup factory is hidden, it can't be picked up
            return (PickupFactory(Pickup).bPickupHidden == false);
        }
        // If a pickup factory is hidden, it can't be picked up
        else if (UTCarriedObject(Pickup) != None)
        {
            if (UTCarriedObject(Pickup).bHome == true)
            {
                return true;
            }
    
            if (UTCarriedObject(Pickup).IsInState('Dropped'))
            {
                return true;
            }
        }
    
    
        // not a valid pickup
        return false;
    }
    
    
    /*
    ================================================
    FindPickup()
    
    Finds a pickup (dropped, factory, weapon cache etc) within a limited radius.
    Returns true if its valid.
    ================================================
    */
    function bool FindPickup()
    {
        local Actor Pickup, Best;
        local vector ViewDir, PawnLoc2D, PickupLoc2D;
        local float NewDot, BestDot;
    
        if (Pawn == None)
        {
            return false;
        }
    
        CurrentPickup = None;
    
        // are we standing on one?
        if ((Pawn.Base != None) && ValidPickup(Pawn.Base))
        {
            CurrentPickup = Pawn.Base;
            return true;
        }
    
        // Pick best nearby item
        PawnLoc2D = Pawn.Location;
        PawnLoc2D.Z = 0;
        ViewDir = vector(Pawn.Rotation);
    
        ForEach Pawn.OverlappingActors(class'Actor', Pickup, Pawn.VehicleCheckRadius)
        {
            if (ValidPickup(Pickup))
            {
                // Prefer items that Pawn is facing
                PickupLoc2D = Pickup.Location;
                PickupLoc2D.Z = 0;
                NewDot = Normal(PickupLoc2D-PawnLoc2D) Dot ViewDir;
                if ((Best == None) || (NewDot > BestDot))
                {
                    // check that item is visible
                    if ( FastTrace(Pickup.Location,Pawn.Location) )
                    {
                        Best = Pickup;
                        BestDot = NewDot;
                    }
                }
            }
        }
    
        // remember what we found please
        CurrentPickup = Best;
    
        // if Best is not NULL, we found something
        return (Best != None);
    }
    
    
    simulated function bool PerformedUseAction()
    {
        Super.PerformedUseAction();
    
        // If we find a valid pickup, touch it.
        if (FindPickup())
        {
            CurrentPickup.Touch(Pawn, None, CurrentPickup.Location, Normal(CurrentPickup.Location-Pawn.Location));
            pawn.bCanPickupInventory = true;
            return true;
        }
    
    }
    
    
    /*************************************************************************************************************
    * Place the name of the camera you want to use in here. If you want to adjust it on the fly within the editor, 
    * use the Archetype that we've created, so Class'RhoneGameCamera'. 
    * Otherwise, enter the name of the class you'd like to use. i.e. 'ThirdPersonCam'
    *************************************************************************************************************/
    defaultproperties
    {
        //Switch between the different styles of camera
        // Allows us to use the camera archetype within the editor to change values on the fly
        //CameraClass = Class'ThirdPersonCam'//Telling the player controller to use your custom camera script
        CameraClass = Class'OverShoulderCam'//Telling the player controller to use your custom camera script
        //CameraClass = Class'FirstPersonCam'//Telling the player controller to use your custom camera script
        //CameraClass = Class'TopDownCam'//Telling the player controller to use your custom camera script
        //CameraClass = Class'SideScrollingCam'//Telling the player controller to use your custom camera script
        CheatClass=class'DebugMenu'            // Reference for DebugMenu
    }
    Camera Class

    Code:
    class OverShoulderCam extends Camera;
    
    //Hardcoded vector offset we will use, rather than tweaking values in the editor's CameraProperties
    var const Vector OSCamOffset;
    //Hardcoded rotator offset we will use, rather than tweaking values in the editor's CameraProperties
    var const Rotator OSCamOffsetRotation;
    
    /**********************************************************************************
     * Query ViewTarget and outputs Point Of View.
     *
     * @param        OutVT            ViewTarget to use.
     * @param        DeltaTime        Delta Time since last camera update (in seconds)
     **********************************************************************************/
    function UpdateViewTarget(out TViewTarget OutVT, float DeltaTime)
    {
        local Pawn Pawn;
        local Vector V, PotentialCameraLocation, HitLocation, HitNormal;
        local Actor HitActor;
    
        // UpdateViewTarget for the camera class we're extending from
        Super.UpdateViewTarget(OutVT, DeltaTime);
    
        // If there is an interpolation, don't update outgoing viewtarget 
        if (PendingViewTarget.Target != None && OutVT == ViewTarget && BlendParams.bLockOutgoing)
        {
            return;
        }
    
        Pawn = Pawn(OutVT.Target);
        if (Pawn != None)
        {
            // Hide the pawn's first-person weapon
            if(Pawn.Weapon != none)
            {
                Pawn.Weapon.SetHidden(true);
            }
    
            /************************************************************************************************
            * If you know the name of the bone socket you want to use, then replace 'WeaponPoint' with yours.
            * Otherwise, just use the Pawn's eye view point as your starting point
            *************************************************************************************************/
            //socket not found, use the other way of updating vectors
            if (Pawn.Mesh.GetSocketWorldLocationAndRotation('WeaponPoint', OutVT.POV.Location, OutVT.POV.Rotation) == false) 
            {
                //Start the camera location from the target eye view point
                OutVT.Target.GetActorEyesViewPoint(OutVT.POV.Location, OutVT.POV.Rotation);
            }
    
            // Force the camera to use the target's rotation
            OutVT.Target.GetActorEyesViewPoint(V, OutVT.POV.Rotation);
    
            // Add the camera offset
            OutVT.POV.Rotation += OSCamOffsetRotation;
    
            // Math for the potential camera location
            PotentialCameraLocation = OutVT.POV.Location + (OSCamOffset >> OutVT.POV.Rotation);        
    
            // Draw a trace to see if the potential camera location will work
            HitActor = Trace(HitLocation, HitNormal, PotentialCameraLocation, OutVT.POV.Location, true,,, TRACEFLAG_BULLET);
    
            // Will the trace hit world geometry? If so then use the hit location and offset it by the hit normal
            if (HitActor != None && HitActor.bWorldGeometry)
            {
                OutVT.POV.Location = HitLocation + HitNormal * 16.f;
            }
            else
            {
                OutVT.POV.Location = PotentialCameraLocation;
            }
        }
    }
    
    // Hardcoded vector & rotator values for our camera
    defaultproperties
    {
        OSCamOffset=(x=-60,y=20,z=25)
        OSCamOffsetRotation=(Pitch=-2048)
    }
    
    /********************
    *****Reference*******
    *********************
    * 65536 = 360 degrees
    * 32768 = 180 degrees
    * 16384 =  90 degrees
    *  8192 =  45 degrees
    *    182 =    1 degree
    *********************/

    #2
    Hello Men and Women,

    So basically we already have these roles filled:

    TEAM ROLES:

    David Gunner, Robert Ramsay & David Goffe, Matthew Scannell: Lead Designers
    Lucas: Lead Audio Director
    Audio/Sfx : Jamie Lewis
    Lead Video Editor/Story Boarder: Robert Ramsay (if time) OTHERS NEEDED
    Plot: David Gunner, David Goffe, Robert Ramsay & Matthew Scannell
    Lead Concept Art : Robert Ramsay & Airhead (Tom Gray)
    3D Modeller : Robert Ramsay, OTHERS NEEDED
    Proofreading, spelling and grammar checking: Laura Goffe, Matthew Scannell
    Alex Smith : Weapons Expert/Analyst


    We are in need of:

    Programmers : (I have taken up learning Unrealscript so am willing to work with and learn with people who are knowledgeable in this field)

    Comic Style (Graphic Novelist) : We do have 2 artists but they are very busy doing other things, so we need a Comic Style Concept Artist. The role here will be to put the games prequel if you like into a comic style intro before the games main intro, this will explain the back story leading up to the point of the game starting. More info on the game can be found on the original post here : Team-Members-Wanted-For-S-A-S-Diaries-Project-Rhone-Island! For additional information and updates on the game please feel free to contact me below.

    If anybody is interested please contact me by:

    E-Mail : DaveyG24@live.co.uk

    Skype : daveyg25

    Thanks

    Comment


      #3
      All right, so what you're going to want to do is create two new classes: one of them is RhonePlayerInput.
      Code:
      class RhonePlayerInput extends UTPlayerInput within RhonePlayerController
      config(RhoneInput);
      
      //rest of class here
      Then in RhonePlayerController, you should set the Input Class in DefaultProperties to this input:
      Code:
      InputClass=class'Rhone.RhonePlayerInput'
      And lastly you'll need to make a "Default" config file in UDKGame > Config called "DefaultRhoneInput" (or just Default- and the same name you used up in the config("") when you declare RhonePlayerInput).
      The inside of this config file should look like this:
      Code:
      [Configuration]
      BasedOn=..\UDKGame\Config\DefaultInput.ini
      
      ;-----------------------------------------------------------------------------------------
      ; RHONE GAME FUNCTIONS
      ;-----------------------------------------------------------------------------------------
      [Rhone.RhonePlayerInput]
      .Bindings=(Name="Rhone_ShoulderAim",Command="ZoomOverTheShoulder | OnRelease ReleaseOverTheShoulder")
      .Bindings=(Name="RightMouseButton",Command="HOLLOW_ShoulderAim")
      What this will do is make it so when you press the right mouse button when using this PlayerController, UDK will look for an "exec function" called ZoomOverTheShoulder() and then one called ReleaseOverTheShoulder() in RhonePlayerInput.
      You can use a different button if you like, just use DefaultInput.ini for reference.

      RhonePlayerInput, because it's "within" RhonePlayerController, can then call any function inside RhonePlayerController directly as if it were right inside it. So:

      In RhonePlayerController:
      Code:
      function TurnOnZoom(){
         PlayerCamera.zoomIsOn = true;
      }
      function TurnOffZoom(){
         PlayerCamera.zoomIsOn = false;
      }
      And in RhonePlayerInput:
      Code:
      exec function ZoomOverTheShoulder(){
         TurnOnZoom();
      }
      exec function ZoomOverTheShoulder(){
         TurnOffZoom();
      }
      You'll have to create a bool variable in OverShoulderCam to keep track of whether the zoom is on or off, and have RhonePlayerController change it. Then, in UpdateViewTarget() in OverShoulderCam, just check if the bool is true or false; if it's false, show the camera as normal. If it's true, change the numbers so that the camera is closer to the player.


      This is a very basic tutorial, but it will get you started. Getting any more complicated right now will get you lost; for now, focus on getting the camera positioned how you want it and reacting to your input.

      Comment


        #4
        Originally posted by ortizgames View Post
        All right, so what you're going to want to do is create two new classes: one of them is RhonePlayerInput.
        Code:
        class RhonePlayerInput extends UTPlayerInput within RhonePlayerController
        config(RhoneInput);
        
        //rest of class here
        Then in RhonePlayerController, you should set the Input Class in DefaultProperties to this input:
        Code:
        InputClass=class'Rhone.RhonePlayerInput'
        And lastly you'll need to make a "Default" config file in UDKGame > Config called "DefaultRhoneInput" (or just Default- and the same name you used up in the config("") when you declare RhonePlayerInput).
        The inside of this config file should look like this:
        Code:
        [Configuration]
        BasedOn=..\UDKGame\Config\DefaultInput.ini
        
        ;-----------------------------------------------------------------------------------------
        ; RHONE GAME FUNCTIONS
        ;-----------------------------------------------------------------------------------------
        [Rhone.RhonePlayerInput]
        .Bindings=(Name="Rhone_ShoulderAim",Command="ZoomOverTheShoulder | OnRelease ReleaseOverTheShoulder")
        .Bindings=(Name="RightMouseButton",Command="HOLLOW_ShoulderAim")
        What this will do is make it so when you press the right mouse button when using this PlayerController, UDK will look for an "exec function" called ZoomOverTheShoulder() and then one called ReleaseOverTheShoulder() in RhonePlayerInput.
        You can use a different button if you like, just use DefaultInput.ini for reference.

        RhonePlayerInput, because it's "within" RhonePlayerController, can then call any function inside RhonePlayerController directly as if it were right inside it. So:

        In RhonePlayerController:
        Code:
        function TurnOnZoom(){
           PlayerCamera.zoomIsOn = true;
        }
        function TurnOffZoom(){
           PlayerCamera.zoomIsOn = false;
        }
        And in RhonePlayerInput:
        Code:
        exec function ZoomOverTheShoulder(){
           TurnOnZoom();
        }
        exec function ZoomOverTheShoulder(){
           TurnOffZoom();
        }
        You'll have to create a bool variable in OverShoulderCam to keep track of whether the zoom is on or off, and have RhonePlayerController change it. Then, in UpdateViewTarget() in OverShoulderCam, just check if the bool is true or false; if it's false, show the camera as normal. If it's true, change the numbers so that the camera is closer to the player.


        This is a very basic tutorial, but it will get you started. Getting any more complicated right now will get you lost; for now, focus on getting the camera positioned how you want it and reacting to your input.
        Hey Ortiz thanks for your help man this is great stuff, I have it all implemented and in place, thank you very much for your help bro!

        Comment


          #5
          Ok so I have implemented everything Ortiz showed me which is great, appreciated very much but now I just need some help with what to put into the if statement in the camera class so here is the updated code! can anybody help me with examples of what I could put into the highlighted red code.
          Code:
          class OverShoulderCam extends Camera;
          
          
          //Hardcoded vector offset we will use, rather than tweaking values in the editor's CameraProperties
          
          var const Vector OSCamOffset;
          
          //Hardcoded rotator offset we will use, rather than tweaking values in the editor's CameraProperties
          
          var const Rotator OSCamOffsetRotation;
          
          
          var bool ZoomIsOn;
          
          
          /**********************************************************************************
          
           * Query ViewTarget and outputs Point Of View.
          
           *
          
           * @param        OutVT            ViewTarget to use.
          
           * @param        DeltaTime        Delta Time since last camera update (in seconds)
          
           **********************************************************************************/
          
          function UpdateViewTarget(out TViewTarget OutVT, float DeltaTime)
          
          {
          
              local Pawn Pawn;
          
              local Vector V, PotentialCameraLocation, HitLocation, HitNormal;
          
              local Actor HitActor;
          
          
          // UpdateViewTarget for the camera class we're extending from
          
              Super.UpdateViewTarget(OutVT, DeltaTime);
          
          
          // If there is an interpolation, don't update outgoing viewtarget 
          
          if (PendingViewTarget.Target != None && OutVT == ViewTarget && BlendParams.bLockOutgoing)
          
              {
          
          return;
          
              }  
          
          
          if(ZoomIsOn)
          
              {
          
                  
          
              }
          
          
          else
          
              {
          
                  
          
              } 
           
          
              Pawn = Pawn(OutVT.Target);
          
          if (Pawn != None)
          
              {
          
          // Hide the pawn's first-person weapon
          
          if(Pawn.Weapon != none)
          
                  {
          
                      Pawn.Weapon.SetHidden(true);
          
                  }
          
          
          /************************************************************************************************
          
                  * If you know the name of the bone socket you want to use, then replace 'WeaponPoint' with yours.
          
                  * Otherwise, just use the Pawn's eye view point as your starting point
          
                  *************************************************************************************************/
          
          //socket not found, use the other way of updating vectors
          
          if (Pawn.Mesh.GetSocketWorldLocationAndRotation('WeaponPoint', OutVT.POV.Location, OutVT.POV.Rotation) == false) 
          
                  {
          
          //Start the camera location from the target eye view point
          
                      OutVT.Target.GetActorEyesViewPoint(OutVT.POV.Location, OutVT.POV.Rotation);
          
                  }
          
          
          // Force the camera to use the target's rotation
          
                  OutVT.Target.GetActorEyesViewPoint(V, OutVT.POV.Rotation);
          
          
          // Add the camera offset
          
                  OutVT.POV.Rotation += OSCamOffsetRotation;
          
          
          // Math for the potential camera location
          
                  PotentialCameraLocation = OutVT.POV.Location + (OSCamOffset >> OutVT.POV.Rotation);        
          
          
          // Draw a trace to see if the potential camera location will work
          
                  HitActor = Trace(HitLocation, HitNormal, PotentialCameraLocation, OutVT.POV.Location, true,,, TRACEFLAG_BULLET);
          
          
          // Will the trace hit world geometry? If so then use the hit location and offset it by the hit normal
          
          if (HitActor != None && HitActor.bWorldGeometry)
          
                  {
          
                      OutVT.POV.Location = HitLocation + HitNormal * 16.f;
          
                  }
          
          else
          
                  {
          
                      OutVT.POV.Location = PotentialCameraLocation;
          
                  }
          
              }
          
          }
          
          
          // Hardcoded vector & rotator values for our camera
          
          defaultproperties
          
          {
          
              OSCamOffset=(x=-60,y=20,z=25)
          
              OSCamOffsetRotation=(Pitch=-2048)
          
          }
          
          
          /********************
          
          *****Reference*******
          
          *********************
          
          * 65536 = 360 degrees
          
          * 32768 = 180 degrees
          
          * 16384 =  90 degrees
          
          *  8192 =  45 degrees
          
          *    182 =    1 degree
          
          *********************/
          
          
           
          

          Comment


            #6
            Originally posted by GunnerJnr View Post
            Ok so I have implemented everything Ortiz showed me which is great, appreciated very much but now I just need some help with what to put into the if statement in the camera class so here is the updated code! can anybody help me with examples of what I could put into the highlighted red code.
            Code:
            class OverShoulderCam extends Camera;
            
            
            //Hardcoded vector offset we will use, rather than tweaking values in the editor's CameraProperties
            
            var const Vector OSCamOffset;
            
            //Hardcoded rotator offset we will use, rather than tweaking values in the editor's CameraProperties
            
            var const Rotator OSCamOffsetRotation;
            
            
            var bool ZoomIsOn;
            
            
            /**********************************************************************************
            
             * Query ViewTarget and outputs Point Of View.
            
             *
            
             * @param        OutVT            ViewTarget to use.
            
             * @param        DeltaTime        Delta Time since last camera update (in seconds)
            
             **********************************************************************************/
            
            function UpdateViewTarget(out TViewTarget OutVT, float DeltaTime)
            
            {
            
                local Pawn Pawn;
            
                local Vector V, PotentialCameraLocation, HitLocation, HitNormal;
            
                local Actor HitActor;
            
            
            // UpdateViewTarget for the camera class we're extending from
            
                Super.UpdateViewTarget(OutVT, DeltaTime);
            
            
            // If there is an interpolation, don't update outgoing viewtarget 
            
            if (PendingViewTarget.Target != None && OutVT == ViewTarget && BlendParams.bLockOutgoing)
            
                {
            
            return;
            
                }  
            
            
            if(ZoomIsOn)
            
                {
            
                    
            
                }
            
            
            else
            
                {
            
                    
            
                } 
             
            
                Pawn = Pawn(OutVT.Target);
            
            if (Pawn != None)
            
                {
            
            // Hide the pawn's first-person weapon
            
            if(Pawn.Weapon != none)
            
                    {
            
                        Pawn.Weapon.SetHidden(true);
            
                    }
            
            
            /************************************************************************************************
            
                    * If you know the name of the bone socket you want to use, then replace 'WeaponPoint' with yours.
            
                    * Otherwise, just use the Pawn's eye view point as your starting point
            
                    *************************************************************************************************/
            
            //socket not found, use the other way of updating vectors
            
            if (Pawn.Mesh.GetSocketWorldLocationAndRotation('WeaponPoint', OutVT.POV.Location, OutVT.POV.Rotation) == false) 
            
                    {
            
            //Start the camera location from the target eye view point
            
                        OutVT.Target.GetActorEyesViewPoint(OutVT.POV.Location, OutVT.POV.Rotation);
            
                    }
            
            
            // Force the camera to use the target's rotation
            
                    OutVT.Target.GetActorEyesViewPoint(V, OutVT.POV.Rotation);
            
            
            // Add the camera offset
            
                    OutVT.POV.Rotation += OSCamOffsetRotation;
            
            
            // Math for the potential camera location
            
                    PotentialCameraLocation = OutVT.POV.Location + (OSCamOffset >> OutVT.POV.Rotation);        
            
            
            // Draw a trace to see if the potential camera location will work
            
                    HitActor = Trace(HitLocation, HitNormal, PotentialCameraLocation, OutVT.POV.Location, true,,, TRACEFLAG_BULLET);
            
            
            // Will the trace hit world geometry? If so then use the hit location and offset it by the hit normal
            
            if (HitActor != None && HitActor.bWorldGeometry)
            
                    {
            
                        OutVT.POV.Location = HitLocation + HitNormal * 16.f;
            
                    }
            
            else
            
                    {
            
                        OutVT.POV.Location = PotentialCameraLocation;
            
                    }
            
                }
            
            }
            
            
            // Hardcoded vector & rotator values for our camera
            
            defaultproperties
            
            {
            
                OSCamOffset=(x=-60,y=20,z=25)
            
                OSCamOffsetRotation=(Pitch=-2048)
            
            }
            
            
            /********************
            
            *****Reference*******
            
            *********************
            
            * 65536 = 360 degrees
            
            * 32768 = 180 degrees
            
            * 16384 =  90 degrees
            
            *  8192 =  45 degrees
            
            *    182 =    1 degree
            
            *********************/
            
            
             
            
            it actually didn't highlight red but it is this bit :
            Code:
            if(ZoomIsOn)
            
                {
            
                    
            
                }
            
            
            else
            
                {
            
                    
            
                }
            

            Comment


              #7
              Solved had to add defaultfov angles

              Comment

              Working...
              X