private void DoClick(object sender, ClickedEventArgs e)
{
if (teleportOnClick)
{
// First get the current Transform of the the reference space (i.e. the Play Area, e.g. CameraRig prefab)
var t = reference;
if (t == null)
{
return;
}
// Get the current Y position of the reference space
float refY = t.position.y;
// Create a plane at the Y position of the Play Area
// Then create a Ray from the origin of the controller in the direction that the controller is pointing
Plane plane = new Plane(Vector3.up, -refY);
Ray ray = new Ray(transform.position, transform.forward);
// Set defaults
bool hasGroundTarget = false;
float dist = 0f;
if (teleportType == TeleportType.TeleportTypeUseTerrain) // If we picked to use the terrain
{
RaycastHit hitInfo;
TerrainCollider tc = Terrain.activeTerrain.GetComponent <TerrainCollider>();
hasGroundTarget = tc.Raycast(ray, out hitInfo, 1000f);
dist = hitInfo.distance;
}
else if (teleportType == TeleportType.TeleportTypeUseCollider) // If we picked to use the collider
{
RaycastHit hitInfo;
hasGroundTarget = Physics.Raycast(ray, out hitInfo);
dist = hitInfo.distance;
}
else // If we're just staying flat on the current Y axis
{
// Intersect a ray with the plane that was created earlier
// and output the distance along the ray that it intersects
hasGroundTarget = plane.Raycast(ray, out dist);
}
if (hasGroundTarget)
{
// Get the current Camera (head) position on the ground relative to the world
Vector3 headPosOnGround = new Vector3(SteamVR_Render.Top().head.position.x, refY,
SteamVR_Render.Top().head.position.z);
// We need to translate the reference space along the same vector
// that is between the head's position on the ground and the intersection point on the ground
// i.e. intersectionPoint - headPosOnGround = translateVector
// currentReferencePosition + translateVector = finalPosition
t.position = t.position + (ray.origin + (ray.direction * dist)) - headPosOnGround;
}
}
}
private void Generate()
{
if (!m_Terrain || !m_SpawnData)
{
return;
}
Transform treesRoot = m_Terrain.transform.Find("Trees");
Transform rocksRoot = m_Terrain.transform.Find("Rocks");
if (m_SpawnData.m_TreeList.Length > 0 && !treesRoot)
{
treesRoot = CreateEmptyUnder("Trees", m_Terrain.transform);
}
if (!rocksRoot)
{
rocksRoot = CreateEmptyUnder("Rocks", m_Terrain.transform);
}
TerrainCollider terrainCollider = m_Terrain.GetComponent <TerrainCollider>();
Vector3 terrainSize = m_Terrain.terrainData.size;
Vector3 terrainPosition = m_Terrain.GetPosition();
for (int x = 0; x < terrainSize.x; x++)
{
for (int y = 0; y < terrainSize.z; y++)
{
bool spawn = Random.Range(0, m_SpawnOdds) == (m_SpawnOdds / 2);
if (!spawn)
{
continue;
}
bool spawnTree = Random.Range(0, 2) == 0;
if (m_SpawnData.m_TreeList.Length == 0)
{
spawnTree = false;
}
DetailSpawnData.DetailSpawn prefab = spawnTree ? m_SpawnData.GetTreePrefab() : m_SpawnData.GetRockPrefab();
if (prefab != null)
{
float raycastHeight = terrainPosition.y + terrainSize.y + 1;
Ray ray = new Ray(new Vector3(x, raycastHeight, y), Vector3.down);
RaycastHit hitInfo;
if (terrainCollider.Raycast(ray, out hitInfo, terrainSize.y * 2))
{
Instantiate(prefab.Object, hitInfo.point + prefab.PositionOffset, Quaternion.Euler(prefab.RandomRotation), spawnTree ? treesRoot : rocksRoot);
}
}
}
}
}
// Update is called once per frame
void Update()
{
if (m_stopped)
{
return;
}
if (SeekTarget != null)
{
Vector3 seekTarget = SeekTarget.transform.position;
seekTarget.y = transform.position.y;
m_agent.SetDestination(seekTarget);
if ((seekTarget - transform.position).sqrMagnitude <
(m_radiusToStartFishReelEvent * m_radiusToStartFishReelEvent))
{
m_fish.TriggerFishEvent();
SetStopped(true);
}
return;
}
m_lookAheadEulerAngles.x += Random.value * m_wanderAngleUpdateRate.x;
m_lookAheadEulerAngles.y += Random.value * m_wanderAngleUpdateRate.y;
if (m_newPosTimer > m_reseekDuration)
{
m_lookAheadPos = transform.forward * m_lookAheadDist + transform.position;
m_lookAheadRot = Quaternion.AngleAxis(m_lookAheadEulerAngles.x, Vector3.up) *
Quaternion.AngleAxis(m_lookAheadEulerAngles.y, Vector3.right);
m_wanderTarget = m_lookAheadPos + ((m_lookAheadRot * Vector3.forward) * m_lookAheadRadius);
Vector3 dirToTarget = m_wanderTarget - transform.position;
Vector3 seekDir = dirToTarget;
Ray toWanderTarget = new Ray(transform.position, dirToTarget);
if (m_terrainCollider.Raycast(toWanderTarget, out RaycastHit hitinfo, m_lookAheadDist))
{
Vector3 newDir = Vector3.Reflect(seekDir, transform.forward);
seekDir = newDir;
m_reflectedLookAheadPos = transform.position + newDir;
}
Vector3 seekPos = seekDir + transform.position;
if ((seekPos - m_startPos).sqrMagnitude > (m_maxRadius * m_maxRadius))
{
seekPos = m_startPos;
}
m_agent.SetDestination(seekPos);
m_newPosTimer = 0.0f;
}
m_newPosTimer += Time.deltaTime;
}
public Vector3?ScreenPointToMapPosition(Vector2 point)
{
var ray = Camera.main.ScreenPointToRay(point);
RaycastHit hit;
if (!MapCollider.Raycast(ray, out hit, Mathf.Infinity))
{
return(null);
}
return(hit.point);
}
public GameObjectRayHit RaycastTerrainObject(Ray ray, GameObject terrainObject, TerrainCollider terrainCollider)
{
RaycastHit rayHit;
if (terrainCollider.Raycast(ray, out rayHit, float.MaxValue))
{
return(new GameObjectRayHit(ray, rayHit));
}
return(null);
}
private void updateSelector()
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
try
{
if (board.Raycast(ray, out RaycastHit hitInfo, Mathf.Infinity))
{
Vector3 selectorTransform = hitInfo.point; // New vector to snap selector to grid
selectorTransform.x = Mathf.Round(hitInfo.point.x);
selectorTransform.z = Mathf.Round(hitInfo.point.z);
selectorTransform.y = 0.1f; // Hover over Board
selector.transform.position = selectorTransform;
}
}
catch
{
Debug.Log("Unable to update location for Tile Selector");
}
}
private Vector3?ScreenMapLook()
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (!map.Raycast(ray, out hit, Mathf.Infinity))
{
return(null);
}
return(hit.point);
}
void FixedUpdate()
{
if (ghost != null && dragging)
{
Ray ray = targetCamera.ScreenPointToRay(Input.mousePosition);
RaycastHit hitInfo;
if (terrain.Raycast(ray, out hitInfo, Mathf.Infinity)) // using infinity for the ray length for example
{
ghost.transform.position = CalculatePosition(hitInfo.point);
}
}
}
public override bool Raycast(Ray ray, out Octave3DColliderRayHit colliderRayHit)
{
colliderRayHit = null;
RaycastHit rayHit;
if (_terrainCollider.Raycast(ray, out rayHit, float.MaxValue))
{
colliderRayHit = new Octave3DColliderRayHit(ray, rayHit.distance, rayHit.point, rayHit.normal, this);
}
return(colliderRayHit != null);
}
/*
* Identify a point on the map from a 2d point on the screen
*/
public RaycastHit?ScreenPointToMapPosition(Vector2 point)
{
var ray = Camera.main.ScreenPointToRay(point);
RaycastHit hit;
//if we have not hit anything, then just return null
if (!MapCollider.Raycast(ray, out hit, Mathf.Infinity))
{
return(null);
}
return(hit);
}
private Vector3 getWorldCoordonatesFromClick(Vector3 mousePosition)
{
Ray ray;
ray = Camera.main.ScreenPointToRay(mousePosition);
RaycastHit hitData;
if (terrainCollider != null && terrainCollider.Raycast(ray, out hitData, Mathf.Infinity))
{
return(hitData.point);
}
return(new Vector3(-1, -1, -1));
}
private bool CanLand()
{
if (height > maxDistanceToLand)
{
return(false);
}
Ray ray = new Ray(new Vector3(transform.position.x, transform.position.y, transform.position.z), Vector3.down);
RaycastHit hit;
terrainCollider = GameObject.FindObjectOfType <TerrainCollider>();
return(terrainCollider.Raycast(ray, out hit, 2.0f) && hit.distance <= maxDistanceToLand);
}
private void Update()
{
if (isFired)
{
return;
}
timer += Time.deltaTime;
if (Input.GetKeyDown(KeyCode.Escape) || Input.GetKeyDown(KeyCode.Mouse1))
{
gameObject.SetActive(false);
enabled = false;
Manager.Instance.SkillOnMouse = false;
return;
}
RaycastHit hit;
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (terrainCollider.Raycast(ray, out hit, 145f))
{
transform.position = hit.point;
}
if (CheckDistance())
{
canBeCasted = true;
rend.material.color = Color.green;
}
else
{
canBeCasted = false;
Scale();
rend.material.color = new Color(0.7f, 0.3f, 0.1f);
}
if (timer < 0.5f)
{
return;
}
if (Input.GetKeyDown(KeyCode.Mouse0))
{
if (canBeCasted)
{
Fire();
}
else
{
EventLog.Instance.AddAction(LogType.Error, Distance, transform.position);
}
}
}
public Vector3 BrushPos()
{
Ray ray = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
RaycastHit hit;
if (terrainCollider.Raycast(ray, out hit, Mathf.Infinity))
{
return(hit.point);
}
else
{
return(strokeBounds.center); //returning somewhere within stroke
}
}
public static float GetHeight(this TerrainCollider ground, float x, float z, float maxHeight = 1000.0f)
{
var ray = new Ray(new Vector3(x, maxHeight, z), Vector3.down);
RaycastHit hit;
if (ground.Raycast(ray, out hit, maxHeight))
{
return(hit.point.y);
}
else
{
return(0);
}
}
private void HandleHolo() {
if (!_currentHolo) return;
var t = transform;
_terrainCollider.Raycast(new Ray(t.position, -t.forward), out var hit, PositiveInfinity);
_currentHolo.transform.position = hit.point;
if (!_controls.fire1) return;
var buildingHolo = _currentHolo.GetComponent<BuildingHolo>();
if (!buildingHolo.CanBeBuilt()) return;
_build.CmdBuild(_currentHolo.transform.position, _currentHoloType);
Destroy(_currentHolo);
_currentHolo = null;
}
void FixedUpdate()
{
if (terrainColliderForUpdate)
{
RaycastHit hit = new RaycastHit();
if (terrainColliderForUpdate.Raycast(new Ray(transform.position + Vector3.up * checkOffset, Vector3.down), out hit, Mathf.Infinity))
{
// enable only in the case when my collider seems to be over terrain surface
for (int i = 0; i < terrainColliders.Length; i++)
{
Physics.IgnoreCollision(_collider, terrainColliders[i], false);
}
}
terrainColliderForUpdate = null;
}
}
//void DoClick(object sender, ClickedEventArgs e)
void DoClick()
{
GameObject go = Fsm.GetOwnerDefaultTarget(controller);
var i = -1;
if ((int)trackedObj.index > i++)
{
var t = reference;
if (t == null)
{
return;
}
float refY = t.position.y;
Plane plane = new Plane(Vector3.up, -refY);
Ray ray = new Ray(go.transform.position, go.transform.forward);
bool hasGroundTarget = false;
float dist = 0f;
if (teleportType == TeleportType.TeleportTypeUseTerrain)
{
RaycastHit hitInfo;
TerrainCollider tc = Terrain.activeTerrain.GetComponent <TerrainCollider>();
hasGroundTarget = tc.Raycast(ray, out hitInfo, 1000f);
dist = hitInfo.distance;
}
else if (teleportType == TeleportType.TeleportTypeUseCollider)
{
RaycastHit hitInfo;
Physics.Raycast(ray, out hitInfo);
dist = hitInfo.distance;
}
else
{
hasGroundTarget = plane.Raycast(ray, out dist);
}
if (hasGroundTarget)
{
Vector3 headPosOnGround = new Vector3(SteamVR_Render.Top().head.localPosition.x, 0.0f, SteamVR_Render.Top().head.localPosition.z);
t.position = ray.origin + ray.direction * dist - new Vector3(t.GetChild(0).localPosition.x, 0f, t.GetChild(0).localPosition.z) - headPosOnGround;
Fsm.Event(sendEvent);
}
}
}
private void MoveGhostWithMouse()
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hitInfo;
if (terrainCollider.Raycast(ray, out hitInfo, 1000))
{
currentGhostPos.x = hitInfo.point.x;
currentGhostPos.y = currentGhost.transform.position.y;
currentGhostPos.z = hitInfo.point.z;
ghostRot = Quaternion.FromToRotation(Vector3.up, hitInfo.normal);
}
currentGhost.transform.position = currentGhostPos;
currentGhost.transform.rotation = ghostRot;
}
void Start()
{
if (mainCamera == null)
{
GameObject gameObj = GameObject.FindWithTag("MainCamera");
if (gameObj == null || (mainCamera = gameObj.GetComponent <Transform>()) == null)
{
Debug.LogError("Unable to find camera to attach to");
return;
}
}
if (terrain == null)
{
Terrain terrainObj = GameObject.FindObjectOfType <Terrain>();
if (terrainObj == null || (terrain = terrainObj.GetComponent <TerrainCollider>()) == null)
{
Debug.LogError("Unable to find terrain with collider to use");
}
}
RaycastHit hit;
if (!terrain.Raycast(new Ray(mainCamera.position, mainCamera.forward), out hit, Mathf.Infinity))
{
Debug.LogError("Camera is not looking at the terrain");
return;
}
lookAtPoint = hit.point;
directionVector = new Vector3(lookAtPoint.x - mainCamera.position.x, 0, lookAtPoint.z - mainCamera.position.z);
centerOfCameraArc = new Vector3(
lookAtPoint.x,
mainCamera.position.y + Mathf.Tan(startAngle) * directionVector.magnitude,
lookAtPoint.z);
directionVector = directionVector.normalized;
Vector3 normalVector = new Vector3(0, 1, 0); // Always facing upright above the lookAtPoint.
axisOfRotation = Vector3.Cross(normalVector, directionVector); // Should have length 1, no need to normalize again.
// Start angle is the minimum angle.
currentAngle = startAngle;
originalCameraPosition = mainCamera.position;
originalUpVector = mainCamera.up;
}
public GameObjectRayHit RaycastTerrainObject(Ray ray, GameObject terrainObject)
{
TerrainCollider terrainCollider = terrainObject.GetComponent <TerrainCollider>();
if (terrainCollider == null)
{
return(null);
}
RaycastHit rayHit;
if (terrainCollider.Raycast(ray, out rayHit, float.MaxValue))
{
return(new GameObjectRayHit(ray, rayHit));
}
return(null);
}
public static void PushOutFromTerrain(TerrainCollider terrainCollider, float segmentRadius, ref Vector3 point)
{
Terrain terrain = terrainCollider.GetComponent <Terrain>();
Vector3 rayOrigin = point;
rayOrigin.y = terrainCollider.transform.position.y + terrain.SampleHeight(point) + segmentRadius;
Ray ray = new Ray(rayOrigin, Vector3.down);
RaycastHit hit;
if (terrainCollider.Raycast(ray, out hit, segmentRadius * 2f))
{
float hitToPointDist = (point - hit.point).magnitude;
float underMul = 1f;
if (hit.point.y > point.y + segmentRadius * 0.9f)
{
underMul = 8f;
}
else
if (hit.point.y > point.y)
{
underMul = 4f;
}
if (hitToPointDist < segmentRadius * underMul)
{
Vector3 toNormal = hit.point - point;
Vector3 pushNormal;
if (underMul > 1f)
{
pushNormal = toNormal + toNormal.normalized * segmentRadius;
}
else
{
pushNormal = toNormal - toNormal.normalized * segmentRadius;
}
point = point + pushNormal;
}
}
}
Vector2 Hit(Camera camera, Vector2 screenPosition) // returns uv
{
RaycastHit hit;
Ray ray = camera.ScreenPointToRay(screenPosition);
if (boardCollider.Raycast(ray, out hit, 200.0f))
{
var localHit =
boardCollider.transform.InverseTransformPoint(hit.point);
var bounds = boardCollider.bounds;
var extents = bounds.extents * 2;
var uv = new Vector2(
localHit.x / extents.x,
localHit.z / extents.z);
Debug.Log($"bounds.min = {bounds.min}, extents = {extents}, hit.point = {hit.point}, localHit = {localHit}, uv = {uv}");
return(uv);
}
return(Vector2.zero);
}
public void PlaceAtScreenPosition(Vector2 position)
{
if (Camera.current == null)
{
return;
}
position.y = Camera.current.pixelHeight - position.y;
Ray ray = Camera.current.ScreenPointToRay(position);
RaycastHit hit;
TerrainCollider collider = this.GetComponent <TerrainCollider>();
if (collider.Raycast(ray, out hit, Mathf.Infinity))
{
Place(hit.point);
LastHit = hit.point;
}
}
void DoClick(object sender, ClickedEventArgs e)
{
if (teleportOnClick)
{
var t = reference;
if (t == null)
{
return;
}
float refY = t.position.y;
Plane plane = new Plane(Vector3.up, -refY);
Ray ray = new Ray(this.transform.position, transform.forward);
bool hasGroundTarget = false;
float dist = 0f;
if (teleportType == TeleportType.TeleportTypeUseTerrain)
{
RaycastHit hitInfo;
TerrainCollider tc = Terrain.activeTerrain.GetComponent <TerrainCollider>();
hasGroundTarget = tc.Raycast(ray, out hitInfo, 1000f);
dist = hitInfo.distance;
}
else if (teleportType == TeleportType.TeleportTypeUseCollider)
{
RaycastHit hitInfo;
Physics.Raycast(ray, out hitInfo);
dist = hitInfo.distance;
}
else
{
hasGroundTarget = plane.Raycast(ray, out dist);
}
if (hasGroundTarget)
{
Vector3 headPosOnGround = new Vector3(SteamVR_Render.Top().head.localPosition.x, 0.0f, SteamVR_Render.Top().head.localPosition.z);
t.position = ray.origin + ray.direction * dist - new Vector3(t.GetChild(0).localPosition.x, 0f, t.GetChild(0).localPosition.z) - headPosOnGround;
}
}
}
void Start()
{
skin = Resources.Load("GUISkin") as GUISkin;
if (mainCamera == null)
{
GameObject go = GameObject.FindGameObjectWithTag("MainCamera");
if (go != null)
{
mainCamera = go.transform;
}
}
if (terrain == null)
{
Terrain terrainObj = GameObject.FindObjectOfType <Terrain>();
if (terrainObj == null || (terrain = terrainObj.GetComponent <TerrainCollider>()) == null)
{
Debug.LogError("Unable to find terrain with collider to use");
}
}
RaycastHit hit;
if (!terrain.Raycast(new Ray(mainCamera.position, mainCamera.forward), out hit, Mathf.Infinity))
{
Debug.LogError("Camera is not looking at the terrain");
return;
}
lookAtPoint = hit.point;
directionVector = new Vector3(lookAtPoint.x - mainCamera.position.x, 0, lookAtPoint.z - mainCamera.position.z).normalized;
centerOfCameraArc = new Vector3(
lookAtPoint.x,
0,
lookAtPoint.z);
Debug.Log("Center of camera:" + centerOfCameraArc);
Debug.Log("Original pos:" + mainCamera.position);
originalCameraPosition = mainCamera.position;
originalUpVector = mainCamera.up;
}
// Update is called once per frame
void Update()
{
if (!IsGrounded || !IsIkActivated)
{
return;
}
RaycastHit hit;
Ray left_ray = new Ray(LeftLeg.position, new Vector3(0f, -10f, 0f));
_TerrainCollider.Raycast(left_ray, out hit, 10);
Base.transform.Translate(new Vector3(0, 0, -0.005f), Space.Self);
/*if (hit.collider != null)
* {
* LeftLeg.position = hit.point + new Vector3(0, 0.1f, 0);
* }*/
//_TerrainData.GetInterpolatedNormal()
}
// This is a method that returns a point on the terrain that has been selected with the mouse when pressing a certain key
public Vector3 GetTerrainCollisionInEditor(Event currentEvent, KeyCode keysCode)
{
Vector3 returnCollision = new Vector3();
AttachedRiverScript riverScript = (AttachedRiverScript)target as AttachedRiverScript;
Camera SceneCameraReceptor = new Camera();
GameObject terrain = riverScript.parentTerrain;
Terrain terComponent = (Terrain)terrain.GetComponent(typeof(Terrain));
TerrainCollider terCollider = (TerrainCollider)terrain.GetComponent(typeof(TerrainCollider));
TerrainData terData = terComponent.terrainData;
Ray terrainRay = new Ray();
if (Camera.current != null)
{
SceneCameraReceptor = Camera.current;
RaycastHit raycastHit = new RaycastHit();
Vector2 newMousePosition = new Vector2(currentEvent.mousePosition.x, Screen.height - (currentEvent.mousePosition.y + 25));
terrainRay = SceneCameraReceptor.ScreenPointToRay(newMousePosition);
if (terCollider.Raycast(terrainRay, out raycastHit, Mathf.Infinity))
{
returnCollision = raycastHit.point;
returnCollision.x = Mathf.RoundToInt((returnCollision.x / terData.size.x) * terData.heightmapResolution);
returnCollision.y = returnCollision.y / terData.size.y;
returnCollision.z = Mathf.RoundToInt((returnCollision.z / terData.size.z) * terData.heightmapResolution);
}
else
{
Debug.LogError("Error: No collision with terrain to create node");
}
}
return(returnCollision);
}
public void CloseRiver()
{
MeshFilter meshFilter = (MeshFilter)riverObject.GetComponent(typeof(MeshFilter));
Mesh newMesh = meshFilter.sharedMesh;
Vector3[] newVertices = newMesh.vertices;
TerrainCollider terCollider = (TerrainCollider)terrainObject.GetComponent(typeof(TerrainCollider));
for (int i = 0; i < newVertices.Length; i++)
{
Ray riverRay = new Ray(new Vector3(newVertices[i].x, newVertices[i].y + transform.position.y, newVertices[i].z), -Vector3.up);
RaycastHit raycastHit = new RaycastHit();
if (terCollider.Raycast(riverRay, out raycastHit, Mathf.Infinity))
{
newVertices[i].y = (raycastHit.point.y - 1.0f) - transform.position.y;
}
}
newMesh.vertices = newVertices;
}
// Token: 0x06005BFE RID: 23550 RVA: 0x00201E88 File Offset: 0x00200288
private void DoClick(object sender, ClickedEventArgs e)
{
if (this.teleportOnClick)
{
Transform reference = this.reference;
if (reference == null)
{
return;
}
float y = reference.position.y;
Plane plane = new Plane(Vector3.up, -y);
Ray ray = new Ray(base.transform.position, base.transform.forward);
float d = 0f;
bool flag;
if (this.teleportType == SteamVR_Teleporter.TeleportType.TeleportTypeUseTerrain)
{
TerrainCollider component = Terrain.activeTerrain.GetComponent <TerrainCollider>();
RaycastHit raycastHit;
flag = component.Raycast(ray, out raycastHit, 1000f);
d = raycastHit.distance;
}
else if (this.teleportType == SteamVR_Teleporter.TeleportType.TeleportTypeUseCollider)
{
RaycastHit raycastHit2;
flag = Physics.Raycast(ray, out raycastHit2);
d = raycastHit2.distance;
}
else
{
flag = plane.Raycast(ray, out d);
}
if (flag)
{
Vector3 b = new Vector3(SteamVR_Render.Top().head.position.x, y, SteamVR_Render.Top().head.position.z);
reference.position = reference.position + (ray.origin + ray.direction * d) - b;
}
}
}