Tyler Hallada
c25499b41e
Set ModVersion and add update code. Update docs. Might add another couple fixes before releasing 0.2.0.
1305 lines
61 KiB
Plaintext
1305 lines
61 KiB
Plaintext
ScriptName RYBQuestScript
|
|
|
|
float fQuestDelayTime ; controls script update rate, see: https://cs.uesp.net/wiki/FQuestDelayTime
|
|
float HighUpdateRate ; script updates per second when boat is moving or rocking (default: 0.0166)
|
|
float MediumUpdateRate ; script updates per second when boat is not moving or rocking but nearby (default: 0.1)
|
|
float LowUpdateRate ; script updates per second when far away from the boat (default: 1.0)
|
|
|
|
float ModVersion ; For handling updates
|
|
|
|
; Quest script states
|
|
short Initializing
|
|
|
|
; Boat states
|
|
short BoatMoving ; 0 = not moving, 1 = about to move this tick, 2 = in motion
|
|
short Rowing ; 0 = not rowing (timed), 1 = rowing forward (timed), 2 = rowing backward (timed)
|
|
short AutoRowing ; 0 = not auto rowing, 1 = auto rowing forward, 2 = auto rowing backward
|
|
; 1 = run positioning code once relative to player
|
|
; 2 = run positioning code once relative to boat
|
|
; -1 = re-enable boat and attachments, then run positioning code once relative to player
|
|
short Resetting
|
|
short LockHeading ; 0 = free to turn, 1 = locked to current boat heading
|
|
short LadderDeployed ; 0 = disabled, 1 = enabled
|
|
short LampOn
|
|
; 0 = not summoning, 1 = waiting for collider to move, 2 = moving boat to collider,
|
|
; 3 = moving slightly to fix collision/interaction issues
|
|
short Summoning
|
|
short Dragging ; 0 = not dragging, 1 = dragging
|
|
short Grounded ; 0 = not grounded, 1 = collided with something and stopped
|
|
short OnLand ; 0 = not on land, 1 = on land (Z position is too high) auto-set if BoatZ > LandZThreshold
|
|
short BoatPurchased
|
|
short ChestPurchased
|
|
short LampPurchased
|
|
short LadderPurchased
|
|
short PlayerNearBoat ; 0 = not near boat, 1 = near boat (within RockDistanceThreshold)
|
|
|
|
; Triggers
|
|
; Sort of like functions that any script can call by setting these to 1 which this script will handle and set back to 0
|
|
short TriggerAutoRow ; 1 = auto-row forward, 2 = auto-row backward
|
|
short TriggerGetOnBoat ; 1 = get on boat via SetPosition, 2 = sit on the seat
|
|
short TriggerStartDragging ; 1 = will start dragging if Dragging == 0
|
|
short TriggerStopDragging ; 1 = will stop dragging if Dragging == 1
|
|
short TriggerSummonBoat ; 1 = summon boat, 2 = place boat right here
|
|
short TriggerRowCast ; player casting the row spell will set this to 1 (forward) or 2 (back)
|
|
|
|
float SecondsPassed ; actual time passed since last frame (GetSecondsPassed)
|
|
float SmoothedDeltaTime ; SecondsPassed adjusted to the recent average frame rate using exponentially smoothing
|
|
; How much to smooth the delta time.
|
|
; Tune this between 0.05-0.2 to make adjustments more/less responsive to frame rate changes (default: 0.1)
|
|
float DeltaSmoothingFactor
|
|
float TargetDeltaTime ; target delta time to smooth to (default: 0.0166) aka. 60fps
|
|
|
|
; All "base" speed/rate values below assume a frame rate of 60fps (0.0166 seconds per frame)
|
|
; To prevent the boat from moving faster in higher FPS and slower in lower FPS, the speed values are dynamically
|
|
; adjusted to the current frame rate (based on the result of GetSecondsPassed exponentially smoothed over many frames).
|
|
float BaseBoatVelocity ; distance in units to move the boat every frame
|
|
float AbsoluteBoatVelocity ; absolute value of BaseBoatVelocity (used in calculating the turn rate)
|
|
float FrameBoatVelocity
|
|
float BoatMaxVelocity ; maximum distance in units to move the boat every frame (default: 6)
|
|
float VelocityDecayLnRetentionFactor ; natural log of the retention factor (0.99) per frame at 60fps (default: -0.01005)
|
|
float FrameVelocityDecay ; how much to multiply the velocity by every frame to decay it. will be calculated
|
|
float BaseRowForce ; how much to increase/decrease the velocity every frame when rowing (default: 0.05)
|
|
float FrameRowForce
|
|
float BaseTurnRate ; how much to turn the boat every frame (default: 0.4)
|
|
float TurnRateVelocityFactor ; how much to multiply the base turn rate by based on the boat's velocity (calculated)
|
|
float FrameTurnRate
|
|
float CurrentTurnRate ; the actual turn rate being applied this frame (decayed or accelerated version of FrameTurnRate)
|
|
float TurnRateAcceleration ; how quickly turn rate ramps up (default: 0.15)
|
|
float TurnRateDeceleration ; how quickly turn rate decays when not turning (default: 0.92)
|
|
float LandZThreshold ; Z position that the boat must be above to be considered on land (default: 10)
|
|
float WaterLevelZ ; Z position of the water level (default: 0)
|
|
|
|
float RowTimer ; current time left before stopping rowing
|
|
float RowSpellDuration ; duration to row after spell is cast (default: 1.0)
|
|
float OverboardDistance ; distance in units from the boat to be considered overboard (default: 300)
|
|
float PlayerDistance ; current distance from the player to the boat (returned from GetDistance)
|
|
|
|
float SummonDistance ; distance in units to place the boat in front of the player when summoning (default: 350)
|
|
; summoning the boat goes haywire unless we give things time to "settle" this delays moving the boat a bit
|
|
float SummonTimer ; how much time left to wait before executing the next step of summoning (default: 0.5)
|
|
float SummonTimerDelay ; how long to wait in seconds after summoning to move boat to collider (default: 0.5)
|
|
float PlayerSin
|
|
float PlayerCos
|
|
|
|
; Dragging physics variables
|
|
float DragRopeLength ; how far the player can get before boat starts moving (default: 100)
|
|
float DragTautDistanceSquared ; current distance from player to tow point (squared)
|
|
float DragSlackDistance ; how much slack is in the rope
|
|
float PlayerMovementDistance
|
|
float PlayerMovementForce
|
|
float DragPointX ; point where the rope connects (center of boat)
|
|
float DragPointY
|
|
float DragTargetAngle
|
|
float DragForceX ; force applied to boat
|
|
float DragForceY
|
|
float DragBoatVelocityX ; boat's current drag velocity
|
|
float DragBoatVelocityY
|
|
float DragVelocitySquared
|
|
float DragFriction ; how quickly boat stops when not being pulled. 1.0 = no friction (default: 0.85)
|
|
float DragBaseTurnRate ; how fast boat rotates to match drag direction (default: 0.1)
|
|
float DragFrameTurnRate ; how much to rotate the boat this frame adjusted for the current frame rate
|
|
float DragMaxTurnPerFrame ; maximum angle to turn the boat per frame while dragging (default: 0.1)
|
|
float DragTurnDeadzone ; difference of degrees in player angle to boat angle to ignore before turning (default: 5)
|
|
float DragCurrentTurnRate ; current turn rate applied this frame while dragging adjusted with accel/decel smoothing
|
|
float DragTurnRateAcceleration ; how quickly to accelerate the turn rate while dragging (default: 0.15)
|
|
float DragTurnRateDeceleration ; how quickly to decelerate the turn rate while dragging (default: 0.92)
|
|
float DragAngleDiff ; difference between boat angle and drag angle
|
|
float DragPullStrength ; how strong the pull is (default: 0.005)
|
|
float DragMaxForce ; maximum force to apply to the boat (default: 0.5)
|
|
float DragMaxVelocity ; maximum velocity of the boat while dragging (default: 4.0)
|
|
float DragZInterpolationRate ; how quickly to interpolate the Z position of the boat to the player (default: 0.1)
|
|
float DragPlayerBoatZDiff ; difference between player Z and boat Z
|
|
float DragFrameBoatZAdjust ; adjustment to the boat Z position this frame based on player Z
|
|
float DragLandPlayerZOffset ; offset from the player z to place the drag point, to raise the boat up (default: 30)
|
|
float DragMaxZPerFrame ; maximum Z distance to move the boat per frame while dragging (default: 0.1)
|
|
float DragMaxPlayerDistance ; maximum distance between player and boat before dragging is canceled (default: 1800)
|
|
float DragPitchAngle ; current smoothed pitch angle for dragging terrain
|
|
float DragTargetPitchAngle ; target pitch angle to smooth toward
|
|
float DragMaxPitchAngle ; maximum (absolute) pitch angle to apply while dragging (default: 45)
|
|
float DragPitchSmoothingFactor ; how quickly to smooth pitch changes (default: 0.15)
|
|
float DragPathStartX ; Start position of current path segment
|
|
float DragPathStartY
|
|
float DragPathStartZ
|
|
float DragPathDistance ; Distance traveled in current segment
|
|
float DragPathSlope ; Calculated slope of boat's path
|
|
float DragPathMinDistance ; Minimum distance before calculating slope (default: 50)
|
|
float DragPathSlopeFactor ; Factor to invert and minimize slope player path (default: -0.7)
|
|
float DragPathSlopeDeadzone ; Angle of player path that will not affect pitch (default: 2)
|
|
float DragTargetPitchMovingSmoothingFactor ; Additional smoothing factor on pitch applied while moving (default: 0.03)
|
|
float DragTargetPitchStoppedSmoothingFactor ; Additional smoothing factor on pitch applied while stopped (default: 0.02)
|
|
float DragUphillZAdjustmentFactor ; How much to adjust Z based on angle when going uphill (default: 6.0)
|
|
float DragDownhillZAdjustmentFactor ; How much to adjust Z based on angle when going downhill (default: 4.5)
|
|
; Boat drag angle calculation variables
|
|
float dX
|
|
float dY
|
|
float dXAbs
|
|
float dYAbs
|
|
float a
|
|
float r
|
|
float s
|
|
|
|
; Rocking animation variables
|
|
; IMPORTANT: Keep pitch and roll angles small (under 10-15 degrees) to avoid gimbal lock issues
|
|
; The boat's primary movement still relies on Z rotation, these are just visual effects
|
|
float RockingEnabled ; 0 = disabled, 1 = enabled (default: 1)
|
|
float RockPhase ; Current phase of the primary rocking motion (0-360)
|
|
float RockPhase2 ; Secondary rocking phase for more complex motion
|
|
float RockPhase3 ; Tertiary phase for roll motion
|
|
float RockAmplitudeZ ; How much the boat rocks up/down (in units) (default: 0.8)
|
|
float RockAmplitudePitch ; How much the boat pitches forward/back (in degrees) (default: 2.0)
|
|
float RockAmplitudeRoll ; How much the boat rolls side-to-side (in degrees) (default: 3.0)
|
|
float RockMaxAbsoluteZ ; Maximum BoatZ +/- Z offset value allowed from rocking (in units) (default: 3.0)
|
|
float RockFrequency ; How fast the boat rocks (degrees per second) (default: 30.0)
|
|
float RockFrequency2 ; Secondary frequency for complex motion (default: 45.0)
|
|
float RockFrequency3 ; Frequency for roll motion (default: 25.0)
|
|
float RockRandomPhase ; Random offset to make rocking look natural
|
|
float RockRandomTimer ; Timer for changing random values
|
|
float RockRandomInterval ; How often to change random values (in seconds) (default: 3.0)
|
|
float RockSpeedFactor ; How much boat speed affects rocking (default: 0.5)
|
|
float RockWeatherFactor ; Multiplier for bad weather (purely based on GetWindSpeed currently) (default: 0.5)
|
|
float WindSpeed ; Current wind speed (0-1) from GetWindSpeed
|
|
float RockDistanceThreshold ; Distance from player to enable rocking (in units) (default: 3000)
|
|
float TargetRockZOffset ; Target Z offset from rocking
|
|
float TargetRockPitchOffset ; Target pitch (X angle) offset from rocking
|
|
float TargetRockRollOffset ; Target roll (Y angle) offset from rocking
|
|
float RockZOffset ; Current smoothed boat Z offset from rocking
|
|
float RockPitchOffset ; Current smoothed pitch (X angle) offset from rocking
|
|
float RockRollOffset ; Current smoothed roll (Y angle) offset from rocking
|
|
float RockSmoothingFactor ; How quickly rocking starts from nothing and settles when stopped (default: 0.1)
|
|
float BoatPitchAngle ; Current pitch angle of boat
|
|
float BoatRollAngle ; Current roll angle of boat
|
|
; Sine approximation variables for rocking
|
|
float rockAng
|
|
float rockN
|
|
float rockT2
|
|
float rockSin
|
|
float rockSin2
|
|
float rockSin3
|
|
float rockCos3
|
|
; Attachment rotation calculation variables
|
|
float PitchRadians ; Pitch angle in radians for calculations
|
|
float RollRadians ; Roll angle in radians for calculations
|
|
float SinPitch ; Sine of pitch angle
|
|
float SinRoll ; Sine of roll angle
|
|
float CosPitch ; Cosine of pitch angle
|
|
float CosRoll ; Cosine of roll angle
|
|
float OrigX
|
|
float OrigY
|
|
float OrigZ
|
|
float TempX
|
|
float TempY
|
|
float TempZ
|
|
; Player weight influence variables
|
|
float PlayerWeightEnabled ; 0 = disabled, 1 = enabled (default: 1)
|
|
float PlayerLocalX ; Player's position relative to boat center (starboard/port)
|
|
float PlayerLocalY ; Player's position relative to boat center (bow/stern)
|
|
float PlayerLocalZ ; Player's position relative to boat center (up/down)
|
|
float PlayerRelativeX ; World relative position before rotation
|
|
float PlayerRelativeY ; World relative position before rotation
|
|
float PlayerDistanceFromCenter ; How far player is from boat center
|
|
float PlayerWeightInfluence ; 0-1 multiplier based on distance from center
|
|
float PlayerWeightMaxDistanceForward ; bow to stern max distance (default: 240)
|
|
float PlayerWeightMaxDistanceSide ; port to starboard max distance (default: 100)
|
|
float PlayerWeightMaxDistanceVertical ; vertical max distance (default: 60)
|
|
float PlayerWeightPitchFactor ; How much player position affects pitch (default: 0.15)
|
|
float PlayerWeightRollFactor ; How much player position affects roll (default: 0.12)
|
|
float PlayerWeightPitchOffset ; Pitch offset caused by player weight
|
|
float PlayerWeightRollOffset ; Roll offset caused by player weight
|
|
float PlayerWeightSmoothingFactor ; How quickly weight effects change (default: 0.2)
|
|
float TargetPlayerWeightPitchOffset ; Target pitch offset for smoothing
|
|
float TargetPlayerWeightRollOffset ; Target roll offset for smoothing
|
|
|
|
ref BoatRef
|
|
float BoatX
|
|
float BoatY
|
|
float BoatZ
|
|
float BoatZWithRock ; BoatZ + RockZOffset
|
|
float BoatAngle
|
|
|
|
float PlayerX
|
|
float PlayerY
|
|
float PlayerZ
|
|
float PlayerAngle
|
|
|
|
float Diff
|
|
float Hemi
|
|
float BoatModelAngle ; boat's in-game model is rotated 90 degrees offset from 0, this stores true model angle
|
|
float TurnDeadzone ; difference of degrees in player angle to boat angle to ignore before turning (default: 10)
|
|
|
|
; Math variables for boat movement phyiscs
|
|
float pi
|
|
float halfPi
|
|
float radToDeg
|
|
float degToRad
|
|
float ang
|
|
float n
|
|
float t2
|
|
; (specific to boat yaw angle)
|
|
float sin
|
|
float cos
|
|
float tan
|
|
|
|
ref BoatMarker
|
|
float BoatMarkerZ
|
|
float BoatMarkerZOffset ; offset from the boat to place the map marker (default: 20)
|
|
|
|
ref Seat
|
|
float SeatX
|
|
float SeatY
|
|
float SeatZ
|
|
float SeatForwardOffset ; pos units from boat center along bow to stern to place the seat
|
|
float SeatSideOffset ; pos units from boat center along port to starboard to place the seat
|
|
float SeatZOffset ; pos units from BoatZ upwards to place the seat (default: 19)
|
|
|
|
ref Chest
|
|
float ChestX
|
|
float ChestY
|
|
float ChestZ
|
|
float ChestAngle
|
|
float ChestAngleOffset
|
|
float ChestForwardOffset ; pos units from boat center along bow to stern to place the chest
|
|
float ChestSideOffset ; pos units from boat center along port to starboard to place the chest
|
|
float ChestZOffset ; pos units from BoatZ upwards to place the chest (default: 15)
|
|
|
|
ref LampLit
|
|
ref LampUnlit
|
|
float LampX
|
|
float LampY
|
|
float LampZ
|
|
float LampForwardOffset ; pos units from boat center along bow to stern to place the lamp
|
|
float LampSideOffset ; pos units from boat center along port to starboard to place the lamp
|
|
float LampZOffset ; pos units from BoatZ upwards to place the lamp (default: 87)
|
|
|
|
ref Ladder
|
|
float LadderX
|
|
float LadderY
|
|
float LadderZ
|
|
float LadderForwardOffset ; pos units from boat center along bow to stern to place the ladder
|
|
float LadderSideOffset ; pos units from boat center along port to starboard to place the ladder
|
|
float LadderZOffset ; pos units from BoatZ upwards to place the ladder (default: -28)
|
|
|
|
ref Collider
|
|
float ColliderX
|
|
float ColliderActualX
|
|
float ColliderY
|
|
float ColliderActualY
|
|
float ColliderZ
|
|
float ColliderOffset ; pos units from boat center towards boat direction to place the collider
|
|
float ColliderOffsetReverse ; pos units from boat center towards the back of the boat to place the collider
|
|
float ColliderMoveFreq ; how often to move the collider in seconds (default: 0.05)
|
|
float ColliderMoveTimer ; current time left to wait before moving the collider again
|
|
float CollisionDetectDelay ; how long to wait in seconds at boat startup before checking for collision (default: 2)
|
|
float CollisionDetectTimer ; current time left to give for moving the boat away at startup before detecting collision
|
|
short CollisionDetectZThreshold ; Z position that the collider must be above to be considered colliding with something
|
|
; how close (in units) the collider must be to the expected position to trigger a collision (default: 1.0)
|
|
float ColliderPosThreshold
|
|
|
|
begin GameMode
|
|
if (Initializing == 0)
|
|
set Initializing to 1
|
|
; start in low-processing mode and switch to faster later on when boat is moving
|
|
set fQuestDelayTime to LowUpdateRate
|
|
; Initialization is done in stage result scripts to save max script size space
|
|
SetStage RYB 1 ; init constants
|
|
SetStage RYB 2 ; init refs
|
|
SetStage RYB 3 ; init collider
|
|
SetStage RYB 4 ; init summoning
|
|
SetStage RYB 5 ; init dragging
|
|
SetStage RYB 6 ; init rocking
|
|
SetStage RYB 7 ; init player weight
|
|
endif
|
|
|
|
if (ModVersion < 0.2)
|
|
set ModVersion to 0.2
|
|
set ColliderPosThreshold to 1.0
|
|
endif
|
|
|
|
if (Resetting == -1)
|
|
SetStage RYB 51 ; Re-enable boat and attachment refs
|
|
set Resetting to 1
|
|
endif
|
|
|
|
set PlayerDistance to BoatRef.GetDistance Player
|
|
if (PlayerDistance < RockDistanceThreshold)
|
|
if (RockingEnabled == 1)
|
|
set fQuestDelayTime to HighUpdateRate ; high processing rate when near the boat for rocking animation
|
|
else
|
|
set fQuestDelayTime to MediumUpdateRate ; medium processing rate when nearby but rocking is disabled
|
|
endif
|
|
if (PlayerNearBoat == 0)
|
|
; Fix bug with boat disappearing after returning to the boat's cell by disabling all refs and re-enable in
|
|
; the next frame
|
|
SetStage RYB 50 ; Disable boat and attachment refs
|
|
set Resetting to -1 ; re-enable boat and attachment refs next frame
|
|
endif
|
|
set PlayerNearBoat to 1
|
|
else
|
|
set fQuestDelayTime to LowUpdateRate ; low processing rate when far away
|
|
set PlayerNearBoat to 0
|
|
; SetStage RYB 50 ; Disable boat and attachment refs when away
|
|
endif
|
|
|
|
if (TriggerAutoRow == 1)
|
|
set TriggerAutoRow to 0
|
|
set BoatMoving to 1
|
|
set fQuestDelayTime to HighUpdateRate
|
|
set AutoRowing to 1
|
|
set Grounded to 0
|
|
set DragTargetPitchAngle to 0
|
|
Seat.SetDestroyed 1
|
|
BoatMarker.Disable
|
|
Ladder.Disable
|
|
set LadderDeployed to 0
|
|
|
|
set BaseBoatVelocity to BaseRowForce
|
|
set CollisionDetectTimer to CollisionDetectDelay
|
|
elseif (TriggerAutoRow == 2)
|
|
set TriggerAutoRow to 0
|
|
set BoatMoving to 1
|
|
set Grounded to 0
|
|
set DragTargetPitchAngle to 0
|
|
set fQuestDelayTime to HighUpdateRate
|
|
set AutoRowing to 2
|
|
Seat.SetDestroyed 1
|
|
BoatMarker.Disable
|
|
Ladder.Disable
|
|
set LadderDeployed to 0
|
|
|
|
set BaseBoatVelocity to -BaseRowForce
|
|
set CollisionDetectTimer to CollisionDetectDelay
|
|
endif
|
|
|
|
; For some unknown reason, this player distance check only works in this script and not in the menu script
|
|
if (TriggerRowCast > 0 && PlayerDistance > OverboardDistance)
|
|
set TriggerRowCast to 0
|
|
set RYBMenu.TriggerRowCast to 3 ; not near boat messagebox
|
|
elseif (TriggerRowCast > 0 && Dragging >= 1)
|
|
set TriggerRowCast to 0
|
|
set RYBMenu.TriggerRowCast to 4 ; dragging boat messagebox
|
|
elseif (TriggerRowCast > 0 && OnLand == 1)
|
|
set TriggerRowCast to 0
|
|
set RYBMenu.TriggerRowCast to 5 ; boat on land messagebox
|
|
elseif (TriggerRowCast == 1)
|
|
set TriggerRowCast to 0
|
|
set AutoRowing to 0 ; rowing manually cancels auto rowing
|
|
set Rowing to 1
|
|
set RowTimer to RowSpellDuration
|
|
if (BoatMoving == 0)
|
|
set BoatMoving to 1
|
|
set Grounded to 0
|
|
set DragTargetPitchAngle to 0
|
|
set fQuestDelayTime to HighUpdateRate
|
|
Seat.SetDestroyed 1
|
|
BoatMarker.Disable
|
|
Ladder.Disable
|
|
set LadderDeployed to 0
|
|
set BaseBoatVelocity to BaseRowForce
|
|
set CollisionDetectTimer to CollisionDetectDelay
|
|
endif
|
|
elseif (TriggerRowCast == 2)
|
|
set TriggerRowCast to 0
|
|
set AutoRowing to 0 ; rowing manually cancels auto rowing
|
|
set DragTargetPitchAngle to 0
|
|
set Rowing to 2
|
|
set RowTimer to RowSpellDuration
|
|
if (BoatMoving == 0)
|
|
set BoatMoving to 1
|
|
set Grounded to 0
|
|
set fQuestDelayTime to HighUpdateRate
|
|
Seat.SetDestroyed 1
|
|
BoatMarker.Disable
|
|
Ladder.Disable
|
|
set LadderDeployed to 0
|
|
set BaseBoatVelocity to -BaseRowForce
|
|
set CollisionDetectTimer to CollisionDetectDelay
|
|
endif
|
|
endif
|
|
|
|
if (TriggerGetOnBoat == 1)
|
|
set TriggerGetOnBoat to 0
|
|
SetStage RYB 11 ; Update boat position and angle
|
|
set PlayerZ to BoatZ + 20
|
|
|
|
; TODO: this sometimes doesn't put the player on the boat
|
|
Player.SetPos x BoatX
|
|
Player.SetPos y BoatY
|
|
Player.SetPos z PlayerZ
|
|
Player.SetAngle z BoatAngle
|
|
Message "You climbed onto the boat."
|
|
elseif (TriggerGetOnBoat == 2)
|
|
set TriggerGetOnBoat to 0
|
|
Seat.Activate Player 1
|
|
endif
|
|
|
|
if (TriggerStartDragging == 1)
|
|
set TriggerStartDragging to 0
|
|
if (Dragging == 0)
|
|
set Dragging to 1
|
|
set DragTargetPitchAngle to 0 ; smooth reset to 0 pitch
|
|
Player.AddItem RYBBoatToken 1
|
|
set fQuestDelayTime to HighUpdateRate ; High update rate while dragging
|
|
Seat.SetDestroyed 1
|
|
BoatMarker.Disable
|
|
set Grounded to 0
|
|
|
|
; stop the boat from moving while summoning
|
|
set BaseBoatVelocity to 0
|
|
set CurrentTurnRate to 0
|
|
; Initialize dragging state
|
|
set DragBoatVelocityX to 0
|
|
set DragBoatVelocityY to 0
|
|
|
|
SetStage RYB 11 ; Update boat position and angle
|
|
set DragTargetAngle to BoatAngle
|
|
; Initialize path tracking
|
|
set DragPathStartX to Player.GetPos x
|
|
set DragPathStartY to Player.GetPos y
|
|
set DragPathStartZ to Player.GetPos z
|
|
set DragPathSlope to 0
|
|
|
|
if (OnLand == 1 && Player.IsSwimming == 0)
|
|
; When on land, raise the boat up a bit to indicate dragging has been activated
|
|
set DragPlayerBoatZDiff to (PlayerZ + DragLandPlayerZOffset) - BoatZ
|
|
set Dragging to 2 ; special state that allows z change until boat meets this z change
|
|
endif
|
|
|
|
Message "You are now dragging the boat."
|
|
endif
|
|
endif
|
|
if (TriggerStopDragging == 1)
|
|
set TriggerStopDragging to 0
|
|
if (Dragging >= 1)
|
|
set Dragging to 0
|
|
if (RockingEnabled == 0)
|
|
set fQuestDelayTime to MediumUpdateRate
|
|
endif
|
|
set DragBoatVelocityX to 0
|
|
set DragBoatVelocityY to 0
|
|
Player.RemoveItem RYBBoatToken 1
|
|
Seat.SetDestroyed 0
|
|
BoatMarker.Enable
|
|
Message "You stop dragging the boat."
|
|
endif
|
|
endif
|
|
|
|
if (TriggerSummonBoat >= 1)
|
|
set fQuestDelayTime to HighUpdateRate
|
|
; stop the boat from moving while summoning
|
|
set BoatMoving to 0
|
|
set Grounded to 0
|
|
Seat.SetDestroyed 0
|
|
set BaseBoatVelocity to 0
|
|
set CurrentTurnRate to 0
|
|
set DragTargetPitchAngle to 0
|
|
set PlayerX to Player.GetPos x
|
|
set PlayerY to Player.GetPos y
|
|
set PlayerZ to Player.GetPos z
|
|
if (PlayerZ < 1)
|
|
set PlayerZ to 1
|
|
endif
|
|
set PlayerAngle to Player.GetAngle z
|
|
if (PlayerAngle < 0)
|
|
set PlayerAngle to PlayerAngle + 360
|
|
elseif (PlayerAngle >= 360)
|
|
set PlayerAngle to PlayerAngle - 360
|
|
endif
|
|
set BoatAngle to PlayerAngle
|
|
set BoatModelAngle to BoatAngle + 90
|
|
if (BoatModelAngle < 0)
|
|
set BoatModelAngle to BoatModelAngle + 360
|
|
elseif (BoatModelAngle >= 360)
|
|
set BoatModelAngle to BoatModelAngle - 360
|
|
endif
|
|
; This positions the invisible collider SummonDistance units in front of the player.
|
|
; The game places actors in a way that avoids terrain and object collisions so this is a hack to prevent
|
|
; too much clipping on the boat when it is summoned.
|
|
set ang to PlayerAngle
|
|
SetStage RYB 18 ; Calculate sin/cos of the player angle
|
|
|
|
if (TriggerSummonBoat == 1)
|
|
set TriggerSummonBoat to 0
|
|
Message "Summoning boat..."
|
|
; Use collider to find a good spot to place the boat in front of the player
|
|
set ColliderX to PlayerX + (PlayerSin * SummonDistance)
|
|
set ColliderY to PlayerY + (PlayerCos * SummonDistance)
|
|
SetStage RYB 20 ; Enable and position collider
|
|
|
|
; need to wait for collider to move and "settle" before moving the boat to the spot the collider found
|
|
set SummonTimer to SummonTimerDelay
|
|
set Summoning to 1
|
|
return
|
|
elseif (TriggerSummonBoat == 2)
|
|
set TriggerSummonBoat to 0
|
|
Message "Placing boat..."
|
|
set BoatX to PlayerX + (PlayerSin * SummonDistance)
|
|
set BoatY to PlayerY + (PlayerCos * SummonDistance)
|
|
set BoatZ to PlayerZ
|
|
; Disable all the refs first since they need to be disabled and enabled one frame later to appear correctly
|
|
SetStage RYB 50 ; Disable boat and attachment refs
|
|
BoatRef.MoveTo Player
|
|
BoatRef.SetPos x, BoatX
|
|
BoatRef.SetPos y, BoatY
|
|
BoatRef.SetPos z, BoatZ
|
|
BoatRef.SetAngle z, BoatModelAngle
|
|
set Summoning to 2
|
|
return
|
|
endif
|
|
endif
|
|
|
|
if (SummonTimer > 0)
|
|
set SummonTimer to SummonTimer - SecondsPassed
|
|
elseif (SummonTimer <= 0 && Summoning == 1) ; time to move the boat to the collider
|
|
set BoatX to Collider.GetPos x
|
|
set BoatY to Collider.GetPos y
|
|
set BoatZ to Collider.GetPos z
|
|
set BoatZ to BoatZ - RockZOffset ; remove rocking offset from last frame to get "true" Z
|
|
if (BoatZ < (WaterLevelZ + 1))
|
|
set BoatZ to WaterLevelZ + 1
|
|
endif
|
|
SetStage RYB 50 ; Disable boat and attachment refs
|
|
BoatRef.MoveTo Player
|
|
BoatRef.SetPos x, BoatX
|
|
BoatRef.SetPos y, BoatY
|
|
BoatRef.SetPos z, BoatZ
|
|
BoatRef.SetAngle z, BoatModelAngle
|
|
|
|
Collider.Disable
|
|
set Summoning to 2
|
|
return
|
|
; set SummonTimer to SummonTimerDelay ; this delay maybe not necessary
|
|
elseif (Summoning == 2)
|
|
set Summoning to 0
|
|
SetStage RYB 51 ; Re-enable boat and attachment refs
|
|
if (RockingEnabled == 0)
|
|
set fQuestDelayTime to MediumUpdateRate
|
|
endif
|
|
set Resetting to 1
|
|
endif
|
|
|
|
if (LampOn == 1 && LampLit.GetDisabled == 1 && Resetting != -1)
|
|
set Resetting to 1
|
|
LampLit.Enable
|
|
LampUnlit.PlaySound3D SPLFireballFail
|
|
elseif (LampOn == 0 && LampLit.GetDisabled == 0 && Resetting != -1)
|
|
set Resetting to 1
|
|
LampLit.Disable
|
|
LampUnlit.PlaySound3D ITMTorchHeldExt
|
|
endif
|
|
|
|
set SecondsPassed to GetSecondsPassed
|
|
; Clamp extreme values
|
|
if (SecondsPassed < 0.001)
|
|
set SecondsPassed to 0.001
|
|
elseif (SecondsPassed > 0.1)
|
|
set SecondsPassed to 0.1
|
|
endif
|
|
|
|
; Exponentially smooth the delta time to adjust for frame rate changes
|
|
set SmoothedDeltaTime to ((1.0 - DeltaSmoothingFactor) * SmoothedDeltaTime) + (DeltaSmoothingFactor * SecondsPassed)
|
|
|
|
; Speed values assume a frame rate of 60fps so readjust speed values to current frame rate
|
|
set FrameRowForce to BaseRowForce * (SmoothedDeltaTime / TargetDeltaTime)
|
|
|
|
if (Rowing == 0 && AutoRowing == 0 && BoatMoving == 2)
|
|
; Boat is moving, but not rowing. Decay the velocity using exponential decay.
|
|
; velocity = velocity * (1 - decay * time)
|
|
if (BaseBoatVelocity != 0)
|
|
; Calculate decay factor based on smoothed delta time
|
|
; Convert to time-based decay
|
|
; retention^(frames) = retention^(time/frameTime)
|
|
; We need to calculate r^(SmoothedDeltaTime/TargetDeltaTime)
|
|
|
|
; Approximation since we can't do pow():
|
|
; For small time steps, r^t ≈ 1 + t*ln(r)
|
|
; ln(0.98) ≈ -0.0202
|
|
set FrameVelocityDecay to 1 + (SmoothedDeltaTime / TargetDeltaTime) * (VelocityDecayLnRetentionFactor)
|
|
set BaseBoatVelocity to BaseBoatVelocity * FrameVelocityDecay
|
|
|
|
; Stop when very slow
|
|
if (BaseBoatVelocity > -0.2 && BaseBoatVelocity < 0.2)
|
|
set BaseBoatVelocity to 0
|
|
set BoatMoving to 0
|
|
if (RockingEnabled == 0)
|
|
set fQuestDelayTime to MediumUpdateRate
|
|
endif
|
|
Seat.SetDestroyed 0
|
|
BoatMarker.Enable
|
|
Collider.Disable
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
if ((Rowing == 1 || AutoRowing == 1) && BoatMoving == 2 && BaseBoatVelocity < BoatMaxVelocity)
|
|
; Don't allow the boat to accelerate forever past max speed
|
|
set BaseBoatVelocity to BaseBoatVelocity + FrameRowForce
|
|
if (BaseBoatVelocity >= BoatMaxVelocity)
|
|
set BaseBoatVelocity to BoatMaxVelocity
|
|
endif
|
|
endif
|
|
|
|
if ((Rowing == 2 || AutoRowing == 2) && BoatMoving == 2 && BaseBoatVelocity > -BoatMaxVelocity)
|
|
; Don't allow the boat to accelerate backwards forever past max negative speed
|
|
set BaseBoatVelocity to BaseBoatVelocity - FrameRowForce
|
|
if (BaseBoatVelocity <= -BoatMaxVelocity)
|
|
set BaseBoatVelocity to -BoatMaxVelocity
|
|
endif
|
|
endif
|
|
|
|
if (RowTimer > 0)
|
|
set RowTimer to RowTimer - SecondsPassed
|
|
elseif (RowTimer <= 0 && Rowing > 0)
|
|
set Rowing to 0
|
|
endif
|
|
|
|
if (BoatMoving == 2 && PlayerDistance > OverboardDistance)
|
|
set Rowing to 0
|
|
set CurrentTurnRate to 0 ; immediately stop turning
|
|
set AutoRowing to 0
|
|
set LadderDeployed to 1
|
|
Ladder.Enable
|
|
set Resetting to 1
|
|
Message "You've gone overboard!"
|
|
endif
|
|
|
|
if (BoatMoving == 2 && CollisionDetectTimer > 0)
|
|
set CollisionDetectTimer to CollisionDetectTimer - SecondsPassed
|
|
elseif (BoatMoving == 2 && CollisionDetectTimer <= 0 && Collider.GetInSameCell Player && Collider.GetPos z > CollisionDetectZThreshold)
|
|
set ColliderActualX to Collider.GetPos x
|
|
set ColliderActualY to Collider.GetPos y
|
|
if (ColliderActualX > ColliderX - ColliderPosThreshold && ColliderActualX < ColliderX + ColliderPosThreshold && ColliderActualY > ColliderY - ColliderPosThreshold && ColliderActualY < ColliderY + ColliderPosThreshold)
|
|
if (RockingEnabled == 0)
|
|
set fQuestDelayTime to MediumUpdateRate
|
|
endif
|
|
SetStage RYB 21 ; Collision procedure
|
|
endif
|
|
elseif (BoatMoving == 2 && CollisionDetectTimer <= 0 && Collider.GetDead == 1)
|
|
; Moving the collider every frame seems to cause the collider to spontaneously die when near land. However, this
|
|
; also seems to have many false positives where it dies in open water. Instead of every frame, the script uses
|
|
; ColliderMoveTimer to move it every N seconds instead of every frame. The Collider doesn't seem to
|
|
; spontaneously die with this method, but I kept this here just in-case it ever does happen.
|
|
if (RockingEnabled == 0)
|
|
set fQuestDelayTime to MediumUpdateRate
|
|
endif
|
|
Collider.Resurrect 0
|
|
SetStage RYB 21 ; Collision procedure
|
|
endif
|
|
|
|
if (BoatMoving >= 1 && (Player.GetSitting != 0 && Player.GetSitting != 3))
|
|
; wait for player to sit/standup before continuing to move
|
|
Message "Pausing the boat until you get up."
|
|
return
|
|
endif
|
|
|
|
; Boat dragging. See visualization here: https://claude.ai/public/artifacts/23380c6b-c9a4-430d-bd86-781ae588739f
|
|
if (Dragging >= 1)
|
|
set PlayerX to Player.GetPos x
|
|
set PlayerY to Player.GetPos y
|
|
set PlayerZ to Player.GetPos z
|
|
SetStage RYB 11 ; Update boat position and angle
|
|
|
|
if (PlayerDistance > DragMaxPlayerDistance)
|
|
set Dragging to 0
|
|
Player.RemoveItem RYBBoatToken 1
|
|
if (RockingEnabled == 0)
|
|
set fQuestDelayTime to MediumUpdateRate
|
|
endif
|
|
set DragBoatVelocityX to 0
|
|
set DragBoatVelocityY to 0
|
|
Seat.SetDestroyed 0
|
|
BoatMarker.Enable
|
|
Message "You got too far from the boat and stopped dragging it."
|
|
endif
|
|
|
|
; Drag point is at center of boat
|
|
set DragPointX to BoatX
|
|
set DragPointY to BoatY
|
|
; Vector from rope attach point (center of boat) to player
|
|
set dX to PlayerX - DragPointX
|
|
set dY to PlayerY - DragPointY
|
|
|
|
; Save absolute values of dX and dY
|
|
if (dX < 0)
|
|
set dXAbs to -dX
|
|
else
|
|
set dXAbs to dX
|
|
endif
|
|
if (dY < 0)
|
|
set dYAbs to -dY
|
|
else
|
|
set dYAbs to dY
|
|
endif
|
|
|
|
if (dXAbs < 0.1 && dYAbs < 0.1)
|
|
; Player is very close to the drag point, so no need to calculate angle
|
|
set DragTargetAngle to BoatAngle
|
|
else
|
|
SetStage RYB 10 ; Calculate DragTargetAngle with atan2(dY, dX)
|
|
endif
|
|
|
|
; Calculate squared distance from player to drag point
|
|
set DragTautDistanceSquared to ((PlayerX - DragPointX) * (PlayerX - DragPointX)) + ((PlayerY - DragPointY) * (PlayerY - DragPointY))
|
|
|
|
; Only apply force if rope is taut (player far enough away)
|
|
if (DragTautDistanceSquared > (DragRopeLength * DragRopeLength))
|
|
; Get actual distance using Newton's method for square root (2 iterations is usually enough)
|
|
; See: https://cs.uesp.net/wiki/Square_Root
|
|
set PlayerMovementDistance to DragRopeLength + 50 ; Initial reasonable guess
|
|
; Iteration 1: x = (x + n/x) / 2
|
|
set PlayerMovementDistance to (PlayerMovementDistance + (DragTautDistanceSquared / PlayerMovementDistance)) / 2
|
|
; Iteration 2: x = (x + n/x) / 2
|
|
set PlayerMovementDistance to (PlayerMovementDistance + (DragTautDistanceSquared / PlayerMovementDistance)) / 2
|
|
|
|
; Calculate normalized direction from drag point to player
|
|
if (PlayerMovementDistance > 0)
|
|
set DragForceX to (PlayerX - DragPointX) / PlayerMovementDistance
|
|
set DragForceY to (PlayerY - DragPointY) / PlayerMovementDistance
|
|
|
|
; Apply pulling force based on how far beyond rope length we are
|
|
set DragSlackDistance to PlayerMovementDistance - DragRopeLength
|
|
|
|
; Instead of linear, use a dampened response
|
|
if (DragSlackDistance > 100)
|
|
; If very far, use logarithmic-like response to prevent extreme forces
|
|
set DragSlackDistance to 100 + (DragSlackDistance - 100) * 0.1
|
|
endif
|
|
|
|
set PlayerMovementForce to DragSlackDistance * DragPullStrength
|
|
|
|
if (PlayerMovementForce > DragMaxForce)
|
|
set PlayerMovementForce to DragMaxForce
|
|
endif
|
|
|
|
; Simple spring force: the further stretched, the stronger the pull
|
|
set DragForceX to DragForceX * PlayerMovementForce
|
|
set DragForceY to DragForceY * PlayerMovementForce
|
|
|
|
; Apply force to velocity
|
|
set DragBoatVelocityX to DragBoatVelocityX + (DragForceX * SmoothedDeltaTime / TargetDeltaTime)
|
|
set DragBoatVelocityY to DragBoatVelocityY + (DragForceY * SmoothedDeltaTime / TargetDeltaTime)
|
|
|
|
; Limit max velocity
|
|
set DragVelocitySquared to (DragBoatVelocityX * DragBoatVelocityX) + (DragBoatVelocityY * DragBoatVelocityY)
|
|
if (DragVelocitySquared > (DragMaxVelocity * DragMaxVelocity))
|
|
; Get actual velocity
|
|
set PlayerMovementDistance to DragMaxVelocity ; Start with max
|
|
set PlayerMovementDistance to (PlayerMovementDistance + (DragVelocitySquared / PlayerMovementDistance)) / 2
|
|
|
|
; Scale down to max velocity
|
|
set DragBoatVelocityX to DragBoatVelocityX * (DragMaxVelocity / PlayerMovementDistance)
|
|
set DragBoatVelocityY to DragBoatVelocityY * (DragMaxVelocity / PlayerMovementDistance)
|
|
endif
|
|
|
|
; Calculate angle difference to movement direction
|
|
set DragAngleDiff to DragTargetAngle - BoatAngle
|
|
|
|
if (DragAngleDiff > 180)
|
|
set DragAngleDiff to DragAngleDiff - 360
|
|
elseif (DragAngleDiff < -180)
|
|
set DragAngleDiff to DragAngleDiff + 360
|
|
endif
|
|
if (DragAngleDiff < DragTurnDeadzone && DragAngleDiff > -DragTurnDeadzone)
|
|
; Within deadzone - decay the turn rate
|
|
set DragCurrentTurnRate to DragCurrentTurnRate * DragTurnRateDeceleration
|
|
; Stop tiny movements
|
|
if (DragCurrentTurnRate > -0.01 && DragCurrentTurnRate < 0.01)
|
|
set DragCurrentTurnRate to 0
|
|
endif
|
|
else
|
|
; Outside deadzone - calculate target turn rate and ramp up toward it
|
|
set DragFrameTurnRate to DragAngleDiff * DragBaseTurnRate * (SmoothedDeltaTime / TargetDeltaTime)
|
|
if (DragFrameTurnRate > DragMaxTurnPerFrame)
|
|
set DragFrameTurnRate to DragMaxTurnPerFrame
|
|
elseif (DragFrameTurnRate < -DragMaxTurnPerFrame)
|
|
set DragFrameTurnRate to -DragMaxTurnPerFrame
|
|
endif
|
|
|
|
; Smoothly ramp up to target turn rate
|
|
set DragCurrentTurnRate to DragCurrentTurnRate + ((DragFrameTurnRate - DragCurrentTurnRate) * DragTurnRateAcceleration * SmoothedDeltaTime / TargetDeltaTime)
|
|
endif
|
|
|
|
set BoatAngle to BoatAngle + DragCurrentTurnRate
|
|
endif
|
|
endif
|
|
|
|
; Apply friction to velocity (always, even when not pulling)
|
|
set DragBoatVelocityX to DragBoatVelocityX * DragFriction
|
|
set DragBoatVelocityY to DragBoatVelocityY * DragFriction
|
|
|
|
; Update boat position based on velocity
|
|
set BoatX to BoatX + (DragBoatVelocityX * SmoothedDeltaTime / TargetDeltaTime)
|
|
set BoatY to BoatY + (DragBoatVelocityY * SmoothedDeltaTime / TargetDeltaTime)
|
|
|
|
; Only allow changing Z pos and pitch angle if rope is taut so the player can't ride the boat up into the air
|
|
; (not a plane mod yet ;D)
|
|
if (DragTautDistanceSquared > (DragRopeLength * DragRopeLength))
|
|
; Smoothly interpolate boat Z towards target
|
|
if (Player.IsSwimming == 1)
|
|
set DragPlayerBoatZDiff to PlayerZ - BoatZ
|
|
else
|
|
; Raise the boat up a bit when on land so it doesn't clip into the ground as much
|
|
set DragPlayerBoatZDiff to (PlayerZ + DragLandPlayerZOffset) - BoatZ
|
|
endif
|
|
|
|
; Calculate distance boat has traveled from start of path segment
|
|
set dX to PlayerX - DragPathStartX
|
|
set dY to PlayerY - DragPathStartY
|
|
set DragPathDistance to (dX * dX) + (dY * dY)
|
|
|
|
; If boat has moved enough, calculate the slope it traveled
|
|
if (DragPathDistance > (DragPathMinDistance * DragPathMinDistance))
|
|
; Get actual distance using Newton's method
|
|
set DragPathDistance to DragPathMinDistance ; Initial guess
|
|
set DragPathDistance to (DragPathDistance + ((dX * dX + dY * dY) / DragPathDistance)) / 2
|
|
set DragPathDistance to (DragPathDistance + ((dX * dX + dY * dY) / DragPathDistance)) / 2
|
|
|
|
; Calculate slope from player's actual path
|
|
set DragPathSlope to ((PlayerZ - DragPathStartZ) / DragPathDistance) * radToDeg * -DragPathSlopeFactor
|
|
|
|
; Apply deadzone to ignore tiny slopes
|
|
if (DragPathSlope > -DragPathSlopeDeadzone && DragPathSlope < DragPathSlopeDeadzone)
|
|
set DragPathSlope to 0
|
|
endif
|
|
|
|
; Clamp calculated slope to reasonable values
|
|
if (DragPathSlope > DragMaxPitchAngle)
|
|
set DragPathSlope to DragMaxPitchAngle
|
|
elseif (DragPathSlope < -DragMaxPitchAngle)
|
|
set DragPathSlope to -DragMaxPitchAngle
|
|
endif
|
|
|
|
; Start new path segment from current position
|
|
set DragPathStartX to PlayerX
|
|
set DragPathStartY to PlayerY
|
|
set DragPathStartZ to PlayerZ
|
|
endif
|
|
|
|
if (Player.IsSwimming == 1)
|
|
set DragTargetPitchAngle to 0 ; Reset pitch when swimming
|
|
else
|
|
; Only adjust pitch when boat is moving and player is not swimming
|
|
if (DragBoatVelocityX != 0 || DragBoatVelocityY != 0)
|
|
; Smoothly adjust target pitch toward the path slope
|
|
set DragTargetPitchAngle to DragTargetPitchAngle + ((DragPathSlope - DragTargetPitchAngle) * DragTargetPitchMovingSmoothingFactor)
|
|
else
|
|
; When stopped, very slowly tend toward path slope
|
|
set DragTargetPitchAngle to DragTargetPitchAngle + ((DragPathSlope - DragTargetPitchAngle) * DragTargetPitchStoppedSmoothingFactor)
|
|
endif
|
|
|
|
; Z adjustment based on pitch angle to prevent clipping going up and down hills
|
|
if (DragPlayerBoatZDiff >= 0)
|
|
; raise boat when player going downhill
|
|
set DragPlayerBoatZDiff to DragPlayerBoatZDiff + (DragTargetPitchAngle * DragDownhillZAdjustmentFactor)
|
|
else
|
|
; lower boat when player going uphill (DragTargetPitchAngle is negative)
|
|
set DragPlayerBoatZDiff to DragPlayerBoatZDiff + (DragTargetPitchAngle * DragUphillZAdjustmentFactor)
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
if (Dragging == 2 || DragTautDistanceSquared > (DragRopeLength * DragRopeLength))
|
|
set DragFrameBoatZAdjust to (DragPlayerBoatZDiff * DragZInterpolationRate * SmoothedDeltaTime / TargetDeltaTime)
|
|
if (Dragging == 2)
|
|
; This is a one-time adjustment, so remove this frame's adjustment from the total target adjustment
|
|
set DragPlayerBoatZDiff to DragPlayerBoatZDiff - DragFrameBoatZAdjust
|
|
if ((DragFrameBoatZAdjust > 0 && DragPlayerBoatZDiff <= 0) || (DragFrameBoatZAdjust < 0 && DragPlayerBoatZDiff > 0) || DragPlayerBoatZDiff == 0)
|
|
set Dragging to 1 ; target reached, proceed with normal dragging
|
|
endif
|
|
endif
|
|
|
|
; Prevent "boat becomes a missile" issue
|
|
if (DragFrameBoatZAdjust > DragMaxZPerFrame)
|
|
set DragFrameBoatZAdjust to DragMaxZPerFrame
|
|
elseif (DragFrameBoatZAdjust < -DragMaxZPerFrame)
|
|
set DragFrameBoatZAdjust to -DragMaxZPerFrame
|
|
endif
|
|
set BoatZ to BoatZ + DragFrameBoatZAdjust
|
|
endif
|
|
|
|
; Prevent boat from going below water level
|
|
if (BoatZ < (WaterLevelZ + 1))
|
|
set BoatZ to WaterLevelZ + 1
|
|
endif
|
|
|
|
; Stop tiny movements
|
|
if (DragBoatVelocityX > -0.1 && DragBoatVelocityX < 0.1)
|
|
set DragBoatVelocityX to 0
|
|
endif
|
|
if (DragBoatVelocityY > -0.1 && DragBoatVelocityY < 0.1)
|
|
set DragBoatVelocityY to 0
|
|
endif
|
|
endif
|
|
|
|
; Smooth the actual pitch angle toward target (outside the dragging check)
|
|
if (DragPitchAngle != DragTargetPitchAngle)
|
|
set DragPitchAngle to DragPitchAngle + ((DragTargetPitchAngle - DragPitchAngle) * DragPitchSmoothingFactor * SmoothedDeltaTime / TargetDeltaTime)
|
|
|
|
; Stop tiny movements
|
|
if (DragPitchAngle > -0.05 && DragPitchAngle < 0.05)
|
|
set DragPitchAngle to 0
|
|
endif
|
|
endif
|
|
|
|
; TODO: test if it's necessary to set these every update while moving.
|
|
; In theory, they only need to be set once at initialization since the boat is immovable beyond this script.
|
|
; (I want to see if resetting these fixes get on boat issues)
|
|
; Doesn't 100% fix it, but maybe it helps a bit? Not sure.
|
|
if (Summoning == 0 && Dragging == 0)
|
|
; During summoning and dragging these are preset so don't overwrite them
|
|
SetStage RYB 11 ; Update boat position and angle
|
|
endif
|
|
|
|
; Calculate player weight influence on boat pitch and roll
|
|
if (PlayerWeightEnabled == 1 && Summoning == 0 && Dragging == 0 && PlayerDistance < PlayerWeightMaxDistanceForward)
|
|
; Get player position
|
|
set PlayerX to Player.GetPos x
|
|
set PlayerY to Player.GetPos y
|
|
set PlayerZ to Player.GetPos z
|
|
|
|
; Calculate player position relative to boat center
|
|
set PlayerRelativeX to PlayerX - BoatX
|
|
set PlayerRelativeY to PlayerY - BoatY
|
|
|
|
; Calculate boat's forward and right vectors using BoatAngle directly
|
|
; Forward vector (bow direction): sin(BoatAngle), cos(BoatAngle)
|
|
; Right vector (starboard direction): cos(BoatAngle), -sin(BoatAngle)
|
|
; PlayerLocalY: positive = toward bow, negative = toward stern
|
|
set PlayerLocalY to PlayerRelativeX * sin + PlayerRelativeY * cos
|
|
; PlayerLocalX: positive = toward starboard, negative = toward port
|
|
set PlayerLocalX to PlayerRelativeX * cos - PlayerRelativeY * sin
|
|
set PlayerLocalZ to PlayerZ - BoatZWithRock
|
|
|
|
; Calculate distance from boat center for falloff effect
|
|
set PlayerDistanceFromCenter to PlayerRelativeX * PlayerRelativeX + PlayerRelativeY * PlayerRelativeY
|
|
; Newton's method square root approximation (2 iterations)
|
|
set PlayerDistanceFromCenter to PlayerWeightMaxDistanceForward ; Initial guess
|
|
set PlayerDistanceFromCenter to (PlayerDistanceFromCenter + ((PlayerRelativeX * PlayerRelativeX + PlayerRelativeY * PlayerRelativeY) / PlayerDistanceFromCenter)) / 2
|
|
set PlayerDistanceFromCenter to (PlayerDistanceFromCenter + ((PlayerRelativeX * PlayerRelativeX + PlayerRelativeY * PlayerRelativeY) / PlayerDistanceFromCenter)) / 2
|
|
|
|
; Calculate influence factor (1.0 at center, 0.0 at max distance)
|
|
; Limit effect area to a box approximately the area above the boat up 60 units (PlayerWeightMaxDistanceVertical)
|
|
if (PlayerDistanceFromCenter <= PlayerWeightMaxDistanceForward && PlayerLocalZ < PlayerWeightMaxDistanceVertical && PlayerLocalX < PlayerWeightMaxDistanceSide && PlayerLocalX > -PlayerWeightMaxDistanceSide)
|
|
set PlayerWeightInfluence to 1.0 - (PlayerDistanceFromCenter / PlayerWeightMaxDistanceForward)
|
|
else
|
|
set PlayerWeightInfluence to 0
|
|
endif
|
|
|
|
; Calculate target pitch offset based on player's fore/aft position
|
|
; Positive PlayerLocalY = toward bow (front) = boat should pitch forward (bow dips down)
|
|
; Negative PlayerLocalY = toward stern (back) = boat should pitch backward (stern dips down)
|
|
set TargetPlayerWeightPitchOffset to PlayerLocalY * PlayerWeightPitchFactor * PlayerWeightInfluence
|
|
|
|
; Calculate target roll offset based on player's port/starboard position
|
|
; Positive PlayerLocalX = toward starboard (right) = boat should roll starboard (startboard dips down)
|
|
; Negative PlayerLocalX = toward port (left) = boat should roll port (port dips down)
|
|
set TargetPlayerWeightRollOffset to -PlayerLocalX * PlayerWeightRollFactor * PlayerWeightInfluence
|
|
|
|
; Smooth the transition to prevent jarring movements
|
|
set PlayerWeightPitchOffset to PlayerWeightPitchOffset + ((TargetPlayerWeightPitchOffset - PlayerWeightPitchOffset) * PlayerWeightSmoothingFactor * SmoothedDeltaTime / TargetDeltaTime)
|
|
set PlayerWeightRollOffset to PlayerWeightRollOffset + ((TargetPlayerWeightRollOffset - PlayerWeightRollOffset) * PlayerWeightSmoothingFactor * SmoothedDeltaTime / TargetDeltaTime)
|
|
else
|
|
; Player not on boat or system disabled - gradually return to neutral
|
|
set PlayerWeightPitchOffset to PlayerWeightPitchOffset * (1 - PlayerWeightSmoothingFactor * SmoothedDeltaTime / TargetDeltaTime)
|
|
set PlayerWeightRollOffset to PlayerWeightRollOffset * (1 - PlayerWeightSmoothingFactor * SmoothedDeltaTime / TargetDeltaTime)
|
|
|
|
; Stop tiny movements
|
|
if (PlayerWeightPitchOffset > -0.01 && PlayerWeightPitchOffset < 0.01)
|
|
set PlayerWeightPitchOffset to 0
|
|
endif
|
|
if (PlayerWeightRollOffset > -0.01 && PlayerWeightRollOffset < 0.01)
|
|
set PlayerWeightRollOffset to 0
|
|
endif
|
|
endif
|
|
|
|
if (BoatMoving >= 1 || Dragging >= 1 || Resetting >= 1)
|
|
; Speed values assume a frame rate of 60fps so readjust speed values to current frame rate
|
|
set FrameBoatVelocity to BaseBoatVelocity * (SmoothedDeltaTime / TargetDeltaTime)
|
|
|
|
; Calculate new boat angle. Script originally by Jason1
|
|
set PlayerAngle to Player.GetAngle z
|
|
if (PlayerAngle < 0)
|
|
set PlayerAngle to PlayerAngle + 360
|
|
elseif (PlayerAngle >= 360)
|
|
set PlayerAngle to PlayerAngle - 360
|
|
endif
|
|
|
|
if (BoatMoving >= 1 && Dragging == 0 && Summoning == 0 && LockHeading == 0)
|
|
set Diff to PlayerAngle - BoatAngle
|
|
|
|
; Calculate velocity-based turn modifier to make boats turn slower when moving slowly for realism
|
|
if (BaseBoatVelocity < 0)
|
|
set AbsoluteBoatVelocity to -BaseBoatVelocity
|
|
else
|
|
set AbsoluteBoatVelocity to BaseBoatVelocity
|
|
endif
|
|
|
|
; Turn rate scales with velocity (0.3 to 1.0 multiplier)
|
|
set TurnRateVelocityFactor to 0.3 + (0.7 * (AbsoluteBoatVelocity / BoatMaxVelocity))
|
|
if (TurnRateVelocityFactor > 1.0)
|
|
set TurnRateVelocityFactor to 1.0
|
|
endif
|
|
|
|
set FrameTurnRate to BaseTurnRate * TurnRateVelocityFactor * (SmoothedDeltaTime / TargetDeltaTime)
|
|
|
|
if ((Diff > 1 || Diff < -1) && (Diff > TurnDeadzone || Diff < -TurnDeadzone))
|
|
; Player is currently turning, ramp up turn rate
|
|
set CurrentTurnRate to CurrentTurnRate + ((FrameTurnRate - CurrentTurnRate) * TurnRateAcceleration * SmoothedDeltaTime / TargetDeltaTime)
|
|
else
|
|
; Player not turning, decay the turn rate
|
|
set CurrentTurnRate to CurrentTurnRate * TurnRateDeceleration
|
|
; Stop tiny movements
|
|
if (CurrentTurnRate > -0.05 && CurrentTurnRate < 0.05)
|
|
set CurrentTurnRate to 0
|
|
endif
|
|
endif
|
|
|
|
if (CurrentTurnRate != 0 && (Diff > 1 || Diff < -1))
|
|
if (PlayerAngle > 180)
|
|
set Hemi to PlayerAngle - 180
|
|
else
|
|
set Hemi to PlayerAngle + 180
|
|
endif
|
|
if (Hemi < 0)
|
|
set Hemi to Hemi + 360
|
|
elseif (Hemi >= 360)
|
|
set Hemi to Hemi - 360
|
|
endif
|
|
if (PlayerAngle > Hemi)
|
|
if (BoatAngle > Hemi && BoatAngle < PlayerAngle)
|
|
set BoatAngle to BoatAngle + CurrentTurnRate
|
|
else
|
|
set BoatAngle to BoatAngle - CurrentTurnRate
|
|
endif
|
|
else
|
|
if (BoatAngle < Hemi && BoatAngle > PlayerAngle)
|
|
set BoatAngle to BoatAngle - CurrentTurnRate
|
|
else
|
|
set BoatAngle to BoatAngle + CurrentTurnRate
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
if (BoatAngle < 0)
|
|
set BoatAngle to BoatAngle + 360
|
|
elseif (BoatAngle >= 360)
|
|
set BoatAngle to BoatAngle - 360
|
|
endif
|
|
else
|
|
; Player not turning - decay the turn rate
|
|
set CurrentTurnRate to CurrentTurnRate * TurnRateDeceleration
|
|
; Stop tiny movements
|
|
if (CurrentTurnRate > -0.05 && CurrentTurnRate < 0.05)
|
|
set CurrentTurnRate to 0
|
|
endif
|
|
endif
|
|
|
|
; Adjust for model alignment (boat model is rotated 90 degrees)
|
|
set BoatModelAngle to BoatAngle + 90
|
|
if (BoatModelAngle < 0)
|
|
set BoatModelAngle to BoatModelAngle + 360
|
|
elseif (BoatModelAngle >= 360)
|
|
set BoatModelAngle to BoatModelAngle - 360
|
|
endif
|
|
|
|
set BoatX to BoatX + (sin * FrameBoatVelocity)
|
|
set BoatY to BoatY + (cos * FrameBoatVelocity)
|
|
if (BoatMoving >= 1 && Dragging == 0 && OnLand == 0 && BoatZ != (WaterLevelZ + 1))
|
|
set BoatZ to WaterLevelZ + 1 ; if boat started moving above water, reset it to water level
|
|
endif
|
|
set BoatZWithRock to BoatZ + RockZOffset
|
|
if (Resetting != 2)
|
|
BoatRef.MoveTo Player
|
|
endif
|
|
BoatRef.SetPos x, BoatX
|
|
BoatRef.SetPos y, BoatY
|
|
BoatRef.SetPos z, BoatZWithRock
|
|
BoatRef.SetAngle z, BoatModelAngle
|
|
BoatRef.SetAngle x, BoatPitchAngle
|
|
BoatRef.SetAngle y, BoatRollAngle
|
|
endif
|
|
|
|
if (BoatZ > LandZThreshold)
|
|
set OnLand to 1
|
|
else
|
|
set OnLand to 0
|
|
endif
|
|
|
|
; Boat rocking animation
|
|
if (RockingEnabled == 1 && Dragging == 0 && Summoning == 0 && Grounded == 0 && OnLand == 0 && PlayerNearBoat == 1)
|
|
; Update random variation
|
|
if (RockRandomTimer <= 0)
|
|
set RockRandomTimer to RockRandomInterval
|
|
; Add some random variation to make it look natural
|
|
set RockRandomPhase to (GetRandomPercent - 50) * 0.02
|
|
else
|
|
set RockRandomTimer to RockRandomTimer - SecondsPassed
|
|
endif
|
|
|
|
; Update rocking phases
|
|
set RockPhase to RockPhase + (RockFrequency * SecondsPassed)
|
|
if (RockPhase >= 360)
|
|
set RockPhase to RockPhase - 360
|
|
endif
|
|
|
|
set RockPhase2 to RockPhase2 + (RockFrequency2 * SecondsPassed)
|
|
if (RockPhase2 >= 360)
|
|
set RockPhase2 to RockPhase2 - 360
|
|
endif
|
|
|
|
set RockPhase3 to RockPhase3 + (RockFrequency3 * SecondsPassed)
|
|
if (RockPhase3 >= 360)
|
|
set RockPhase3 to RockPhase3 - 360
|
|
endif
|
|
|
|
SetStage RYB 15 ; Calculate sine for primary rocking (Z movement and pitch)
|
|
SetStage RYB 16 ; Calculate sine for secondary rocking
|
|
SetStage RYB 17 ; Calculate sine and cosine for roll motion
|
|
|
|
; Calculate rocking offsets
|
|
; Z movement: combine multiple sine waves
|
|
set TargetRockZOffset to RockAmplitudeZ * (rockSin * 0.7 + rockSin2 * 0.3 + RockRandomPhase)
|
|
|
|
; Pitch (X rotation): boat tips forward/backward
|
|
set TargetRockPitchOffset to RockAmplitudePitch * (rockSin * 0.8 + rockSin2 * 0.2) + PlayerWeightPitchOffset
|
|
|
|
; Roll (Y rotation): boat tips side to side, offset by 90 degrees using cosine
|
|
set TargetRockRollOffset to RockAmplitudeRoll * (rockCos3 * 0.7 + rockSin2 * 0.3) + PlayerWeightRollOffset
|
|
|
|
; Adjust for boat speed (more rocking when moving)
|
|
if (BoatMoving >= 1)
|
|
if (BaseBoatVelocity < 0)
|
|
set AbsoluteBoatVelocity to -BaseBoatVelocity
|
|
else
|
|
set AbsoluteBoatVelocity to BaseBoatVelocity
|
|
endif
|
|
; Increase rocking amplitude based on speed
|
|
set TargetRockZOffset to TargetRockZOffset * (1 + (AbsoluteBoatVelocity / BoatMaxVelocity) * RockSpeedFactor)
|
|
set TargetRockPitchOffset to TargetRockPitchOffset * (1 + (AbsoluteBoatVelocity / BoatMaxVelocity) * RockSpeedFactor * 1.5)
|
|
set TargetRockRollOffset to TargetRockRollOffset * (1 + (AbsoluteBoatVelocity / BoatMaxVelocity) * RockSpeedFactor * 0.7)
|
|
endif
|
|
|
|
; Apply weather factor (based on wind speed)
|
|
set WindSpeed to GetWindSpeed
|
|
set TargetRockZOffset to TargetRockZOffset * (1 + (WindSpeed * RockWeatherFactor))
|
|
; Limit extreme Z offsets that would mess with boat-in-water detection
|
|
if (BoatZ + TargetRockZOffset < -RockMaxAbsoluteZ)
|
|
set TargetRockZOffset to -RockMaxAbsoluteZ - BoatZ
|
|
elseif (BoatZ + TargetRockZOffset > RockMaxAbsoluteZ)
|
|
set TargetRockZOffset to RockMaxAbsoluteZ - BoatZ
|
|
endif
|
|
set TargetRockPitchOffset to TargetRockPitchOffset * (1 + (WindSpeed * RockWeatherFactor))
|
|
set TargetRockRollOffset to TargetRockRollOffset * (1 + (WindSpeed * RockWeatherFactor))
|
|
|
|
; Smooth out the rocking effects so it doesn't snap into rocking position on boat launch
|
|
set RockZOffset to RockZOffset + ((TargetRockZOffset - RockZOffset) * RockSmoothingFactor * SmoothedDeltaTime / TargetDeltaTime)
|
|
set RockPitchOffset to RockPitchOffset + ((TargetRockPitchOffset - RockPitchOffset) * RockSmoothingFactor * SmoothedDeltaTime / TargetDeltaTime)
|
|
set RockRollOffset to RockRollOffset + ((TargetRockRollOffset - RockRollOffset) * RockSmoothingFactor * SmoothedDeltaTime / TargetDeltaTime)
|
|
else
|
|
; Dampen rocking when conditions aren't met
|
|
set RockZOffset to RockZOffset * (1 - RockSmoothingFactor * SmoothedDeltaTime / TargetDeltaTime)
|
|
set RockPitchOffset to RockPitchOffset * (1 - RockSmoothingFactor * SmoothedDeltaTime / TargetDeltaTime)
|
|
set RockRollOffset to RockRollOffset * (1 - RockSmoothingFactor * SmoothedDeltaTime / TargetDeltaTime)
|
|
|
|
; Stop tiny movements
|
|
if (RockZOffset > -0.01 && RockZOffset < 0.01)
|
|
set RockZOffset to 0
|
|
endif
|
|
if (RockPitchOffset > -0.01 && RockPitchOffset < 0.01)
|
|
set RockPitchOffset to 0
|
|
endif
|
|
if (RockRollOffset > -0.01 && RockRollOffset < 0.01)
|
|
set RockRollOffset to 0
|
|
endif
|
|
endif
|
|
|
|
if (BoatMoving >= 1 || Dragging >= 1 || Resetting >= 1 || (PlayerNearBoat == 1 && (RockZOffset != 0 || RockPitchOffset != 0 || RockRollOffset != 0)))
|
|
set ang to BoatAngle
|
|
SetStage RYB 12 ; Calculate sin, cos, & tan for boat angle
|
|
endif
|
|
|
|
if (BoatMoving >= 1 || Dragging >= 1 || Resetting >= 1 || (PlayerNearBoat == 1 && (RockZOffset != 0 || RockPitchOffset != 0 || RockRollOffset != 0)))
|
|
; Transform world pitch/roll to boat's local pitch/roll
|
|
set BoatPitchAngle to (RockPitchOffset + DragPitchAngle) * cos + RockRollOffset * sin
|
|
set BoatRollAngle to -(RockPitchOffset + DragPitchAngle) * sin + RockRollOffset * cos
|
|
|
|
; Calculate sine/cosine for the transformed angles
|
|
if (BoatPitchAngle != 0)
|
|
SetStage RYB 13 ; Calculate sin, cos for pitch
|
|
else
|
|
set SinPitch to 0
|
|
set CosPitch to 1
|
|
endif
|
|
if (BoatRollAngle != 0)
|
|
SetStage RYB 14 ; Calculate sin, cos for roll
|
|
else
|
|
set SinRoll to 0
|
|
set CosRoll to 1
|
|
endif
|
|
endif
|
|
|
|
if (BoatMoving >= 1 || Dragging >= 1 || Resetting >= 1)
|
|
set BoatMarkerZ to BoatZWithRock + BoatMarkerZOffset
|
|
if (Resetting == 2)
|
|
BoatMarker.MoveTo BoatRef
|
|
else
|
|
BoatMarker.MoveTo Player
|
|
endif
|
|
BoatMarker.SetPos x, BoatX
|
|
BoatMarker.SetPos y, BoatY
|
|
BoatMarker.SetPos z, BoatMarkerZ
|
|
|
|
if (BoatMoving >= 1)
|
|
if (FrameBoatVelocity > 0)
|
|
set ColliderX to BoatX + (sin * ColliderOffset)
|
|
set ColliderY to BoatY + (cos * ColliderOffset)
|
|
else
|
|
set ColliderX to BoatX - (sin * ColliderOffsetReverse)
|
|
set ColliderY to BoatY - (cos * ColliderOffsetReverse)
|
|
endif
|
|
|
|
if (ColliderMoveTimer > 0)
|
|
Set ColliderMoveTimer to ColliderMoveTimer - SecondsPassed
|
|
else
|
|
SetStage RYB 20 ; Enable and position collider
|
|
Set ColliderMoveTimer to ColliderMoveFreq
|
|
endif
|
|
endif
|
|
elseif (BoatMoving == 0 && Dragging == 0 && Summoning == 0 && (PlayerNearBoat == 1 && (RockZOffset != 0 || RockPitchOffset != 0 || RockRollOffset != 0)))
|
|
; Apply rocking to stationary boat.
|
|
set BoatZWithRock to BoatZ + RockZOffset
|
|
|
|
BoatRef.SetPos z, BoatZWithRock
|
|
BoatRef.SetAngle x, BoatPitchAngle
|
|
BoatRef.SetAngle y, BoatRollAngle
|
|
|
|
set BoatMarkerZ to BoatZWithRock + BoatMarkerZOffset
|
|
BoatMarker.SetPos z, BoatMarkerZ
|
|
endif
|
|
|
|
; Update attachments (seat, chest, lamp, ladder) positions and angles both while moving and stationary (if rocking)
|
|
if (BoatMoving >= 1 || Dragging >= 1 || Resetting >= 1 || (BoatMoving == 0 && Dragging == 0 && (PlayerNearBoat == 1 && (RockZOffset != 0 || RockPitchOffset != 0 || RockRollOffset != 0))))
|
|
SetStage RYB 30 ; Calculate seat position and angle
|
|
SetStage RYB 40 ; Update seat position and angle
|
|
|
|
if (ChestPurchased == 1)
|
|
SetStage RYB 31 ; Calculate chest position and angle
|
|
SetStage RYB 41 ; Update chest position and angle
|
|
endif
|
|
|
|
if (LampPurchased == 1)
|
|
SetStage RYB 32 ; Calculate lamp(s) position and angle
|
|
SetStage RYB 42 ; Update lamp(s) position and angle
|
|
endif
|
|
|
|
if (LadderPurchased == 1 && LadderDeployed == 1)
|
|
SetStage RYB 33 ; Calculate ladder position and angle
|
|
SetStage RYB 43 ; Update ladder position and angle
|
|
endif
|
|
endif
|
|
|
|
if (BoatMoving == 1)
|
|
set BoatMoving to 2 ; boat is now fully in motion
|
|
endif
|
|
if (Resetting >= 1)
|
|
set Resetting to 0
|
|
endif
|
|
end |