Initial commit

.svn/pristine/e1/e162356a43cb331350d1edc063a5b6e79bb50f8e.svn-base

@@ -0,0 +1,353 @@
+extends CharacterBody3D
+class_name PlayerCharacter
+
+var aceleration: float = 4.32 #Current aceleration
+var maxSpeed: float = 6.2 #Maximum Speed
+var sprintSpeed: float = 3.34 #Additional Speed gained while Sprinting
+var slowdownSpeedLimit: float = 0.8 #How fast the player can go when slowed
+var gear: String = "neutral" #Weather the player is going forward, backward or standing still
+var isMoving: bool = false
+var slowed: bool = false
+
+var momentum: float = 0
+var newMoveDirection: Vector3 = Vector3(0,0,0)
+var moveDirection: Vector3 = Vector3(0,0,0)
+var deceleration: float = 5.56
+
+var turnSpeed: float = PI #Speed at wich body turn sideways
+var handling: float = 0.67
+var facingDirection = Vector2(0,1) #Where the legs are facing
+var sprinting = false #While Player is sprinting
+var sprintEnergy: float = 100 #Energy used for Sprinting
+var sprintEnergyInitialUse: float = 4.5 #How much % sprint energy is used immediatly when initiating a sprint
+var sprintEnergyUse: float = 17.5 #How much % energy is used per 1 sec of sprint
+var sprintEnergyGain: float = 30 #How much % energy is gained per 1 sec of recovery
+
+var maxDriftAngle = 0.12 #Quaternion(0,0,0.06,0.998).normalized() #How much the playesr turns to the side while drifting (radians)
+var rightLeftLean: float = 0.0 #How much the player leans right or left from -1 to 1 with negative numbers being left and 0 being no lean
+
+var currentControlState: int = 0
+enum controls {DEFAULT,STANDARD_MINIGAME}
+
+var health: float = 100.0
+var invoulnerable: bool = false
+var alive: bool = true
+
+@onready var camera: Camera3D = $CameraPivot/Camera3D
+@onready var cameraPivot: Marker3D = $CameraPivot
+
+@onready var flashlight: SpotLight3D = $CameraPivot/Camera3D/flashlight
+
+
+@onready var backlightR := $pivot/BodyPivot/body/BacklightR
+@onready var backlightL := $pivot/BodyPivot/body/BacklightL
+
+@onready var pivot: = $pivot
+@onready var headPivot: = $pivot/HeadBinoculars/HeadPivot
+@onready var headBinoculars: = $pivot/HeadBinoculars
+@onready var legs := $pivot/BodyPivot/CaterpillarLegs
+@onready var body: = $pivot/BodyPivot/body
+
+@onready var hud = $/root/Main/Hud
+@onready var interactCross :=  $/root/Main/Hud/InteractCross
+@onready var sprintBar := $/root/Main/Hud/TextureProgressBar
+
+@onready var grabRaycast: = $CameraPivot/Camera3D/GrabDetector
+@onready var grabPivot: = $pivot/BodyPivot/body/GrabPivot
+@onready var grabBox: = $pivot/BodyPivot/body/GrabBox
+var grabbedObject: GrabableObject
+
+@onready var interactRaycast = $CameraPivot/Camera3D/InteractDetector
+@onready var VoiceChat = $VoiceChat
+
+@onready var bodyPivot: Node3D = $pivot/BodyPivot
+var mouseSensetivity := 0.1 #How much mouse movement affects ingame camera movement
+
+var spectatorScene: PackedScene = preload("res://actors/Player/Spectator.tscn")
+var spectatorParent: Node3D
+
+var mapLogic: MapLogic
+
+#Camera Shake Stuff 
+var traumaReductionRate:float = 0.34
+var trauma: float = 0
+@export var maxX = 12
+@export var maxY = 12
+@export var maxZ = 7
+@export var shakeIntensety : float = 7.0
+var time: float = 0
+@export var noise: Noise
+var noiseSpeed: float = 50
+var initialRotation = rotation_degrees as Vector3
+# Camera Shake Stuff end
+
+func _enter_tree() -> void:
+	set_multiplayer_authority(name.to_int())
+	if is_multiplayer_authority():
+		$CameraPivot/Camera3D.make_current()
+		$pivot/HeadBinoculars.hide()
+		$/root/Main/Hud/TextureProgressBar.show()
+
+func _ready() -> void:
+	Multiplayer.player_ready.emit(int(name))
+	Input.mouse_mode = Input.MOUSE_MODE_CAPTURED
+	mapLogic = Multiplayer.currentMapLogic
+	spectatorParent = get_node("/root/Main/Spectators")
+	if mapLogic:
+		mapLogic.onCollision.connect(onCollision)
+	if is_multiplayer_authority():
+		position.y += 2
+		return
+
+func _process(delta: float) -> void:
+	if not is_multiplayer_authority(): return
+	if not alive: return
+	
+	if invoulnerable and trauma == 0.0:
+		invoulnerable = false
+	
+	if Input.is_action_just_pressed("debug"): ##Debug
+		die()
+	
+	match currentControlState:
+		controls.DEFAULT:
+			regularControlsIdle(delta)
+		controls.STANDARD_MINIGAME:
+			standardMinigameControlsIdle(delta)
+	
+
+func _physics_process(delta: float) -> void:
+	if not is_multiplayer_authority(): return
+	if not alive: return
+	
+	match currentControlState:
+		controls.DEFAULT:
+			regularControlsPhysics(delta)
+		controls.STANDARD_MINIGAME:
+			endOfPhysicsCleanup(delta)
+
+func standardMinigameControlsIdle(_delta:float):
+	if Input.is_action_just_pressed("moveDown") or Input.is_action_just_pressed("interact"):
+		currentControlState = controls.DEFAULT
+
+func regularControlsIdle(_delta:float):
+	#Interacting Logic
+	var InteractCollider: InteractBox = interactRaycast.get_collider()
+	
+	if InteractCollider and Input.is_action_just_pressed("interact"):
+		InteractCollider.playerRef = self
+		InteractCollider.interact()
+		if InteractCollider.type == "minigame":
+			currentControlState = controls.STANDARD_MINIGAME
+			momentum = 0
+	
+	#Grabbing Logic
+	var GrabCollider: GrabBox = grabRaycast.get_collider()
+	var grabBoxCollider: Array[Area3D] = grabBox.get_overlapping_areas()
+	
+	
+	if(grabBoxCollider and Input.is_action_just_pressed("interact") and !grabbedObject):
+		if grabBoxCollider.has(GrabCollider): #If the player is looking at an object and it is in the grab box
+			grabbedObject = GrabCollider.grab()
+		else:
+			#If the player is not looking at an object, grab the closet one in the grab box
+			var closestObj: GrabBox
+			var distanceToClosestObj: float = 100
+			for grabObj in grabBoxCollider:
+				if (getDistance(self,grabObj) < distanceToClosestObj):
+					closestObj = grabObj
+					distanceToClosestObj = getDistance(self, grabObj)
+			grabbedObject = closestObj.grab()
+	
+	if InteractCollider or grabBoxCollider:
+		interactCross.show()
+	else:
+		interactCross.hide()
+	
+	if Input.is_action_just_pressed("flashlight"):
+		flashlight.visible = !flashlight.visible
+	
+	if grabbedObject:
+		grabbedObject.global_position = grabPivot.global_position# + grabbedObject.grabPositionPositionOffset
+		grabbedObject.rotation = grabPivot.global_rotation + grabbedObject.grabPositionRotationOffset
+		if grabbedObject.grabBox.heavy: slowed = true
+		if Input.is_action_just_pressed("drop"):
+			grabbedObject.release.rpc()
+			grabbedObject = null
+			slowed = false
+			momentum = 0
+		
+		if Input.is_action_just_pressed("throw"):
+			grabbedObject.release.rpc()
+			grabbedObject.throw.rpc_id(1,facingDirection.x,facingDirection.y,camera.rotation.x)
+			grabbedObject = null
+			slowed = false
+			momentum = 0
+
+func regularControlsPhysics(delta: float):
+	isMoving = false
+	
+	#Drain energy on sprint start to prevent the player from pressing sprint every other frame to get infinity energy
+	if Input.is_action_just_pressed("Sprint"):
+		sprintEnergy = clamp(sprintEnergy - sprintEnergyInitialUse, -(sprintEnergyInitialUse*2) , 100)
+	
+	# Rest of sprint energy logic
+	if Input.is_action_pressed("Sprint"):
+		sprintEnergy = clamp(sprintEnergy - sprintEnergyUse * delta, 0 , 100) # Drain sprint when holding the button
+		
+		if sprintEnergy > 0:
+			sprinting = true
+		else:
+			sprinting = false
+		
+	else:
+		sprinting = false
+		sprintEnergy = clamp(sprintEnergy + sprintEnergyGain * delta, -(sprintEnergyInitialUse*2) , 100) # Gain sprint when not holding the button
+	
+	
+	if not is_on_floor(): velocity += get_gravity()
+	
+	newMoveDirection = Vector3(0,0,0)
+	
+	# Set moveDirection based on input
+	if Input.is_action_pressed("moveUp") and !Input.is_action_pressed("moveDown"):
+		isMoving = true
+		newMoveDirection += Vector3(facingDirection.x,0,facingDirection.y)
+	if Input.is_action_pressed("moveRight") and !Input.is_action_pressed("moveLeft"):
+		isMoving = true
+		newMoveDirection -= Vector3(facingDirection.x,0,facingDirection.y).rotated(up_direction,PI/2)
+	if Input.is_action_pressed("moveLeft") and !Input.is_action_pressed("moveRight"):
+		isMoving = true
+		newMoveDirection += Vector3(facingDirection.x,0,facingDirection.y).rotated(up_direction,PI/2)
+	if Input.is_action_pressed("moveDown") and !Input.is_action_pressed("moveUp"):
+		isMoving = true
+		newMoveDirection += Vector3(facingDirection.x,0,facingDirection.y)
+		showBacklights()
+	else:
+		hideBacklights()
+	
+	
+	if newMoveDirection != Vector3(0,0,0):
+		moveDirection = clampVectorLength(moveDirection + newMoveDirection*delta,0,handling) 
+	
+	
+	endOfPhysicsCleanup(delta)
+	
+	#Momentum stuff
+	if isMoving:
+		if Input.is_action_pressed("moveDown"):
+			momentum = clamp(momentum + -aceleration*2 * delta,-maxSpeed/2,maxSpeed)
+		else:
+			momentum = clamp(momentum + aceleration * delta,-maxSpeed/2,maxSpeed)
+	else:
+		if momentum >= 0:
+			momentum = clamp(momentum - deceleration * delta,-maxSpeed/2,maxSpeed)
+		if momentum < 0:
+			momentum = clamp(momentum + deceleration * delta,-maxSpeed/2,maxSpeed)
+	
+	if sprinting and isMoving and !Input.is_action_pressed("moveDown"):
+		velocity = clampVectorLength(moveDirection.normalized() * (momentum + sprintSpeed),0,maxSpeed+sprintSpeed)
+	else:
+		velocity = clampVectorLength(moveDirection.normalized() * momentum,0,maxSpeed)
+	
+	bodyPivot.rotation.y = rotate_toward(bodyPivot.rotation.y, -atan2(moveDirection.z,moveDirection.x) + PI/2,delta*turnSpeed)
+	#print(facingDirection.length())
+	move_and_slide() #applies movement
+
+func endOfPhysicsCleanup(delta: float):
+	trauma = max(trauma-delta*traumaReductionRate,0)
+	time += delta
+	rotation_degrees.x = initialRotation.x + maxX * getShakeIntensity() * getNoiseFromSeed(343)
+	rotation_degrees.y = initialRotation.y + maxY * getShakeIntensity() * getNoiseFromSeed(123)
+	rotation_degrees.z = initialRotation.z + maxZ * getShakeIntensity() * getNoiseFromSeed(234)
+	#Rotate head based on camera movement
+	headPivot.rotation.y = cameraPivot.rotation.y
+	headPivot.rotation.x = -camera.rotation.x
+	if trauma == 0.0:
+		headPivot.rotation.z = 0.0
+		headBinoculars.rotation.z = 0.0
+	sprintBar.value = sprintEnergy
+	
+
+func showBacklights() -> void:
+	backlightL.show()
+	backlightR.show()
+
+func hideBacklights() -> void:
+	backlightL.hide()
+	backlightR.hide()
+
+
+
+
+func useSprintEnergy(delta: float):
+	sprintEnergy = clamp(sprintEnergy - sprintEnergyUse * delta, 0, 100)
+
+func setRightLeftLean(direction: int, strength: float, delta: float) -> void:
+	if direction > 0 and rightLeftLean < 0:
+		rightLeftLean = 0
+	elif direction < 0 and rightLeftLean > 0:
+		rightLeftLean = 0
+	rightLeftLean = clamp(rightLeftLean + strength * delta * direction,-1,1) 
+
+func getAngleBetweenVectors(a: Vector3, b: Vector3) -> float:
+	if a.length() == 0 or b. length() == 0:
+		return 0
+	return acos((a.dot(b)/(a.length()*b.length())))
+
+func getDistance(a: Node3D, b: Node3D) -> float:
+	var distanceVector: Vector3
+	distanceVector = b.global_position - a.global_position
+	return distanceVector.length()
+
+func clampVectorLength(Vector: Vector3, minLength: float, maxLength: float) -> Vector3:
+	#scales Vector up/ down to the max/ min length givin. If the Vector has a length of 0 it will be returned without being scaled.
+	if Vector.length() == 0: return Vector
+	if Vector.length() < minLength:
+		return Vector * minLength / Vector.length()
+	elif Vector.length() > maxLength:
+		return Vector * maxLength / Vector.length()
+	return Vector
+
+func onCollision() -> void:
+	trauma = 1
+
+func addTrauma(traumaAmount: float):
+	trauma = clamp(trauma+traumaAmount,0,1)
+
+func getShakeIntensity() -> float:
+	return shakeIntensety * trauma * trauma
+
+func getNoiseFromSeed(seed_: int) -> float:
+	noise.seed = seed_
+	return noise.get_noise_1d(time*noiseSpeed)
+
+func _input(event: InputEvent) -> void: #Camera movement with mouse
+	if event is InputEventMouseMotion && Input.mouse_mode == 2:
+		camera.rotation.x -= clamp(deg_to_rad(event.relative.y * mouseSensetivity),-180,180)
+		cameraPivot.rotation.y -= deg_to_rad(event.relative.x * mouseSensetivity)
+		facingDirection = facingDirection.rotated(deg_to_rad(event.relative.x * mouseSensetivity))
+		
+		camera.rotation_degrees.x = clamp(camera.rotation_degrees.x, -70, 70)
+		cameraPivot.rotation.z = 0
+
+func _on_hurt_box_hit_taken(attack: Attack) -> void:
+	if invoulnerable: return
+	
+	trauma = attack.trauma
+	health -= attack.damage
+	if health <= 0.0:
+		die()
+	invoulnerable = true
+
+func die() -> void:
+	Multiplayer.alivePlayerDict.erase(int(name))
+	headBinoculars.show()
+	headPivot.position = Vector3(0,0.382,0.063)
+	headPivot.rotation = Vector3(0,0,0)
+	$"pivot/pivotRightLeg/pivotLeftLeg/body/Grabby Arms_L".rotation.x = deg_to_rad(90) 
+	$"pivot/pivotRightLeg/pivotLeftLeg/body/Grabby Arms_R".rotation.x = deg_to_rad(90)
+	var spectator = spectatorScene.instantiate()
+	spectatorParent.add_child(spectator)
+	camera.current = false
+	alive = false

