#pragma warning restore 414 KMSelectable[] ProcessTwitchCommand(string command) { command = command.ToLowerInvariant().Trim(); if (Regex.IsMatch(command, @"^press +[0-9^, |&]+$")) { command = command.Substring(6).Trim(); var presses = command.Split(new[] { ',', ' ', '|', '&' }, StringSplitOptions.RemoveEmptyEntries); var pressList = new List <KMSelectable>(); for (var i = 0; i < presses.Length; i++) { if (Regex.IsMatch(presses[i], @"^[0-9]{1,2}$")) { pressList.Add(ModuleButtons[Math.Clamp(Math.Max(1, int.Parse(presses[i].ToString())) - 1, 0, ModuleButtons.Length - 1)]); } } return(pressList.ToArray()); } if (Regex.IsMatch(command, @"^(submit|sub|s)$")) { return new[] { SubmitButton } } ; return(null); } }
public static int TagField(string label, int value) { // Make sure the tagNamesAndEditTagsButton is relatively up to date if (tagNamesAndEditTagsButton == null || EditorApplication.timeSinceStartup - timeLastUpdatedTagNames > 1) { timeLastUpdatedTagNames = EditorApplication.timeSinceStartup; var tagNames = AstarPath.FindTagNames(); tagNamesAndEditTagsButton = new string[tagNames.Length + 1]; tagNames.CopyTo(tagNamesAndEditTagsButton, 0); tagNamesAndEditTagsButton[tagNamesAndEditTagsButton.Length - 1] = "Edit Tags..."; } // Tags are between 0 and 31 value = Mathf.Clamp(value, 0, 31); var newValue = EditorGUILayout.IntPopup(label, value, tagNamesAndEditTagsButton, new [] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, -1 }); // Last element corresponds to the 'Edit Tags...' entry. Open the tag editor if (newValue == -1) { AstarPathEditor.EditTags(); } else { value = newValue; } return(value); }
void basicAttack() { lastClickedTime = Time.time; numberOfClicks++; if (numberOfClicks == 1) { animator.SetBool("basicAttack1", true); } numberOfClicks = Mathf.Clamp(numberOfClicks, 0, 3); }
public void Validate() { if (surfaceDefinition == null) { surfaceDefinition = new ChiselSurfaceDefinition(); } curveSegments = Mathf.Max(curveSegments, 2); revolveSegments = Mathf.Max(revolveSegments, 1); totalAngle = Mathf.Clamp(totalAngle, 1, 360); // TODO: constants surfaceDefinition.EnsureSize(6); }
void UpdateSolution() { updating = true; solvedMods = BombInfo.GetSolvedModuleNames().Count; if (solvedMods != prevSolvedMods) { var nowHalf = new String((countHalf) ? modLetter.Take(20).ToArray() : modLetter.Skip(20).ToArray()); shapeSolution = intShape[(Math.Clamp(nowHalf.Count(x => x == ((countUnlit) ? 'X' : 'O')), 5, 14) + ((solvedMods % 2 == 1) ? 10 : 0)) - 5]; } prevSolvedMods = solvedMods; updating = false; }
private Vector3 GetCameraClampedPosition() { // TODO: Support of many players var player = players[0]; var point = camera.WorldToViewportPoint(player.transform.position); // X target //var viewportXTarget = player.IsFacingRight ? ViewportXTarget : 1f - ViewportXTarget; var viewportXFraction = camera.WorldToViewportPoint(player.transform.position).x; //viewportXFraction = Mathf.Clamp(viewportXFraction, viewportXTarget - ViewportXTargetMaxInterval, viewportXTarget + ViewportXTargetMaxInterval); // Y target var viewportYFraction = camera.WorldToViewportPoint(player.transform.position).y; viewportYFraction = Mathf.Clamp(viewportYFraction, ViewportYMin, ViewportYMax); var delta = player.transform.position - camera.ViewportToWorldPoint(new Vector3(viewportXFraction, viewportYFraction, point.z)); return(transform.position + delta); }
void Tick() { if (Event.current.type == EventType.Repaint) { float deltaTime = Time.realtimeSinceStartup - lastUpdate; // Right at the start of a transition the deltaTime will // not be reliable, so use a very small value instead // until the next repaint if (value == 0f || value == 1f) { deltaTime = 0.001f; } deltaTime = Mathf.Clamp(deltaTime, 0.00001F, 0.1F); // Larger regions fade slightly slower deltaTime /= Mathf.Sqrt(Mathf.Max(lastRect.height, 100)); lastUpdate = Time.realtimeSinceStartup; float targetValue = open ? 1F : 0F; if (!Mathf.Approximately(targetValue, value)) { value += deltaTime * animationSpeed * Mathf.Sign(targetValue - value); value = Mathf.Clamp01(value); editor.Repaint(); if (!fancyEffects) { value = targetValue; } } else { value = targetValue; } } }
public void CircleXZ(Vector3 center, float radius, Color color, float startAngle = 0f, float endAngle = 2 *Mathf.PI) { int steps = 40; #if UNITY_EDITOR if (gizmos) { steps = (int)Mathf.Clamp(Mathf.Sqrt(radius / UnityEditor.HandleUtility.GetHandleSize((UnityEngine.Gizmos.matrix * matrix).MultiplyPoint3x4(center))) * 25, 4, 40); } #endif while (startAngle > endAngle) { startAngle -= 2 * Mathf.PI; } Vector3 prev = new Vector3(Mathf.Cos(startAngle) * radius, 0, Mathf.Sin(startAngle) * radius); for (int i = 0; i <= steps; i++) { Vector3 c = new Vector3(Mathf.Cos(Mathf.Lerp(startAngle, endAngle, i / (float)steps)) * radius, 0, Mathf.Sin(Mathf.Lerp(startAngle, endAngle, i / (float)steps)) * radius); Line(center + prev, center + c, color); prev = c; } }
void Update() { Vec3 pos; /* Cosine of the angle on the X-Z ("horizontal") plane */ float xCosTeta; /* Sine of the angle on the Z-Y ("vertical") plane */ float ySinPhi; if (this.player == null) { GO pl = null; this.rootEvent <GetPlayer>((x, y) => x.Get(out pl)); if (pl != null) { this.player = pl.transform; } return; } if (!Input.GetMouseCameraEnabled()) { /* Try to manipulate the camera using a gamepad */ xCosTeta = Global.camX * -1.0f * Input.GetCameraX(); ySinPhi = Global.camY * Input.GetCameraY(); this.wasUsingMouse = false; } else { if (this.wasUsingMouse) { /* Move the camera, using a 50px (?) circle around the mouse */ Vec3 mouseDelta = Input.GetMousePosition() - this.mouse; xCosTeta = Global.camX * -1.0f * mouseDelta.x * 0.02f; ySinPhi = Global.camY * -1.0f * mouseDelta.y * 0.02f; ySinPhi = Math.Clamp(ySinPhi, -1.0f, 1.0f); } else { /* Use the current position as the mouse's origin */ this.mouse = Input.GetMousePosition(); this.wasUsingMouse = true; xCosTeta = 0.0f; ySinPhi = 0.0f; } } xCosTeta = Math.Clamp(xCosTeta, -0.8f, 0.8f); float dist = Math.Sqrt(xCosTeta * xCosTeta + ySinPhi * ySinPhi); if (!this.wasUsingMouse && dist < 0.5f) { pos = new Vec3(this.baseDX, this.baseDY, this.baseDZ); } else { float zSinTeta = -1.0f * Math.Sqrt(1.0f - xCosTeta * xCosTeta); float zCosPhi = -1.0f * Math.Sqrt(1.0f - ySinPhi * ySinPhi); pos = new Vec3(xCosTeta, ySinPhi, (zSinTeta + zCosPhi) * 0.5f); } pos = pos.normalized * this.distance; this.lastPos = 0.75f * this.lastPos + pos * 0.25f; this.cam.position = this.player.position + this.lastPos; this.cam.LookAt(this.player); }
// Update is called once per frame void Update() { HPBar.value = hp; TimeBar.value = timeEnergy; // if player dead if (this.hp <= 0) { timeToGameRestart -= Time.deltaTime; int timetoRestartDelta = (int)timeToGameRestart; if (Input.GetKeyDown(KeyCode.R)) { timeToGameRestart = -1; } StartCoroutine(ShowMessage("Press \"r\" for restart. \n Auto restart in " + (timetoRestartDelta + 1))); if (timeToGameRestart < 0) { timeToGameRestart = 3; RestartGame(); } else { return; } } else { // number of click for attack chain if ((Time.time - lastClickedTime > maxComboDelay)) { numberOfClicks = 0; } // poruszanie i kamera if (!aim) { transform.Rotate(0f, Input.GetAxis("Mouse X") * Time.deltaTime * 225f, 0f); transform.position += transform.right * Input.GetAxis("Horizontal") * Time.deltaTime * 5f; transform.position += transform.forward * Input.GetAxis("Vertical") * Time.deltaTime * 5f; } else { if (!aimAnglesSetCorrectly) { angleVertical = transform.eulerAngles.x; angleHorizontal = transform.eulerAngles.y; aimAnglesSetCorrectly = true; } angleVertical += Input.GetAxis("Mouse Y") * Time.deltaTime * 225f; angleVertical = Mathf.Clamp(angleVertical, -35, 20); angleHorizontal += Input.GetAxis("Mouse X") * Time.deltaTime * 225f; transform.localEulerAngles = new Vector3(angleVertical, angleHorizontal, 0.0f); } // skok if (Input.GetKeyDown(KeyCode.Space) && IsGrounded()) { lastJumpTime = Time.time; body.velocity += new Vector3(0f, 5.0f, 0f); } if (IsGrounded()) { animator.SetBool("isGrounded", true); } else { animator.SetBool("isGrounded", false); } // basic attack + basic attack jump combo if (Input.GetMouseButtonDown(0)) { if (Time.time - lastJumpTime < 0.5f) { if (!IsAnyAttackBoolTrue()) { animator.SetBool("jumpAttack1", true); } } else { basicAttack(); } } // ranged attack + ranged attack jump combo if (Input.GetMouseButtonDown(1) && !IsAnyAttackBoolTrue()) { if (Time.time - lastJumpTime < 0.5f) { animator.SetBool("jumpAttack2", true); } else { animator.SetBool("rangedAttack", true); } } //special abilities energy management if (timeEnergy == 0) { timeStop = false; } if (!timeStop && !timeEnergyRegeneration && timeEnergy < 10) { timeEnergyRegeneration = true; StartCoroutine(RegenerateTimeEnergy()); } // special abilities if (Input.GetKeyDown(KeyCode.Q)) { if (timeStop || timeEnergy == 0) { timeStop = false; } else if (!timeStop && timeEnergy > 1) { timeStop = true; StartCoroutine(TimeIsStopped()); } } if (Input.GetKeyDown(KeyCode.E) && timeEnergy >= 5) { timeEnergy -= 5; transform.position = LastPositions[LastPositions.Count / 2]; hp = lastHPs[lastHPs.Count / 2]; ReLocateIndicies(LastPositions); ReLocateIndicies(lastHPs); } if (Input.GetKeyDown(KeyCode.R) && timeEnergy >= 3) { timeEnergy -= 3; transform.position = transform.Find("Player Model").Find("unityNieOgarnia").position; transform.Find("Player Model").GetComponent <Animator>().enabled = false; transform.Find("Player Model").GetComponent <Animator>().enabled = true; transform.Find("Player Model").GetComponent <Animator>().Play("Idle"); } if (Input.GetKeyDown(KeyCode.F)) { aim = !aim; if (!aim) { transform.eulerAngles = new Vector3(0.0f, transform.eulerAngles.y, transform.eulerAngles.z); } aimAnglesSetCorrectly = false; } // Attack system manager if (Manager != null) { } } }
#pragma warning restore 414 KMSelectable[] ProcessTwitchCommand(string command) { command = command.ToLowerInvariant().Trim(); if (Regex.IsMatch(command, @"^press +[0-9^, |&]+$")) { command = command.Substring(6).Trim(); var presses = command.Split(new[] { ',', ' ', '|', '&' }, StringSplitOptions.RemoveEmptyEntries); var pressList = new List <KMSelectable>(); for (int i = 0; i < presses.Length; i++) { if (Regex.IsMatch(presses[i], @"^[0-9]{1,2}$")) { pressList.Add(ModuleButtons[Math.Clamp(Math.Max(1, int.Parse(presses[i].ToString())) - 1, 0, ModuleButtons.Length - 1)]); } } return((pressList.Count > 0) ? pressList.ToArray() : null); } if (Regex.IsMatch(command, @"^show +([0-9^, |&]|all|top|bottom)+$")) { if (!ColScreen.activeSelf) { return(null); } command = command.Substring(5).Trim(); var showing = command.Split(new[] { ',', ' ', '|', '&' }, StringSplitOptions.RemoveEmptyEntries); var showList = new List <int>(); for (int i = 0; i < showing.Length; i++) { if (Regex.IsMatch(showing[i], @"^[0-9]{1,2}$")) { showList.Add(Math.Clamp(Math.Max(1, int.Parse(showing[i].ToString())) - 1, 0, ModuleButtons.Length - 1)); } else { showList.Clear(); for (int j = ((showing[i].Equals("bottom")) ? 10 : 0); j < 20 - (((showing[i].Equals("top")) ? 10 : 0)); j++) { showList.Add(j); } break; } } if (showList.Count == 0) { return(null); } StopAllCoroutines(); StartCoroutine(ShowScreen(showList)); return(new KMSelectable[0]); } if (Regex.IsMatch(command, @"^\s*(colorblind|cb)\s*$")) { ColScreen.SetActive(true); return(new KMSelectable[0]); } return(null); }
private void Update() { if (!_initCompleted) { return; } if (SuperController.singleton.freezeAnimation) { return; } #if LFE_DEBUG if (Input.GetKey("up")) { CameraTarget.centerTarget.targetCamera.enabled = false; _detector.Detector.enabled = true; } else { CameraTarget.centerTarget.targetCamera.enabled = true; _detector.Detector.enabled = true; } #endif try { _brightnessChangeCountdown -= Time.deltaTime; // run the scheduled animation if (_currentAnimation != null) { _pupilMorph.morphValueAdjustLimits = Math.Clamp(_currentAnimation.Update(), -1.5f, 2.0f); if (_currentAnimation.IsFinished) { _currentAnimation = null; // schedule a new idle _idleCountDown = UnityEngine.Random.Range(0.01f, Math.Max(IdleMaxDelayStorable.val, 0.01f)); } } var brightness = CalculateBrightness(); var currentValue = _pupilMorph.morphValue; var targetValue = BrightnessToMorphValue(brightness); var duration = 0f; if (_lastBrightness == brightness) { // maybe schedule an idle animation - but do not interrupt an animation in progress just for idle if (_currentAnimation == null && _idleCountDown < 0) { duration = Math.Max(IdleAdjustSpeedStorable.val, 0.01f); _idleSign = _idleSign * -1; targetValue = targetValue + (_idleSign * UnityEngine.Random.Range(0.01f, IdleStrengthStorable.val)); _currentAnimation = new EyeDialationAnimation(currentValue, targetValue, duration, (p) => Easings.BackEaseOut(p)); } else { _idleCountDown -= Time.deltaTime; } } else { if (_brightnessChangeCountdown <= 0) { // schedule brightness adjustment animation - override any currently running animation for this one. light always wins duration = targetValue > currentValue ? DarkAdjustSpeedStorable.val : LightAdjustSpeedStorable.val; _currentAnimation = new EyeDialationAnimation(currentValue, targetValue, duration, (p) => Easings.ElasticEaseOut(p)); _brightnessChangeCountdown = _brightnessChangeThrottle; } } _lastBrightness = brightness; } catch (Exception ex) { SuperController.LogError(ex.ToString()); } }
Vector3 Snap(ABPath path, Exactness mode, bool start, out bool forceAddPoint) { var index = start ? 0 : path.path.Count - 1; var node = path.path[index]; var nodePos = (Vector3)node.position; forceAddPoint = false; switch (mode) { case Exactness.ClosestOnNode: return(start ? path.startPoint : path.endPoint); case Exactness.SnapToNode: return(nodePos); case Exactness.Original: case Exactness.Interpolate: case Exactness.NodeConnection: Vector3 relevantPoint; if (start) { relevantPoint = adjustStartPoint != null?adjustStartPoint().ToPFV3() : path.originalStartPoint; } else { relevantPoint = path.originalEndPoint; } switch (mode) { case Exactness.Original: return(GetClampedPoint(nodePos, relevantPoint, node)); case Exactness.Interpolate: // Adjacent node to either the start node or the end node in the path var adjacentNode = path.path[Mathf.Clamp(index + (start ? 1 : -1), 0, path.path.Count - 1)]; return(VectorMath.ClosestPointOnSegment(nodePos, (Vector3)adjacentNode.position, relevantPoint)); case Exactness.NodeConnection: // This code uses some tricks to avoid allocations // even though it uses delegates heavily // The connectionBufferAddDelegate delegate simply adds whatever node // it is called with to the connectionBuffer connectionBuffer = connectionBuffer ?? new List <GraphNode>(); connectionBufferAddDelegate = connectionBufferAddDelegate ?? (System.Action <GraphNode>)connectionBuffer.Add; // Adjacent node to either the start node or the end node in the path adjacentNode = path.path[Mathf.Clamp(index + (start ? 1 : -1), 0, path.path.Count - 1)]; // Add all neighbours of #node to the connectionBuffer node.GetConnections(connectionBufferAddDelegate); var bestPos = nodePos; var bestDist = float.PositiveInfinity; // Loop through all neighbours // Do it in reverse order because the length of the connectionBuffer // will change during iteration for (int i = connectionBuffer.Count - 1; i >= 0; i--) { var neighbour = connectionBuffer[i]; // Find the closest point on the connection between the nodes // and check if the distance to that point is lower than the previous best var closest = VectorMath.ClosestPointOnSegment(nodePos, (Vector3)neighbour.position, relevantPoint); var dist = (closest.ToUnityV3() - relevantPoint).sqrMagnitude; if (dist < bestDist) { bestPos = closest; bestDist = dist; // If this node is not the adjacent node // then the path should go through the start node as well forceAddPoint = neighbour != adjacentNode; } } connectionBuffer.Clear(); return(bestPos); default: throw new System.ArgumentException("Cannot reach this point, but the compiler is not smart enough to realize that."); } default: throw new System.ArgumentException("Invalid mode"); } }
void Start() { moduleId = moduleIdCounter++; string[] choseColor = { "Yellow", "Green", "Cyan", "Blue", "Purple", "White" }; int chooseRndColor = Random.Range(0, randomColors.Length); ColScreen.transform.GetChild(0).GetComponent <TextMesh>().text = ""; buttonsColor = randomColors[chooseRndColor]; char[] moduleLetters = { 'A', 'B', 'D', 'E', 'G', 'I', 'K', 'L', 'N', 'O', 'P', 'S', 'T', 'X', 'Y' }; string[] intLetter = { "XOOOXOXXXOOXXXOOOOOOOXXXOOXXXOOXXXOOXXXO", "OOOOXOXXXOOXXXOOOOOXOXXXOOXXXOOXXXOOOOOX", "OOOOXOXXXOOXXXOOXXXOOXXXOOXXXOOXXXOOOOOX", "OOOOOOXXXXOXXXXOOOOXOXXXXOXXXXOXXXXOOOOO", "XOOOXOXXXOOXXXXOXXXXOXOOOOXXXOOXXXOXOOOX", "OOOOOXXOXXXXOXXXXOXXXXOXXXXOXXXXOXXOOOOO", "OXXXOOXXOXOXOXXOOXXXOXOXXOXXOXOXXOXOXXXO", "OXXXXOXXXXOXXXXOXXXXOXXXXOXXXXOXXXXOOOOO", "OXXXOOOXXOOXOXOOXOXOOXXOOOXXXOOXXXOOXXXO", "XOOOXOXXXOOXXXOOXXXOOXXXOOXXXOOXXXOXOOOX", "OOOOXOXXXOOXXXOOOOOXOXXXXOXXXXOXXXXOXXXX", "XOOOXOXXXOOXXXXXOOOXXXXXOXXXXOOXXXOXOOOX", "OOOOOXXOXXXXOXXXXOXXXXOXXXXOXXXXOXXXXOXX", "OXXXOXOXOXXOXOXXXOXXXXOXXXOXOXXOXOXOXXXO", "OXXXOXOXOXXOXOXXXOXXXXOXXXXOXXXXOXXXXOXX" }; string[] chooseShapes = { "XXXXXXXXXXXXXXXOXXXXOXXXOOXOXOOXOXOOOOOO", "XOOOXOXXXOXXXXOXXXOXXXOXXXXOXXXXXXXXXOXX", "XXOXXXOXOXOXXXOXOOOXOXXXOXOXOXXXOXXOOXOO", "XOOOXXXXXOXXXXOXOOOXXXXXOXXXXOXXXXOXOOOX", "OXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOXOX", "XXOXXXXOXXXXOXXXOOOXOXOXOOOOOOXOOOXXXOXX", "XOOOXOXXXOOXXXOXOXOXOOOOOXOXOXOOOOOXOXOX", "XXXXXXXOOOXXOOOXXOOOXXXOXOXOXXXOOXXXOOXX", "XXOXOOXXOXXXXXXXOOOXXXXXXXOXOOXXXXXOOOOO", "OOXOOOXXXOOXOXOOOXOOOOXOOOXOXOOXXXOOOXOO", "XXXXXXXOXXXXOXXXXOXXXOOOXXXOXXOXOXOOOOOO", "OOOOOOXXXOOXXXOOXOXOOXOXOOXXXOOXXXOOOOOO", "OOOOOXXXOXXXOXXXXXOXOOOOOOXXXXOXXXXOXOOO", "XXXXOXXXOXXXOXXOOXOOOXOXOOXXXOOXXXOOOOOO", "XOXOXOXOOXXXXXXOXOXOOXOXOXXXXXOXOOXXOXOX", "XOXOXOXXXOOXXXOXOOOXOXXXOOOXOOOXXXOXOOOX", "XOXOXXOXOXXXOXXXOXOXOXOXOOXXXOXOXOXXXOXX", "OXOXOOXOXOOXOXOOXOXOOXOXOOXOXOOXOXOOXOXO", "OOOOOXXXXXOOOOOXXXXXOOOOOXXXXXOOOOOXXXXX", "XXOXXXXOXXXXOXXXXOXXXXOXXXXOXXXXXXXXXOXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXOXXXXXXXXXOXXXXOXXXXOXXXXOXXXXOXXXXOXX", "OXOXOOOOOOOXOXOOOOOOOXOXOOOOOOOXOXOOOOOO", "OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO", "XOXOXOXOXOXOXOXXXXXXOXOXOOOOOOXOXOXXXOXX", "OOOOOOXXXOOXXXOOXXXOOXXXOOXXXOOXXXOOOOOO", "XXOXXXXXXXXXOXXXXOXXXOXXXOXXXXOXXXOXOOOX", "XOXOXXXOXXXOXOXXXXXXXXXXXXOXOXXXOXXXOXOX", "OOOOOXXOXXXXOXXOOOOOXXOXXOOOOOOXXXOOOOOO", "OOOOXOXXXOOXXXOOOOOXOXXXXOXXXXOXXXXOXXXX", "OXXXOOOXOOOXOXOOXXXOOXXXOOXXXOOXXXOOXXXO", "XXXXXXOXOXXOXOXXXXXXXXXXXXOOOXOXXXOXXXXX", "XXOXXXOXOXOXXXOXXOXXXXOXXOXXXOXOXOXXXOXX", "XXOXXXOXOXOXXXOOOOOOOOOOOOXXXOXOXOXXXOXX", "OOOOXOXXXOOXXXOOOOOXOXXXOOXXXOOXXXOOOOOX", "XXOXXXOOXXOXOXXXXOXXXXOXXXXOXXXXOXXOOOOO", "OXXXOOXXXOOXXXOOXXXOOXXXOOXXXOOXXXOXOOOX", "XXXXXXXXXXXOXOXXOXOXXXXXXOOOOOXOOOXXXXXX", "OXXXOOXXOXOXOXXOOXXXOXOXXOXXOXOXXOXOXXXO", "XXOXXXXOXXXXOXXXXOXXXXOXXOXOXOXOOOXXXOXX", "OOOOXOXXXOOXXXOOOOOXOOXXXOXOXXOXXOXOXXXO", "OOOOOXXOXXXXOXXXXOXXXXOXXXXOXXXXOXXXXOXX", "XXXXXXOXOXXOXOXXXXXXXXXXXOXXXOXOOOXXXXXX", "XOOOXOXXXOOXXXOOXXXOOXXXOOXOXOXOOOXXXXOO", "XOOOXOXXXOOXXXXXOOOXXXXXOXXXXOOXXXOXOOOX", "XXXOXXXOXXXOXXXXXOXXXXXOXXXOXXXOXXXXXOXX", "XOOOXOXOXOOOOOOOXOXOOXOXOOOXOOOXOXOXOOOX", "XOOOXOXXXOOXXXOOOOOOOXXXOOXXXOOXXXOOXXXO", "OOOOOXXXXOXXXOXXXXOXXXOXXXXOXXXOXXXXOXXX", "OXXXOOXXXOOXXXOOOOOOXXXXOXXXXOXXXXOXXXXO", "XXXXXXXXXXXXXXXXXXXOXXXOOXXOOOXOOOOOOOOO", "OOOOOOXXXXOXXXXOOOOXOXXXXOXXXXOXXXXOXXXX", "XOOOXOXXXOOXXXXOXXXXOXOOOOXXXOOXXXOXOOOX", "OOOOOXXXXXXOOOXOXXXOXOOOXXOOOXOXXXOXOOOX", "XOOOXOXXXXOXXXXOXXXXOOOOXOXXXOOXXXOXOOOX", "OOXOOOXOXOXOXOXOXXXOOXXXOXOXOXOXOXOOOXOO", "XOOOXOXXXOOOOOOXXXXXOXXXOXOOOXOXXXOXOOOX", "OOOOOXXXXOXXXOXXXOXXXXOXXXOXXXOXXXXOOOOO", "OXXXOXOXOXXOXOXXXOXXXXOXXXXOXXXXOXXXXOXX", "XOOOXOXXOOOXOXOOXOXOOXOXOOXOXOOOXXOXOOOX", "XOOOXOXXXOOXXXOOXOXOOXOXOOXXXOOXXXOXOOOX", "XXOXXXOXOXXOXOXOXXXOOXXXOXOXOXXOXOXXXOXX", "XOOOXOXXXOOXXXOXOOOOXXXXOXXXXOXXXXOXXXXO", "OOOOOXOXOXXOXOXXOXOXXOXOXXOXOXXOXOXOOOOO", "OOOOOXOXOXOOOOOXOXOXOOOOOXOXOXOOOOOXOXOX", "XOOOXOXXXOOXXXXOXXXXOXXXXOXXXXOXXXOXOOOX", "OXOXOOXOXOXOXOXXXXXXXXXXXXOXOXOXOXOOXOXO", "XXXXOXXXOXXXOXXOOOXXXXOXXXXOXXXXOXXXXOXX", "XXXXXOOOOOOXXXOOOXOOOXXXOOOOOOOXXXOOOOOO", "OOOOOOXXXXOXXXXOOOOXOXXXXOXXXXOXXXXOOOOO", "OXOXOOXOXOXOXOXXOXOXOXOXOOXOXOXOXOXXOXOX", "OOXOOOXXXOOXXXOOXXXOOXXXOOXXXOOXXXOOOXOO", "XXXXXXXOXXXXOXXXOXOXXOXOXOXXXOOXXXOOOOOO", "OXXXOOXXXOOXXXOOOOOOOXXXOOXXXOOXXXOOXXXO", "OOOOOOOXOOOXOXOOXXXOOXXXOOXOXOOOXOOOOOOO", "OOOOOOXXXXOXXXXOOOOXXXXXOXXXXOXXXXOOOOOX", "XXOXXXOOOXOXOXOXXOXXXXOXXOXOXOXOOOXXXOXX", "XXOXXOOOOOOXOXOOXOXOOOOOOXXOXXXXOXXXXOXX", "XXXXXXXOXXXOXOXXXOXXXXOXXXOXOXXXOXXXXXXX", "OXXXOOOXXOOXOXOOXOXOOXXOOOXXXOOXXXOOXXXO", "OXXXOOXXXOOXXXOOXXXOOXXXOOXXXOXOXOXXXOXX", "OOOOXOXXXOOXXXOOXXXOOXXXOOXXXOOXXXOOOOOX", "XOXOXOXOXOOXOXOOXOXOOXOXOOXOXOOXOXOXOXOX", "XOOOXXOXOXXOOOXXOXOXXOXOXXOXOXXOOOXXXOXX", "OXXXOXOXOXXOXOXXXOXXXXOXXXOXOXXOXOXOXXXO", "XXOXXXOOOXOOOOOXXOXXXXOXXXOOOXOOOOOOXXXO", "OXXXXOXXXXOXXXXOXXXXOXXXXOXXXXOXXXXOOOOO", "XOOOXOOXOOOXOXOOOXOOOXOXOOOXOOOXOXOOOOOO", "XOOOXOXXXOXXXXOXXXOXXXOXXXOXXXOXXXXOOOOO", "XOOOXOXXXOOXXXOXOOOXOXXXOOXXXOOXXXOXOOOX", "OOOOOOXOXOOOXOOOXOXOOXOXOOOXOOOXOXOOOOOO", "XOOOXOXXXOOXXXOOXXXOOXXXOOXXXOOXXXOXOOOX", "OXXXOOXXXOOXXXOOXXXOOXOXOOXOXOOXOXOXOXOX", "OXOXOXOXOXXOXOXXXOXXXXOXXXOXOXXOXOXOXOXO", "OOOOOXXOXXXXOXXXXOXXXXOXXXXOXXXXOXXOOOOO", "XXXXXXXOXXXOOOXOXXXOOOOOOOXXXOOXXXOOOOOO", "XXOXXXOXOXXOXOXXXOXXOXXXOXOXOXXXOXXXXOXX", "XXXOXXXXOXOOOOOXXOOXXOXOXOXXOXXXXOXXXXOX", "OOOOXXXXOXXXXOXXXXOXXXXOXXXXOXOXXOXXOOXX", "XXOXXXOOOXOXOXOXXOXXXXOXXXXOXXXXOXXXXOXX" }; selectLetter = Random.Range(0, intLetter.Length); var onSqrCount = intLetter[selectLetter].Count(x => x == 'O'); var offSqrCount = intLetter[selectLetter].Count(x => x == 'X'); rnd = RuleSeedable.GetRNG(); Debug.LogFormat(@"[Shapes Bombs #{0}] Using rule seed: {1}", moduleId, rnd.Seed); char[] intFullLetter = { 'A', 'B', 'D', 'E', 'G', 'I', 'K', 'L', 'N', 'O', 'P', 'S', 'T', 'X', 'Y' }; int[] chooseSequence = { Array.FindIndex(intFullLetter, x => x.Equals(moduleLetters[selectLetter])), BombInfo.GetModuleNames().Count, onSqrCount, offSqrCount, 0 }; int[] sequenceTables = new int[5]; string[] letterTables = Enumerable.Repeat("", 5).ToArray(); intShape = chooseShapes.Take(20).ToArray(); if (rnd.Seed == 1) { chooseSequence.CopyTo(sequenceTables, 0); letterTables = new[] { "KEPTALINGDOBYXS", "KINGSLEDYOPXTAB", "ONSLYPKIDTXBAEG", "ABDEGIKLNOPSTXY", "YXTSPONLKIGEDBA" }; } else if (rnd.Seed == 333) { for (int i = 0; i < sequenceTables.Length; i++) { sequenceTables[i] = 3; } for (int i = 0; i < letterTables.Length; i++) { for (int j = 0; j < 15; j++) { letterTables[i] += "K"; } } for (int i = 0; i < intShape.Length; i++) { intShape[i] = chooseShapes[3]; } } else { for (int i = 0; i < intFullLetter.Length; i++) { intFullLetter[i] = moduleLetters[ChooseUnique(15)]; } chooseSequence[0] = Array.FindIndex(intFullLetter, x => x.Equals(moduleLetters[selectLetter])); chooseSequence[4] = rnd.Next(15); pickedValues.Clear(); for (int i = 0; i < sequenceTables.Length; i++) { sequenceTables[i] = chooseSequence[ChooseUnique(5)]; } for (int i = 0; i < letterTables.Length; i++) { pickedValues.Clear(); for (int j = 0; j < 15; j++) { letterTables[i] += moduleLetters[ChooseUnique(15)].ToString(); } } pickedValues.Clear(); for (int i = 0; i < intShape.Length; i++) { intShape[i] = chooseShapes[ChooseUnique(100)]; } } myShape = intLetter[selectLetter]; modLetter = myShape; ArrowScreen.transform.GetComponent <Renderer>().material = BlackMat; NumScreen.transform.GetChild(0).GetComponent <TextMesh>().text = ""; int[] arrowDirVal = { 0, 1, -5, -1, 5, -4, 6, -6, 4 }; var logArrows = ""; for (int i = 0; i < chooseArrows.Length; i++) { chooseArrows[i] = Random.Range(0, arrowDirVal.Length); logArrows += new[] { "Center", "Right", "Up", "Left", "Down", "Right-Up", "Right-Down", "Up-Left", "Left-Down" }[chooseArrows[i]] +" (" + i + ") "; } ColScreen.SetActive(ColorblindMode.ColorblindModeActive); Debug.LogFormat(@"[Shapes Bombs #{0}] Initial letter is: {1}", moduleId, moduleLetters[selectLetter]); Debug.LogFormat(@"[Shapes Bombs #{0}] Color for the squares is: {1}", moduleId, choseColor[chooseRndColor]); Debug.LogFormat(@"[Shapes Bombs #{0}] Arrow sequence is: {1}", moduleId, logArrows); if (!buttonsColor.Equals(Color.white)) { var selectTable = letterTables[chooseRndColor]; var intStartSequence = sequenceTables[chooseRndColor]; var tableStartSequence = intStartSequence % 15; var nowLetter = Array.FindIndex(selectTable.ToCharArray(), x => x.Equals(moduleLetters[selectLetter])); for (int i = 0; i < chooseArrows.Length; i++) { if (i >= tableStartSequence) { nowLetter = GetWrapedTable(nowLetter, arrowDirVal[chooseArrows[i]], selectTable.Length, 3); } } var endSequence = Array.FindIndex(intFullLetter, x => x.Equals(selectTable[nowLetter])); Debug.LogFormat(@"[Shapes Bombs #{0}] Initial number of table is: {1}", moduleId, intStartSequence); Debug.LogFormat(@"[Shapes Bombs #{0}] Starting table arrow sequence at: {1}", moduleId, tableStartSequence); Debug.LogFormat(@"[Shapes Bombs #{0}] Letter table is:", moduleId); InputLogShape(selectTable); Debug.LogFormat(@"[Shapes Bombs #{0}] Ended table at letter: {1}", moduleId, selectTable[nowLetter]); var nowSquare = Math.Clamp(intStartSequence, 0, ModuleButtons.Length - 1); Debug.LogFormat(@"[Shapes Bombs #{0}] Initial square location is: {1}", moduleId, nowSquare + 1); Debug.LogFormat(@"[Shapes Bombs #{0}] Module starting arrow sequence at: {1}", moduleId, endSequence); for (int i = endSequence; i < chooseArrows.Length; i++) { nowSquare = GetWrapedTable(nowSquare, arrowDirVal[chooseArrows[i]] * ((modLetter[nowSquare].Equals('O')) ? 1 : -1), ModuleButtons.Length, 5); var addChar = (modLetter[nowSquare].Equals('O')) ? "X" : "O"; modLetter = modLetter.Remove(nowSquare, 1); modLetter = modLetter.Insert(nowSquare, addChar); } } getCount = ((x, y) => x.Count(z => z == y)); countUnlit = (int.Parse(BombInfo.GetSerialNumber()[5].ToString())) % 2 == 1; countHalf = ((Array.FindIndex(intFullLetter, x => x.Equals(moduleLetters[selectLetter]))) % 2 == 0); UpdateSolution(); var nowHalf = new String(((countHalf)) ? modLetter.Take(20).ToArray() : modLetter.Skip(20).ToArray()); var nowCount = getCount(nowHalf, (countUnlit) ? 'X' : 'O'); Debug.LogFormat(@"[Shapes Bombs #{0}] Counting {1} squares", moduleId, (countUnlit) ? "unlit" : "lit"); Debug.LogFormat(@"[Shapes Bombs #{0}] The final {1} square count in the {2}-half is: {3}", moduleId, (countUnlit) ? "unlit" : "lit", (countHalf) ? "upper" : "bottom", nowCount); Debug.LogFormat(@"[Shapes Bombs #{0}] Even solved modules final shape is:", moduleId); InputLogShape(intShape[Math.Clamp(nowCount, 5, 14) - 5]); Debug.LogFormat(@"[Shapes Bombs #{0}] Odd solved modules final shape is:", moduleId); InputLogShape(intShape[(Math.Clamp(nowCount, 5, 14) + 10) - 5]); var lightScalar = transform.lossyScale.x; for (int i = 0; i < ModuleButtons.Length; i++) { ModuleButtons[i].transform.GetComponent <Renderer>().material.color = buttonOFF; var nowLight = buttonLight[i] = ((i == 0) ? LightTemp : Instantiate(LightTemp)); nowLight.name = "ButtonLight" + i; nowLight.transform.parent = ModuleButtons[i].transform; nowLight.transform.localPosition = new Vector3(0.0f, 0.8f, 0.0f); nowLight.transform.localScale = new Vector3(1.0f, 1.0f, 1.0f); nowLight.range = 0.01f * lightScalar; nowLight.intensity = 0.0f; int j = i; ModuleButtons[i].OnInteract += delegate() { OnButtonPress(j, true); return(false); }; } NumScreen.OnInteract += delegate() { BombAudio.PlayGameSoundAtTransform(KMSoundOverride.SoundEffect.ButtonPress, NumScreen.transform); if (arrowCoroutine != null) { StopCoroutine(arrowCoroutine); arrowCoroutine = StartCoroutine(SetArrowScreen()); } return(false); }; KMSelectable[] sideButtons = { ResetButton, EmptyButton, SubmitButton }; for (int i = 0; i < sideButtons.Length; i++) { int j = i; sideButtons[i].transform.GetComponent <Renderer>().material.color = new Color32(239, 228, 176, 255); sideButtons[i].OnInteract += delegate() { BombAudio.PlayGameSoundAtTransform(KMSoundOverride.SoundEffect.ButtonPress, sideButtons[j].transform); ModuleSelect.AddInteractionPunch(0.75f); switch (j) { case 0: case 1: if (nowCoroutine == null && subCoroutine == null) { nowCoroutine = StartCoroutine(((j == 0) ? ResetLetter(intLetter[selectLetter]) : EmptyLights())); } break; default: if (!moduleSolved && nowCoroutine == null && subCoroutine == null) { if (myShape.Equals(shapeSolution)) { StopAllCoroutines(); Debug.LogFormat(@"[Shapes Bombs #{0}] Module solved!", moduleId); BombAudio.PlaySoundAtTransform("CorrectShape", transform); ArrowScreen.transform.GetComponent <Renderer>().material = BlackMat; NumScreen.transform.GetChild(0).GetComponent <TextMesh>().text = ""; moduleSolved = true; BombModule.HandlePass(); } else { var solvedModsEven = (solvedMods % 2 == 0); Debug.LogFormat(@"[Shapes Bombs #{0}] Current shape doesn't equal to the {1} final shape.", moduleId, solvedModsEven ? "even" : "odd"); Debug.LogFormat(@"[Shapes Bombs #{0}] Current shape:", moduleId); InputLogShape(myShape); BombModule.HandleStrike(); } subCoroutine = StartCoroutine(CheckSubmit()); } break; } return(false); }; } BombModule.OnActivate += Activate; }
public void BuildCompactField() { AstarProfiler.StartProfile("Build Compact Voxel Field"); //Build compact representation int spanCount = voxelArea.GetSpanCount(); voxelArea.compactSpanCount = spanCount; if (voxelArea.compactSpans == null || voxelArea.compactSpans.Length < spanCount) { voxelArea.compactSpans = new CompactVoxelSpan[spanCount]; voxelArea.areaTypes = new int[spanCount]; } uint idx = 0; int w = voxelArea.width; int d = voxelArea.depth; int wd = w * d; if (this.voxelWalkableHeight >= 0xFFFF) { Debug.LogWarning("Too high walkable height to guarantee correctness. Increase voxel height or lower walkable height."); } #if !ASTAR_RECAST_CLASS_BASED_LINKED_LIST LinkedVoxelSpan[] spans = voxelArea.linkedSpans; #endif //Parallel.For (0, voxelArea.depth, delegate (int pz) { for (int z = 0, pz = 0; z < wd; z += w, pz++) { for (int x = 0; x < w; x++) { #if !ASTAR_RECAST_CLASS_BASED_LINKED_LIST int spanIndex = x + z; if (spans[spanIndex].bottom == VoxelArea.InvalidSpanValue) { voxelArea.compactCells[x + z] = new CompactVoxelCell(0, 0); continue; } uint index = idx; uint count = 0; //Vector3 p = new Vector3(x,0,pz)*cellSize+voxelOffset; while (spanIndex != -1) { if (spans[spanIndex].area != UnwalkableArea) { int bottom = (int)spans[spanIndex].top; int next = spans[spanIndex].next; int top = next != -1 ? (int)spans[next].bottom : VoxelArea.MaxHeightInt; voxelArea.compactSpans[idx] = new CompactVoxelSpan((ushort)(bottom > 0xFFFF ? 0xFFFF : bottom), (uint)(top - bottom > 0xFFFF ? 0xFFFF : top - bottom)); voxelArea.areaTypes[idx] = spans[spanIndex].area; idx++; count++; } spanIndex = spans[spanIndex].next; } voxelArea.compactCells[x + z] = new CompactVoxelCell(index, count); #else VoxelSpan s = voxelArea.cells[x + z].firstSpan; if (s == null) { voxelArea.compactCells[x + z] = new CompactVoxelCell(0, 0); continue; } uint index = idx; uint count = 0; //Vector3 p = new Vector3(x,0,pz)*cellSize+voxelOffset; while (s != null) { if (s.area != UnwalkableArea) { int bottom = (int)s.top; int top = s.next != null ? (int)s.next.bottom : VoxelArea.MaxHeightInt; voxelArea.compactSpans[idx] = new CompactVoxelSpan((ushort)Mathf.Clamp(bottom, 0, 0xffff), (uint)Mathf.Clamp(top - bottom, 0, 0xffff)); voxelArea.areaTypes[idx] = s.area; idx++; count++; } s = s.next; } voxelArea.compactCells[x + z] = new CompactVoxelCell(index, count); #endif } } AstarProfiler.EndProfile("Build Compact Voxel Field"); }
public void VoxelizeInput(GraphTransform graphTransform, Bounds graphSpaceBounds) { AstarProfiler.StartProfile("Build Navigation Mesh"); AstarProfiler.StartProfile("Voxelizing - Step 1"); // Transform from voxel space to graph space. // then scale from voxel space (one unit equals one voxel) // Finally add min PF.Matrix4x4 voxelMatrix = PF.Matrix4x4.TRS(graphSpaceBounds.min, PF.Quaternion.identity, Vector3.one) * PF.Matrix4x4.Scale(new PF.Vector3(cellSize, cellHeight, cellSize)); transformVoxel2Graph = new GraphTransform(voxelMatrix); // Transform from voxel space to world space // add half a voxel to fix rounding transform = graphTransform * voxelMatrix * PF.Matrix4x4.TRS(new Vector3(0.5f, 0, 0.5f), PF.Quaternion.identity, Vector3.one); int maximumVoxelYCoord = (int)(graphSpaceBounds.size.y / cellHeight); AstarProfiler.EndProfile("Voxelizing - Step 1"); AstarProfiler.StartProfile("Voxelizing - Step 2 - Init"); // Cosine of the slope limit in voxel space (some tweaks are needed because the voxel space might be stretched out along the y axis) float slopeLimit = Mathf.Cos(Mathf.Atan(Mathf.Tan(maxSlope * Mathf.Deg2Rad) * (cellSize / cellHeight))); // Temporary arrays used for rasterization float[] vTris = new float[3 * 3]; float[] vOut = new float[7 * 3]; float[] vRow = new float[7 * 3]; float[] vCellOut = new float[7 * 3]; float[] vCell = new float[7 * 3]; if (inputMeshes == null) { throw new System.NullReferenceException("inputMeshes not set"); } // Find the largest lengths of vertex arrays and check for meshes which can be skipped int maxVerts = 0; for (int m = 0; m < inputMeshes.Count; m++) { maxVerts = System.Math.Max(inputMeshes[m].vertices.Length, maxVerts); } // Create buffer, here vertices will be stored multiplied with the local-to-voxel-space matrix var verts = new Vector3[maxVerts]; AstarProfiler.EndProfile("Voxelizing - Step 2 - Init"); AstarProfiler.StartProfile("Voxelizing - Step 2"); // This loop is the hottest place in the whole rasterization process // it usually accounts for around 50% of the time for (int m = 0; m < inputMeshes.Count; m++) { RasterizationMesh mesh = inputMeshes[m]; var meshMatrix = mesh.matrix; // Flip the orientation of all faces if the mesh is scaled in such a way // that the face orientations would change // This happens for example if a mesh has a negative scale along an odd number of axes // e.g it happens for the scale (-1, 1, 1) but not for (-1, -1, 1) or (1,1,1) var flipOrientation = UnityHelper.ReversesFaceOrientations(meshMatrix); Vector3[] vs = mesh.vertices; int[] tris = mesh.triangles; int trisLength = mesh.numTriangles; // Transform vertices first to world space and then to voxel space for (int i = 0; i < vs.Length; i++) { verts[i] = transform.InverseTransform(meshMatrix.MultiplyPoint3x4(vs[i])); } int mesharea = mesh.area; for (int i = 0; i < trisLength; i += 3) { Vector3 p1 = verts[tris[i]]; Vector3 p2 = verts[tris[i + 1]]; Vector3 p3 = verts[tris[i + 2]]; if (flipOrientation) { var tmp = p1; p1 = p3; p3 = tmp; } int minX = (int)(Utility.Min(p1.x, p2.x, p3.x)); int minZ = (int)(Utility.Min(p1.z, p2.z, p3.z)); int maxX = (int)System.Math.Ceiling(Utility.Max(p1.x, p2.x, p3.x)); int maxZ = (int)System.Math.Ceiling(Utility.Max(p1.z, p2.z, p3.z)); minX = Mathf.Clamp(minX, 0, voxelArea.width - 1); maxX = Mathf.Clamp(maxX, 0, voxelArea.width - 1); minZ = Mathf.Clamp(minZ, 0, voxelArea.depth - 1); maxZ = Mathf.Clamp(maxZ, 0, voxelArea.depth - 1); // Check if the mesh is completely out of bounds if (minX >= voxelArea.width || minZ >= voxelArea.depth || maxX <= 0 || maxZ <= 0) { continue; } Vector3 normal; int area; //AstarProfiler.StartProfile ("Rasterize..."); normal = Vector3.Cross(p2 - p1, p3 - p1); float cosSlopeAngle = Vector3.Dot(normal.normalized, Vector3.up); if (cosSlopeAngle < slopeLimit) { area = UnwalkableArea; } else { area = 1 + mesharea; } Utility.CopyVector(vTris, 0, p1); Utility.CopyVector(vTris, 3, p2); Utility.CopyVector(vTris, 6, p3); for (int x = minX; x <= maxX; x++) { int nrow = clipper.ClipPolygon(vTris, 3, vOut, 1F, -x + 0.5F, 0); if (nrow < 3) { continue; } nrow = clipper.ClipPolygon(vOut, nrow, vRow, -1F, x + 0.5F, 0); if (nrow < 3) { continue; } float clampZ1 = vRow[2]; float clampZ2 = vRow[2]; for (int q = 1; q < nrow; q++) { float val = vRow[q * 3 + 2]; clampZ1 = System.Math.Min(clampZ1, val); clampZ2 = System.Math.Max(clampZ2, val); } int clampZ1I = Mathf.Clamp((int)System.Math.Round(clampZ1), 0, voxelArea.depth - 1); int clampZ2I = Mathf.Clamp((int)System.Math.Round(clampZ2), 0, voxelArea.depth - 1); for (int z = clampZ1I; z <= clampZ2I; z++) { //AstarProfiler.StartFastProfile(1); int ncell = clipper.ClipPolygon(vRow, nrow, vCellOut, 1F, -z + 0.5F, 2); if (ncell < 3) { //AstarProfiler.EndFastProfile(1); continue; } ncell = clipper.ClipPolygonY(vCellOut, ncell, vCell, -1F, z + 0.5F, 2); if (ncell < 3) { //AstarProfiler.EndFastProfile(1); continue; } //AstarProfiler.EndFastProfile(1); //AstarProfiler.StartFastProfile(2); float sMin = vCell[1]; float sMax = vCell[1]; for (int q = 1; q < ncell; q++) { float val = vCell[q * 3 + 1]; sMin = System.Math.Min(sMin, val); sMax = System.Math.Max(sMax, val); } //AstarProfiler.EndFastProfile(2); int maxi = (int)System.Math.Ceiling(sMax); // Skip span if below or above the bounding box if (maxi >= 0 && sMin <= maximumVoxelYCoord) { // Make sure mini >= 0 int mini = System.Math.Max(0, (int)sMin); // Make sure the span is at least 1 voxel high maxi = System.Math.Max(mini + 1, maxi); voxelArea.AddLinkedSpan(z * voxelArea.width + x, (uint)mini, (uint)maxi, area, voxelWalkableClimb); } } } } //AstarProfiler.EndFastProfile(0); //AstarProfiler.EndProfile ("Rasterize..."); } AstarProfiler.EndProfile("Voxelizing - Step 2"); }
private float BrightnessToMorphValue(float brightness) { return(-1 * Math.Clamp(PupilNeutralValue + Math.Lerp(-1.0f, 1.5f, brightness), -1.0f, 1.5f)); }
public static Color HSVToRGB(float H, float S, float V, bool hdr) { Color white = Color.white; if (S == 0f) { white.r = V; white.g = V; white.b = V; } else if (V == 0f) { white.r = 0f; white.g = 0f; white.b = 0f; } else { white.r = 0f; white.g = 0f; white.b = 0f; float num = H * 6f; int num2 = (int)Mathf.Floor(num); float num3 = num - (float)num2; float num4 = V * (1f - S); float num5 = V * (1f - S * num3); float num6 = V * (1f - S * (1f - num3)); int num7 = num2; switch (num7 + 1) { case 0: white.r = V; white.g = num4; white.b = num5; break; case 1: white.r = V; white.g = num6; white.b = num4; break; case 2: white.r = num5; white.g = V; white.b = num4; break; case 3: white.r = num4; white.g = V; white.b = num6; break; case 4: white.r = num4; white.g = num5; white.b = V; break; case 5: white.r = num6; white.g = num4; white.b = V; break; case 6: white.r = V; white.g = num4; white.b = num5; break; case 7: white.r = V; white.g = num6; white.b = num4; break; } if (!hdr) { white.r = Mathf.Clamp(white.r, 0f, 1f); white.g = Mathf.Clamp(white.g, 0f, 1f); white.b = Mathf.Clamp(white.b, 0f, 1f); } } return(white); }