.svn/pristine/e1/e16b4518f631281e4a94bbf56f3fbd2d94bb43b8.svn-base

@@ -0,0 +1 @@
+uid://b4avd5n3wv18p

.svn/pristine/e1/e1ae3067c1f0c56adbbbe06ee2ff5d03530c111f.svn-base

@@ -0,0 +1,88 @@
+extends Node3D
+class_name PathfindingGridLoader
+
+var loading: bool = false # when this is true the grid starts loading
+var loading_done: bool = false # when the grid is loaded, this becomes true
+
+@export var height: float= 0.2 ##Choose a height that is just above the floor
+@export var lengthX: int = 50 ##How far the grid generates in the x direction, generates as a rectangle 
+@export var lengthZ: int = 50 ##How far the grid generates in the z direction, generates as a rectangle 
+@export var point_density: float = 0.75 ##How many points per unit of grid, cannot be = 0 
+@export var minimum_connections_per_point: int = 3
+
+var astar: AStar2D = AStar2D.new()
+
+func _physics_process(_delta: float) -> void:
+	if loading == false: return
+	if loading_done == true: return
+	generatePoints()
+	connectPointsToNeighbors()
+	killPointsWithoutFriends(minimum_connections_per_point)
+	addWeightToPoints()
+	loading = false
+	loading_done = true
+
+func loadGrid() -> void:
+	loading = true
+
+func castRay(startPoint:Vector3,endPoint: Vector3,collisionMask:int = 0xFFFFFFFF,hitFromInside: bool = true) -> bool: ##Returns true if the ray collides and false if it doesn't
+	var space_state = get_world_3d().direct_space_state
+	var rayQueryParam = PhysicsRayQueryParameters3D.create(startPoint,endPoint)
+	rayQueryParam.collision_mask = collisionMask
+	rayQueryParam.hit_from_inside = hitFromInside
+	return space_state.intersect_ray(rayQueryParam).size()
+
+func checkPoint(point: Vector2) -> bool: ## only ever call this from physics process as it uses physics for raycast and may not work on idle callback
+	var floorDetected: bool = castRay(Vector3(point.x,height,point.y),Vector3(point.x,-(height*1.5),point.y)) #Walls are on layer 3 (0b1000)
+	var wallDetected: bool = castRay(Vector3(point.x,height,point.y),Vector3(point.x,-(height*1.5),point.y),0b100)
+	if !wallDetected && floorDetected:
+		return true
+	else:
+		return false
+
+func getPointsInRadius(origin: Vector2,radius: float, maxPoints: int = 9) -> Array[int]: #Origin point is always index 0 in the array
+	var pointIDs: Array[int]
+	for point in maxPoints:
+		var id = astar.get_closest_point(origin)
+		if (astar.get_point_position(id) - origin).length() <= radius:
+			pointIDs.push_back(id)
+			astar.set_point_disabled(id)
+	for id in pointIDs:
+		astar.set_point_disabled(id,false)
+	return pointIDs
+
+func connectIfValid(id1: int, id2: int):
+	var point1 := astar.get_point_position(id1)
+	var point2 := astar.get_point_position(id2)
+	
+	if !castRay(Vector3(point1.x,height,point1.y),Vector3(point2.x,height,point2.y)):
+		astar.connect_points(id1,id2)
+
+func generatePoints() -> void:
+	var currentPoint: Vector2
+	var currentID: int = 0
+	for x in lengthX*point_density:
+		for z in lengthZ*point_density:
+			currentPoint = Vector2((x/point_density + self.global_position.x),z/point_density + self.global_position.z)
+			if checkPoint(currentPoint): 
+				astar.add_point(currentID,currentPoint)
+				currentID += 1
+
+func connectPointsToNeighbors() -> void:
+	for id in astar.get_point_ids():
+		var neighborPoints: Array[int]
+		neighborPoints = getPointsInRadius(astar.get_point_position(id),(1/point_density)*1.5)
+		for point in neighborPoints.size()-1:
+			connectIfValid(neighborPoints[0],neighborPoints[point+1])
+
+func killPointsWithoutFriends(minConnections: int) -> void: ##Really mean and evil and fucked up function
+	var cullPoints: Array[int]
+	for id in astar.get_point_ids():
+		if astar.get_point_connections(id).size() < minConnections:
+			cullPoints.push_back(id)
+	for point in cullPoints:
+		astar.remove_point(point)
+
+func addWeightToPoints() -> void: #Add weight depending on number of connections
+	for id in astar.get_point_ids():
+		astar.set_point_weight_scale(id,8 - astar.get_point_connections(id).size())