public static Clamp ( double v, double l, double h ) : double | ||
v | double | |
l | double | |
h | double | |
리턴 | double |
internal override void Draw(SpriteBatch _, GameTime gameTime) { spriteBatch.Begin(SpriteSortMode.Immediate, BlendState.NonPremultiplied); var lanIpSize = game.Fonts.Get(MonoGame_Engine.Font.DebugFont).MeasureString(lanIp); spriteBatch.DrawString(game.Fonts.Get(MonoGame_Engine.Font.DebugFont), lanIp, new Vector2((game.Screen.CanvasWidth - lanIpSize.X) / 2, game.Screen.CanvasHeight - 20), Color.White); for (int i = 0; i < 4; i++) { pos[i].X = i % 2 == 0 ? ScreenBorder : game.Screen.CanvasWidth - ScreenBorder - chars[i].Width; pos[i].Y = i / 2 == 0 ? ScreenBorder : game.Screen.CanvasHeight - ScreenBorder - chars[i].Height; if (game.MainScene.Players.Count > i) { var player = game.MainScene.Players[i]; var fx = i % 2 == 0 ? SpriteEffects.None : SpriteEffects.FlipHorizontally; var alpha = (gameTime.TotalGameTime.TotalMilliseconds % 300 < 150) ? 0.2f : 1.0f; var color = new Color(1f, 1f, 1f, player.IsInvincible ? alpha : 1f); spriteBatch.Draw(chars[i], pos[i], null, color, 0, Vector2.Zero, Vector2.One, fx, 0); if (!player.IsAlive) { var text = "You died!\r\nPress Button to join"; var textPosXOffset = i % 2 == 0 ? pos[i].X + chars[i].Width : pos[i].X; var textPosYOffset = i / 2 == 0 ? pos[i].Y : pos[i].Y + chars[i].Height - chars[2].Height; DrawTextBox(i, spriteBatch, text, new Vector2(textPosXOffset, textPosYOffset), new Color(player.BaseColor, alpha)); } else if (player.EventTextTime > TimeSpan.Zero) { player.EventTextTime -= gameTime.ElapsedGameTime; var textPosXOffset = i % 2 == 0 ? pos[i].X + chars[i].Width : pos[i].X; var textPosYOffset = i / 2 == 0 ? pos[i].Y : pos[i].Y + chars[i].Height - chars[2].Height; DrawTextBox(i, spriteBatch, player.EventText, new Vector2(textPosXOffset, textPosYOffset), player.BaseColor); } } } const float minDistance = 2000; const float blendInMagic = 0.1f; float offset = MathHelper.Clamp((this.distanceToMotherShip - (minDistance)), -100 / blendInMagic, 0) * blendInMagic; //if (distanceToMotherShip > minDistance) { const float preMultiplier = 0.0005f; const float postMultiplier = 200f; const float log = 5; const float max = 400; var position = (float)Math.Log(distanceToMotherShip * preMultiplier, log) * postMultiplier; position = MathHelper.Clamp(position, 0, max); var left = game.Screen.CanvasWidth / 2 - max / 2; var rigth = game.Screen.CanvasWidth / 2 + max / 2; var indicator = position + left; spriteBatch.Draw(distanceScale, new Vector2(left, offset)); distanceMarker.Draw(spriteBatch, new Vector2(indicator, offset + distanceMarker.Height / 2), 0f); } if (game.MainScene.Players.Count == 0) { Title.Draw(spriteBatch, gameTime); } spriteBatch.End(); }
protected override void Update() { base.Update(); border.Alpha = (float)MathHelper.Clamp((HitObject.StartTime - Time.Current) / 500, 0, 1); }
private static void UpdateWaterFlowSounds(float deltaTime) { if (FlowSounds.Count == 0) { return; } float[] targetFlowLeft = new float[FlowSounds.Count]; float[] targetFlowRight = new float[FlowSounds.Count]; Vector2 listenerPos = new Vector2(GameMain.SoundManager.ListenerPosition.X, GameMain.SoundManager.ListenerPosition.Y); foreach (Gap gap in Gap.GapList) { Vector2 diff = gap.WorldPosition - listenerPos; if (Math.Abs(diff.X) < FlowSoundRange && Math.Abs(diff.Y) < FlowSoundRange) { if (gap.Open < 0.01f) { continue; } float gapFlow = Math.Abs(gap.LerpedFlowForce.X) + Math.Abs(gap.LerpedFlowForce.Y) * 2.5f; if (!gap.IsRoomToRoom) { gapFlow *= 2.0f; } if (gapFlow < 10.0f) { continue; } if (gap.linkedTo.Count == 2 && gap.linkedTo[0] is Hull hull1 && gap.linkedTo[1] is Hull hull2) { //no flow sounds between linked hulls (= rooms consisting of multiple hulls) if (hull1.linkedTo.Contains(hull2)) { continue; } if (hull1.linkedTo.Any(h => h.linkedTo.Contains(hull1) && h.linkedTo.Contains(hull2))) { continue; } if (hull2.linkedTo.Any(h => h.linkedTo.Contains(hull1) && h.linkedTo.Contains(hull2))) { continue; } } int flowSoundIndex = (int)Math.Floor(MathHelper.Clamp(gapFlow / MaxFlowStrength, 0, FlowSounds.Count)); flowSoundIndex = Math.Min(flowSoundIndex, FlowSounds.Count - 1); float dist = diff.Length(); float distFallOff = dist / FlowSoundRange; if (distFallOff >= 0.99f) { continue; } //flow at the left side if (diff.X < 0) { targetFlowLeft[flowSoundIndex] += 1.0f - distFallOff; } else { targetFlowRight[flowSoundIndex] += 1.0f - distFallOff; } } } for (int i = 0; i < FlowSounds.Count; i++) { flowVolumeLeft[i] = (targetFlowLeft[i] < flowVolumeLeft[i]) ? Math.Max(targetFlowLeft[i], flowVolumeLeft[i] - deltaTime) : Math.Min(targetFlowLeft[i], flowVolumeLeft[i] + deltaTime * 10.0f); flowVolumeRight[i] = (targetFlowRight[i] < flowVolumeRight[i]) ? Math.Max(targetFlowRight[i], flowVolumeRight[i] - deltaTime) : Math.Min(targetFlowRight[i], flowVolumeRight[i] + deltaTime * 10.0f); if (flowVolumeLeft[i] < 0.05f && flowVolumeRight[i] < 0.05f) { if (flowSoundChannels[i] != null) { flowSoundChannels[i].Dispose(); flowSoundChannels[i] = null; } } else { Vector2 soundPos = new Vector2(GameMain.SoundManager.ListenerPosition.X + (flowVolumeRight[i] - flowVolumeLeft[i]) * 100, GameMain.SoundManager.ListenerPosition.Y); if (flowSoundChannels[i] == null || !flowSoundChannels[i].IsPlaying) { flowSoundChannels[i] = FlowSounds[i].Play(1.0f, FlowSoundRange, soundPos); flowSoundChannels[i].Looping = true; } flowSoundChannels[i].Gain = Math.Max(flowVolumeRight[i], flowVolumeLeft[i]); flowSoundChannels[i].Position = new Vector3(soundPos, 0.0f); } } }
/// <summary> /// Sets the vibration motor speeds on the controller device if supported. /// </summary> /// <param name="index">Index for the controller you want to query.</param> /// <param name="leftMotor">The speed of the left motor, between 0.0 and 1.0. This motor is a low-frequency motor.</param> /// <param name="rightMotor">The speed of the right motor, between 0.0 and 1.0. This motor is a high-frequency motor.</param> /// <param name="leftTrigger">(Xbox One controller only) The speed of the left trigger motor, between 0.0 and 1.0. This motor is a high-frequency motor.</param> /// <param name="rightTrigger">(Xbox One controller only) The speed of the right trigger motor, between 0.0 and 1.0. This motor is a high-frequency motor.</param> /// <returns>Returns true if the vibration motors were set.</returns> public static bool SetVibration(int index, float leftMotor, float rightMotor, float leftTrigger, float rightTrigger) { if (index < 0 || index >= PlatformGetMaxNumberOfGamePads()) { return(false); } return(PlatformSetVibration(index, MathHelper.Clamp(leftMotor, 0.0f, 1.0f), MathHelper.Clamp(rightMotor, 0.0f, 1.0f), MathHelper.Clamp(leftTrigger, 0.0f, 1.0f), MathHelper.Clamp(rightTrigger, 0.0f, 1.0f))); }
private void LockCmaera() { _position.X = MathHelper.Clamp(Position.X, 0, TileMap.WidthInPixels - _viewportRectangle.Width); _position.Y = MathHelper.Clamp(Position.Y, 0, TileMap.HeightInPixels - _viewportRectangle.Height); }
public int Parse(byte[] buf, int at, int length) { #if Full_API var start = at + 1 /*Skip player id */; // var playerId = (int)buf[at++]; // if (Main.netMode == 2) // { // num6 = bufferId; // } SkinVariant = (int)MathHelper.Clamp((float)buf[start++], 0, 7); Hair = (int)buf[start++]; if (Hair >= 134) { Hair = 0; } int len = 0; while (true) { len += buf[start] & 0x7F; if (buf[start++] > 127) { len <<= 7; } else { break; } } Name = System.Text.Encoding.UTF8.GetString(buf, start, len).Trim(); HairDye = buf[start++]; BitsByte bitsByte = buf[start++]; HideVisual = new bool[10]; for (int num7 = 0; num7 < 8; num7++) { HideVisual[num7] = bitsByte[num7]; } bitsByte = buf[start++]; for (int num8 = 0; num8 < 2; num8++) { HideVisual[num8 + 8] = bitsByte[num8]; } HideMisc = buf[start++]; HairColor = ParseColor(buf, ref start); SkinColor = ParseColor(buf, ref start); EyeColor = ParseColor(buf, ref start); ShirtColor = ParseColor(buf, ref start); UnderShirtColor = ParseColor(buf, ref start); PantsColor = ParseColor(buf, ref start); ShoeColor = ParseColor(buf, ref start); BitsByte bitsByte2 = buf[start++]; Difficulty = 0; if (bitsByte2[0]) { Difficulty += 1; } if (bitsByte2[1]) { Difficulty += 2; } if (Difficulty > 2) { Difficulty = 2; } ExtraAccessory = bitsByte2[2]; return(start - at); #else return(0); #endif }
static private float DenormalizeLog(float f, float min, float max) { return(MathHelper.Clamp(MathHelper.InterpLog(f, min, max), min, max)); }
public static void Draw(SpriteBatch spriteBatch, Character character, Camera cam) { if (GUI.DisableHUD) { return; } character.CharacterHealth.Alignment = Alignment.Right; if (GameMain.GameSession?.CrewManager != null) { orderIndicatorCount.Clear(); foreach (Pair <Order, float> timedOrder in GameMain.GameSession.CrewManager.ActiveOrders) { DrawOrderIndicator(spriteBatch, cam, character, timedOrder.First, MathHelper.Clamp(timedOrder.Second / 10.0f, 0.2f, 1.0f)); } if (character.CurrentOrder != null) { DrawOrderIndicator(spriteBatch, cam, character, character.CurrentOrder, 1.0f); } } foreach (Character.ObjectiveEntity objectiveEntity in character.ActiveObjectiveEntities) { DrawObjectiveIndicator(spriteBatch, cam, character, objectiveEntity, 1.0f); } foreach (Item brokenItem in brokenItems) { if (brokenItem.NonInteractable) { continue; } float dist = Vector2.Distance(character.WorldPosition, brokenItem.WorldPosition); Vector2 drawPos = brokenItem.DrawPosition; float alpha = Math.Min((1000.0f - dist) / 1000.0f * 2.0f, 1.0f); if (alpha <= 0.0f) { continue; } GUI.DrawIndicator(spriteBatch, drawPos, cam, 100.0f, GUI.BrokenIcon, Color.Lerp(GUI.Style.Red, GUI.Style.Orange * 0.5f, brokenItem.Condition / brokenItem.MaxCondition) * alpha); } if (!character.IsIncapacitated && character.Stun <= 0.0f) { if (character.FocusedCharacter != null && character.FocusedCharacter.CanBeSelected) { DrawCharacterHoverTexts(spriteBatch, cam, character); } if (character.FocusedItem != null) { if (focusedItem != character.FocusedItem) { focusedItemOverlayTimer = Math.Min(1.0f, focusedItemOverlayTimer); shouldRecreateHudTexts = true; } focusedItem = character.FocusedItem; } if (focusedItem != null && focusedItemOverlayTimer > ItemOverlayDelay) { Vector2 circlePos = cam.WorldToScreen(focusedItem.DrawPosition); float circleSize = Math.Max(focusedItem.Rect.Width, focusedItem.Rect.Height) * 1.5f; circleSize = MathHelper.Clamp(circleSize, 45.0f, 100.0f) * Math.Min((focusedItemOverlayTimer - 1.0f) * 5.0f, 1.0f); if (circleSize > 0.0f) { Vector2 scale = new Vector2(circleSize / GUI.Style.FocusIndicator.FrameSize.X); GUI.Style.FocusIndicator.Draw(spriteBatch, (int)((focusedItemOverlayTimer - 1.0f) * GUI.Style.FocusIndicator.FrameCount * 3.0f), circlePos, Color.LightBlue * 0.3f, origin: GUI.Style.FocusIndicator.FrameSize.ToVector2() / 2, rotate: (float)Timing.TotalTime, scale: scale); } if (!GUI.DisableItemHighlights && !Inventory.DraggingItemToWorld) { bool shiftDown = PlayerInput.KeyDown(Keys.LeftShift) || PlayerInput.KeyDown(Keys.RightShift); if (shouldRecreateHudTexts || heldDownShiftWhenGotHudTexts != shiftDown) { shouldRecreateHudTexts = true; heldDownShiftWhenGotHudTexts = shiftDown; } var hudTexts = focusedItem.GetHUDTexts(character, shouldRecreateHudTexts); shouldRecreateHudTexts = false; int dir = Math.Sign(focusedItem.WorldPosition.X - character.WorldPosition.X); Vector2 textSize = GUI.Font.MeasureString(focusedItem.Name); Vector2 largeTextSize = GUI.SubHeadingFont.MeasureString(focusedItem.Name); Vector2 startPos = cam.WorldToScreen(focusedItem.DrawPosition); startPos.Y -= (hudTexts.Count + 1) * textSize.Y; if (focusedItem.Sprite != null) { startPos.X += (int)(circleSize * 0.4f * dir); startPos.Y -= (int)(circleSize * 0.4f); } Vector2 textPos = startPos; if (dir == -1) { textPos.X -= largeTextSize.X; } float alpha = MathHelper.Clamp((focusedItemOverlayTimer - ItemOverlayDelay) * 2.0f, 0.0f, 1.0f); GUI.DrawString(spriteBatch, textPos, focusedItem.Name, GUI.Style.TextColor * alpha, Color.Black * alpha * 0.7f, 2, font: GUI.SubHeadingFont); startPos.X += dir * 10.0f * GUI.Scale; textPos.X += dir * 10.0f * GUI.Scale; textPos.Y += largeTextSize.Y; foreach (ColoredText coloredText in hudTexts) { if (dir == -1) { textPos.X = (int)(startPos.X - GUI.SmallFont.MeasureString(coloredText.Text).X); } GUI.DrawString(spriteBatch, textPos, coloredText.Text, coloredText.Color * alpha, Color.Black * alpha * 0.7f, 2, GUI.SmallFont); textPos.Y += textSize.Y; } } } foreach (HUDProgressBar progressBar in character.HUDProgressBars.Values) { progressBar.Draw(spriteBatch, cam); } } if (character.SelectedConstruction != null && (character.CanInteractWith(Character.Controlled.SelectedConstruction) || Screen.Selected == GameMain.SubEditorScreen)) { character.SelectedConstruction.DrawHUD(spriteBatch, cam, Character.Controlled); } if (character.Inventory != null) { for (int i = 0; i < character.Inventory.Items.Length - 1; i++) { var item = character.Inventory.Items[i]; if (item == null || character.Inventory.SlotTypes[i] == InvSlotType.Any) { continue; } foreach (ItemComponent ic in item.Components) { if (ic.DrawHudWhenEquipped) { ic.DrawHUD(spriteBatch, character); } } } } bool mouseOnPortrait = false; if (character.Stun <= 0.1f && !character.IsDead) { if (CharacterHealth.OpenHealthWindow == null && character.SelectedCharacter == null) { if (character.Info != null && !character.ShouldLockHud()) { character.Info.DrawBackground(spriteBatch); character.Info.DrawJobIcon(spriteBatch, new Rectangle( (int)(HUDLayoutSettings.BottomRightInfoArea.X + HUDLayoutSettings.BottomRightInfoArea.Width * 0.05f), (int)(HUDLayoutSettings.BottomRightInfoArea.Y + HUDLayoutSettings.BottomRightInfoArea.Height * 0.1f), (int)(HUDLayoutSettings.BottomRightInfoArea.Width / 2), (int)(HUDLayoutSettings.BottomRightInfoArea.Height * 0.7f))); character.Info.DrawPortrait(spriteBatch, HUDLayoutSettings.PortraitArea.Location.ToVector2(), new Vector2(-12 * GUI.Scale, 4 * GUI.Scale), targetWidth: HUDLayoutSettings.PortraitArea.Width, true); } mouseOnPortrait = HUDLayoutSettings.BottomRightInfoArea.Contains(PlayerInput.MousePosition) && !character.ShouldLockHud(); if (mouseOnPortrait) { GUI.UIGlow.Draw(spriteBatch, HUDLayoutSettings.BottomRightInfoArea, GUI.Style.Green * 0.5f); } } if (ShouldDrawInventory(character)) { character.Inventory.Locked = LockInventory(character); character.Inventory.DrawOwn(spriteBatch); character.Inventory.CurrentLayout = CharacterHealth.OpenHealthWindow == null && character.SelectedCharacter == null ? CharacterInventory.Layout.Default : CharacterInventory.Layout.Right; } } if (!character.IsIncapacitated && character.Stun <= 0.0f) { if (character.IsHumanoid && character.SelectedCharacter != null && character.SelectedCharacter.Inventory != null) { if (character.SelectedCharacter.CanInventoryBeAccessed) { ///character.Inventory.CurrentLayout = Alignment.Left; character.SelectedCharacter.Inventory.CurrentLayout = CharacterInventory.Layout.Left; character.SelectedCharacter.Inventory.DrawOwn(spriteBatch); } else { //character.Inventory.CurrentLayout = (CharacterHealth.OpenHealthWindow == null) ? Alignment.Center : Alignment.Left; } if (CharacterHealth.OpenHealthWindow == character.SelectedCharacter.CharacterHealth) { character.SelectedCharacter.CharacterHealth.Alignment = Alignment.Left; character.SelectedCharacter.CharacterHealth.DrawStatusHUD(spriteBatch); } } else if (character.Inventory != null) { //character.Inventory.CurrentLayout = (CharacterHealth.OpenHealthWindow == null) ? Alignment.Center : Alignment.Left; } } if (mouseOnPortrait) { GUIComponent.DrawToolTip( spriteBatch, character.Info?.Job == null ? character.DisplayName : character.DisplayName + " (" + character.Info.Job.Name + ")", HUDLayoutSettings.PortraitArea); } }
private void UpdatePlayer(GameTime gameTime) { player.Update(gameTime); if (player.Active) { // Windows 8 Touch Gestures for MonoGame while (TouchPanel.IsGestureAvailable) { GestureSample gesture = TouchPanel.ReadGesture(); if (gesture.GestureType == GestureType.FreeDrag) { player.Position += gesture.Delta; } } //Get Mouse State then Capture the Button type and Respond Button Press Vector2 mousePosition = new Vector2(currentMouseState.X, currentMouseState.Y); if (currentMouseState.LeftButton == ButtonState.Pressed) { Vector2 posDelta = mousePosition - player.Position; posDelta.Normalize(); posDelta *= playerMoveSpeed; if ((mousePosition - player.Position).Length() <= playerMoveSpeed) { player.Position = mousePosition; } else { player.Position += posDelta; } } // Get Thumbstick Controls player.Position.X += currentGamePadState.ThumbSticks.Left.X * playerMoveSpeed; player.Position.Y -= currentGamePadState.ThumbSticks.Left.Y * playerMoveSpeed; // Use the Keyboard / Dpad if (currentKeyboardState.IsKeyDown(Keys.Left) || currentKeyboardState.IsKeyDown(Keys.A) || currentGamePadState.DPad.Left == ButtonState.Pressed) { player.Position.X -= playerMoveSpeed; } if (currentKeyboardState.IsKeyDown(Keys.Right) || currentKeyboardState.IsKeyDown(Keys.D) || currentGamePadState.DPad.Right == ButtonState.Pressed) { player.Position.X += playerMoveSpeed; } if (currentKeyboardState.IsKeyDown(Keys.Up) || currentKeyboardState.IsKeyDown(Keys.W) || currentGamePadState.DPad.Up == ButtonState.Pressed) { player.Position.Y -= playerMoveSpeed; } if (currentKeyboardState.IsKeyDown(Keys.Down) || currentKeyboardState.IsKeyDown(Keys.S) || currentGamePadState.DPad.Down == ButtonState.Pressed) { player.Position.Y += playerMoveSpeed; } if (currentKeyboardState.IsKeyDown(Keys.Space) || currentGamePadState.Buttons.X == ButtonState.Pressed) { FirePlayerLaser(gameTime); } // Make sure that the player does not go out of bounds player.Position.X = MathHelper.Clamp(player.Position.X, player.Width / 2, GraphicsDevice.Viewport.Width - player.Width / 2); player.Position.Y = MathHelper.Clamp(player.Position.Y, player.Height / 2, GraphicsDevice.Viewport.Height - player.Height / 2 + 20); } else if (!isGameEnded) { AddExplosion(allyExplosionTexture, player.Position, 2.5f); playerExplosionSound.SoundEffectInstance.Play(); isGameEnded = true; } }
partial void ExplodeProjSpecific(Vector2 worldPosition, Hull hull) { if (shockwave) { GameMain.ParticleManager.CreateParticle("shockwave", worldPosition, Vector2.Zero, 0.0f, hull); } hull = hull ?? Hull.FindHull(worldPosition, useWorldCoordinates: true); bool underwater = hull == null || worldPosition.Y < hull.WorldSurface; if (underwater && underwaterBubble) { var underwaterExplosion = GameMain.ParticleManager.CreateParticle("underwaterexplosion", worldPosition, Vector2.Zero, 0.0f, hull); if (underwaterExplosion != null) { underwaterExplosion.Size *= MathHelper.Clamp(attack.Range / 150.0f, 0.5f, 10.0f); underwaterExplosion.StartDelay = 0.0f; } } for (int i = 0; i < attack.Range * 0.1f; i++) { if (!underwater) { float particleSpeed = Rand.Range(0.0f, 1.0f); particleSpeed = particleSpeed * particleSpeed * attack.Range; if (flames) { float particleScale = MathHelper.Clamp(attack.Range * 0.0025f, 0.5f, 2.0f); var flameParticle = GameMain.ParticleManager.CreateParticle("explosionfire", ClampParticlePos(worldPosition + Rand.Vector((float)System.Math.Sqrt(Rand.Range(0.0f, attack.Range))), hull), Rand.Vector(Rand.Range(0.0f, particleSpeed)), 0.0f, hull); if (flameParticle != null) { flameParticle.Size *= particleScale; } } if (smoke) { var smokeParticle = GameMain.ParticleManager.CreateParticle(Rand.Range(0.0f, 1.0f) < 0.5f ? "explosionsmoke" : "smoke", ClampParticlePos(worldPosition + Rand.Vector((float)System.Math.Sqrt(Rand.Range(0.0f, attack.Range))), hull), Rand.Vector(Rand.Range(0.0f, particleSpeed)), 0.0f, hull); } } else if (underwaterBubble) { Vector2 bubblePos = Rand.Vector(Rand.Range(0.0f, attack.Range * 0.5f)); GameMain.ParticleManager.CreateParticle("risingbubbles", worldPosition + bubblePos, Vector2.Zero, 0.0f, hull); if (i < attack.Range * 0.02f) { var underwaterExplosion = GameMain.ParticleManager.CreateParticle("underwaterexplosion", worldPosition + bubblePos, Vector2.Zero, 0.0f, hull); if (underwaterExplosion != null) { underwaterExplosion.Size *= MathHelper.Clamp(attack.Range / 300.0f, 0.5f, 2.0f) * Rand.Range(0.8f, 1.2f); } } } if (sparks) { GameMain.ParticleManager.CreateParticle("spark", worldPosition, Rand.Vector(Rand.Range(500.0f, 800.0f)), 0.0f, hull); } } if (hull != null && !string.IsNullOrWhiteSpace(decal) && decalSize > 0.0f) { hull.AddDecal(decal, worldPosition, decalSize); } if (flash) { float displayRange = attack.Range; if (displayRange < 0.1f) { return; } var light = new LightSource(worldPosition, displayRange, Color.LightYellow, null); CoroutineManager.StartCoroutine(DimLight(light)); } }
/// <summary> /// The update checks for successful ghost selection against the selection render. Successful ones are hidden, and a new one is displayed. /// New renders are made each time a new ghost appears on the screen. /// </summary> /// <param name="gameTime">The game time</param> public override void Update(GameTime gameTime) { MouseState ms = Mouse.GetState(); if (selectableList[0].selected && (Gesture == ManipMode.GRAB || Gesture == ManipMode.SELECTGRAB)) { Ray ray = XNAHelper.CalculateCursorRay(CursorPos, camera.GetProjectionMatrix(), camera.GetViewMatrix(), game.GraphicsDevice); selectableList[0].position = Vector3.Lerp(selectableList[0].position, ray.Position + (ray.Direction * ratio), (float)gameTime.ElapsedGameTime.TotalSeconds * 8); selectableList[0].position.Y = MathHelper.Clamp(selectableList[0].position.Y, ymin, ymax); selectableList[0].position.Z = MathHelper.Clamp(selectableList[0].position.Z, zmin, zmax); selectableList[0].position.X = xFixed; } if ((Gesture == ManipMode.SELECT || Gesture == ManipMode.SELECTGRAB) && LastGesture == ManipMode.NONE) { Rectangle source = new Rectangle((int)(CursorPos.X - Game1.cursorArea / 2), (int)(CursorPos.Y - Game1.cursorArea / 2), (int)Game1.cursorArea, (int)Game1.cursorArea); Color[] retrieved = new Color[(int)(Game1.cursorArea * Game1.cursorArea)]; bool selectionSuccessful = false; try { flatRender.GetData <Color>(0, source, retrieved, 0, (int)(Game1.cursorArea * Game1.cursorArea)); //We increment by 2 as an optimization measure, as those values are going to be pretty consistent. for (int i = 0; i < retrieved.Length; i += 2) { if (retrieved[i] == this.selectionColor) { selectableList[0].selected = true; selectionSuccessful = true; Ray ray = XNAHelper.CalculateCursorRay(new Vector2(ms.X, ms.Y), camera.GetProjectionMatrix(), camera.GetViewMatrix(), game.GraphicsDevice); ratio = Vector3.Distance(ray.Position, selectableList[0].position) / Vector3.Distance(ray.Position, ray.Position + new Vector3(ray.Direction.X, 0, 0)); ((GEntity)selectableList[0]).waiting = true; } } if (selectionSuccessful) { DataLogger.Environment = LoggingEnvironment.YESSELECT; } else { DataLogger.Environment = LoggingEnvironment.NOSELECT; } } catch (ArgumentException) { Console.Error.WriteLine("Mouse Click outside Bounds!"); } } if (Gesture == ManipMode.NONE && LastGesture != ManipMode.NONE) { if (((Cage)draggableList[0]).Contains(selectableList[0].position)) { selectableList[0].selected = false; sceneryList.Insert(0, selectableList[0]); selectableList.RemoveAt(0); ((Firefly)sceneryList[0]).standardColor = Color.Yellow; ((Firefly)sceneryList[0]).RemoveGlow(); DataLogger.Environment = LoggingEnvironment.YESDROP; if (selectableList.Count == 0) { complete = true; } else { ((Firefly)selectableList[0]).standardColor = Color.Orange; } } else { DataLogger.Environment = LoggingEnvironment.NODROP; } renderRequested = true; } base.Update(gameTime); }
void UpdateRoomToRoom(float deltaTime, Hull hull1, Hull hull2) { Vector2 subOffset = Vector2.Zero; if (hull1.Submarine != Submarine) { subOffset = Submarine.Position - hull1.Submarine.Position; } else if (hull2.Submarine != Submarine) { subOffset = hull2.Submarine.Position - Submarine.Position; } if (hull1.WaterVolume <= 0.0 && hull2.WaterVolume <= 0.0) { return; } float size = IsHorizontal ? rect.Height : rect.Width; //a variable affecting the water flow through the gap //the larger the gap is, the faster the water flows float sizeModifier = size / 100.0f * open; //horizontal gap (such as a regular door) if (IsHorizontal) { higherSurface = Math.Max(hull1.Surface, hull2.Surface + subOffset.Y); float delta = 0.0f; //water level is above the lower boundary of the gap if (Math.Max(hull1.Surface + hull1.WaveY[hull1.WaveY.Length - 1], hull2.Surface + subOffset.Y + hull2.WaveY[0]) > rect.Y - size) { int dir = (hull1.Pressure > hull2.Pressure + subOffset.Y) ? 1 : -1; //water flowing from the righthand room to the lefthand room if (dir == -1) { if (!(hull2.WaterVolume > 0.0f)) { return; } lowerSurface = hull1.Surface - hull1.WaveY[hull1.WaveY.Length - 1]; //delta = Math.Min((room2.water.pressure - room1.water.pressure) * sizeModifier, Math.Min(room2.water.Volume, room2.Volume)); //delta = Math.Min(delta, room1.Volume - room1.water.Volume + Water.MaxCompress); flowTargetHull = hull1; //make sure not to move more than what the room contains delta = Math.Min(((hull2.Pressure + subOffset.Y) - hull1.Pressure) * 5.0f * sizeModifier, Math.Min(hull2.WaterVolume, hull2.Volume)); //make sure not to place more water to the target room than it can hold delta = Math.Min(delta, hull1.Volume * Hull.MaxCompress - (hull1.WaterVolume)); hull1.WaterVolume += delta; hull2.WaterVolume -= delta; if (hull1.WaterVolume > hull1.Volume) { hull1.Pressure = Math.Max(hull1.Pressure, (hull1.Pressure + hull2.Pressure + subOffset.Y) / 2); } flowForce = new Vector2(-delta, 0.0f); } else if (dir == 1) { if (!(hull1.WaterVolume > 0.0f)) { return; } lowerSurface = hull2.Surface - hull2.WaveY[hull2.WaveY.Length - 1]; flowTargetHull = hull2; //make sure not to move more than what the room contains delta = Math.Min((hull1.Pressure - (hull2.Pressure + subOffset.Y)) * 5.0f * sizeModifier, Math.Min(hull1.WaterVolume, hull1.Volume)); //make sure not to place more water to the target room than it can hold delta = Math.Min(delta, hull2.Volume * Hull.MaxCompress - (hull2.WaterVolume)); hull1.WaterVolume -= delta; hull2.WaterVolume += delta; if (hull2.WaterVolume > hull2.Volume) { hull2.Pressure = Math.Max(hull2.Pressure, ((hull1.Pressure - subOffset.Y) + hull2.Pressure) / 2); } flowForce = new Vector2(delta, 0.0f); } if (delta > 100.0f && subOffset == Vector2.Zero) { float avg = (hull1.Surface + hull2.Surface) / 2.0f; if (hull1.WaterVolume < hull1.Volume / Hull.MaxCompress && hull1.Surface + hull1.WaveY[hull1.WaveY.Length - 1] < rect.Y) { hull1.WaveVel[hull1.WaveY.Length - 1] = (avg - (hull1.Surface + hull1.WaveY[hull1.WaveY.Length - 1])) * 0.1f; hull1.WaveVel[hull1.WaveY.Length - 2] = hull1.WaveVel[hull1.WaveY.Length - 1]; } if (hull2.WaterVolume < hull2.Volume / Hull.MaxCompress && hull2.Surface + hull2.WaveY[0] < rect.Y) { hull2.WaveVel[0] = (avg - (hull2.Surface + hull2.WaveY[0])) * 0.1f; hull2.WaveVel[1] = hull2.WaveVel[0]; } } } } else { //lower room is full of water if (hull2.Pressure + subOffset.Y > hull1.Pressure && hull2.WaterVolume > 0.0f) { float delta = Math.Min(hull2.WaterVolume - hull2.Volume + (hull2.Volume * Hull.MaxCompress), deltaTime * 8000.0f * sizeModifier); //make sure not to place more water to the target room than it can hold if (hull1.WaterVolume + delta > hull1.Volume * Hull.MaxCompress) { delta -= (hull1.WaterVolume + delta) - (hull1.Volume * Hull.MaxCompress); } delta = Math.Max(delta, 0.0f); hull1.WaterVolume += delta; hull2.WaterVolume -= delta; flowForce = new Vector2( 0.0f, Math.Min(Math.Min((hull2.Pressure + subOffset.Y) - hull1.Pressure, 200.0f), delta)); flowTargetHull = hull1; if (hull1.WaterVolume > hull1.Volume) { hull1.Pressure = Math.Max(hull1.Pressure, (hull1.Pressure + (hull2.Pressure + subOffset.Y)) / 2); } } //there's water in the upper room, drop to lower else if (hull1.WaterVolume > 0) { flowTargetHull = hull2; //make sure the amount of water moved isn't more than what the room contains float delta = Math.Min(hull1.WaterVolume, deltaTime * 25000f * sizeModifier); //make sure not to place more water to the target room than it can hold if (hull2.WaterVolume + delta > hull2.Volume * Hull.MaxCompress) { delta -= (hull2.WaterVolume + delta) - (hull2.Volume * Hull.MaxCompress); } hull1.WaterVolume -= delta; hull2.WaterVolume += delta; flowForce = new Vector2( hull1.WaveY[hull1.GetWaveIndex(rect.X)] - hull1.WaveY[hull1.GetWaveIndex(rect.Right)], MathHelper.Clamp(-delta, -200.0f, 0.0f)); if (hull2.WaterVolume > hull2.Volume) { hull2.Pressure = Math.Max(hull2.Pressure, ((hull1.Pressure - subOffset.Y) + hull2.Pressure) / 2); } } } if (open > 0.0f) { if (hull1.WaterVolume > hull1.Volume / Hull.MaxCompress && hull2.WaterVolume > hull2.Volume / Hull.MaxCompress) { float avgLethality = (hull1.LethalPressure + hull2.LethalPressure) / 2.0f; hull1.LethalPressure = avgLethality; hull2.LethalPressure = avgLethality; } else { hull1.LethalPressure = 0.0f; hull2.LethalPressure = 0.0f; } } }
public static int Clamp(int value) { return MathHelper.Clamp(value, 0, UnitMax); }
public static void ExportHitsounds(List <HitsoundEvent> hitsounds, string baseBeatmap, string exportFolder, string exportMapName, GameMode exportGameMode, bool useGreenlines, bool useStoryboard) { var editor = EditorReaderStuff.GetNewestVersionOrNot(baseBeatmap); Beatmap beatmap = editor.Beatmap; if (useStoryboard) { beatmap.StoryboardSoundSamples.Clear(); foreach (var h in hitsounds.Where(h => !string.IsNullOrEmpty(h.Filename))) { beatmap.StoryboardSoundSamples.Add(new StoryboardSoundSample((int)Math.Round(h.Time), 0, h.Filename, h.Volume * 100)); } } else { // Make new timing points // Add red lines var redlines = beatmap.BeatmapTiming.Redlines; List <TimingPointsChange> timingPointsChanges = redlines.Select(tp => new TimingPointsChange(tp, mpb: true, meter: true, unInherited: true, omitFirstBarLine: true)) .ToList(); // Add hitsound stuff // Replace all hitobjects with the hitsounds beatmap.HitObjects.Clear(); foreach (HitsoundEvent h in hitsounds) { if (useGreenlines) { TimingPoint tp = beatmap.BeatmapTiming.GetTimingPointAtTime(h.Time + 5).Copy(); tp.Offset = h.Time; tp.SampleIndex = h.CustomIndex; h.CustomIndex = 0; // Set it to default value because it gets handled by greenlines now tp.Volume = Math.Round(tp.Volume * h.Volume); h.Volume = 0; // Set it to default value because it gets handled by greenlines now timingPointsChanges.Add(new TimingPointsChange(tp, index: true, volume: true)); } beatmap.HitObjects.Add(new HitObject(h.Pos, h.Time, 5, h.GetHitsounds(), h.SampleSet, h.Additions, h.CustomIndex, h.Volume * 100, h.Filename)); } // Replace the old timingpoints beatmap.BeatmapTiming.Clear(); TimingPointsChange.ApplyChanges(beatmap.BeatmapTiming, timingPointsChanges); } // Change version to hitsounds beatmap.General["StackLeniency"] = new TValue("0.0"); beatmap.General["Mode"] = new TValue(((int)exportGameMode).ToInvariant()); beatmap.Metadata["Version"] = new TValue(exportMapName); if (exportGameMode == GameMode.Mania) { // Count the number of distinct X positions int numXPositions = new HashSet <double>(hitsounds.Select(h => h.Pos.X)).Count; int numKeys = MathHelper.Clamp(numXPositions, 1, 18); beatmap.Difficulty["CircleSize"] = new TValue(numKeys.ToInvariant()); } else { beatmap.Difficulty["CircleSize"] = new TValue("4"); } // Save the file to the export folder editor.SaveFile(Path.Combine(exportFolder, beatmap.GetFileName())); }
public override void Update(GameTime gameTime) { for (int i = 0; i < _menuItems.Count; i++) { if (_menuItems[i].Position.Contains(MonsterGame.Instance.Scaler.ScaleInput(InputManager.CurrentState.Position.ToVector2()).ToPoint())) { _selectedIndex = i; } } switch (_state) { case TitleState.Select: if (InputManager.CurrentState.Start) { switch (_selectedIndex) { case 0: AudioManager.SoundEffectInstances[AudioManager.Cue.TitleScreenMusic].Stop(); AudioManager.SoundEffectInstances[AudioManager.Cue.Start].Play(); _state = TitleState.Start; break; case 1: MonsterGame.Instance.SetState(GameState.Achievements); break; case 2: MonsterGame.Instance.SetState(GameState.Leaderboard); break; default: AudioManager.SoundEffects[AudioManager.Cue.MenuSelect].Play(); break; } } if (InputManager.CurrentState.Up) { _selectedIndex = MathHelper.Clamp(_selectedIndex - 1, 0, _menuItems.Count - 1); AudioManager.SoundEffects[AudioManager.Cue.MenuUpDown].Play(); } if (InputManager.CurrentState.Down) { _selectedIndex = MathHelper.Clamp(_selectedIndex + 1, 0, _menuItems.Count - 1); AudioManager.SoundEffects[AudioManager.Cue.MenuUpDown].Play(); } break; case TitleState.Start: if (AudioManager.SoundEffectInstances[AudioManager.Cue.Start].State != SoundState.Playing) { MonsterGame.Instance.SetState(GameState.GameScreen); } break; default: throw new ArgumentOutOfRangeException(); } _gamerCard.SetUserProfile(XboxLiveManager.Profile); _gamerCard.Update(gameTime); FontManager.YPosition = 500; }
/// <summary> /// Sets the vibration motor speeds on the controller device if supported. /// </summary> /// <param name="playerIndex">Player index that identifies the controller to set.</param> /// <param name="leftMotor">The speed of the left motor, between 0.0 and 1.0. This motor is a low-frequency motor.</param> /// <param name="rightMotor">The speed of the right motor, between 0.0 and 1.0. This motor is a high-frequency motor.</param> /// <returns>Returns true if the vibration motors were set.</returns> public static bool SetVibration(PlayerIndex playerIndex, float leftMotor, float rightMotor) { // Make sure the player index is in range. var index = (int)playerIndex; if (index < (int)PlayerIndex.One || index > (int)PlayerIndex.Four) { throw new InvalidOperationException(); } return(PlatformSetVibration(index, MathHelper.Clamp(leftMotor, 0.0f, 1.0f), MathHelper.Clamp(rightMotor, 0.0f, 1.0f))); }
public override void Update(float deltaTime, Camera cam) { if (GameMain.Server != null && nextServerLogWriteTime != null) { if (Timing.TotalTime >= (float)nextServerLogWriteTime) { GameServer.Log(lastUser + " adjusted reactor settings: " + "Temperature: " + (int)temperature + ", Fission rate: " + (int)fissionRate + ", Cooling rate: " + (int)coolingRate + ", Cooling rate: " + coolingRate + ", Shutdown temp: " + shutDownTemp + (autoTemp ? ", Autotemp ON" : ", Autotemp OFF"), ServerLog.MessageType.ItemInteraction); nextServerLogWriteTime = null; lastServerLogWriteTime = (float)Timing.TotalTime; } } ApplyStatusEffects(ActionType.OnActive, deltaTime, null); fissionRate = Math.Min(fissionRate, AvailableFuel); float heat = 80 * fissionRate * (AvailableFuel / 2000.0f); float heatDissipation = 50 * coolingRate + Math.Max(ExtraCooling, 5.0f); float deltaTemp = (((heat - heatDissipation) * 5) - temperature) / 10000.0f; Temperature = temperature + deltaTemp; if (temperature > fireTemp && temperature - deltaTemp < fireTemp) { Vector2 baseVel = Rand.Vector(300.0f); for (int i = 0; i < 10; i++) { var particle = GameMain.ParticleManager.CreateParticle("spark", item.WorldPosition, baseVel + Rand.Vector(100.0f), 0.0f, item.CurrentHull); if (particle != null) { particle.Size *= Rand.Range(0.5f, 1.0f); } } new FireSource(item.WorldPosition); } if (temperature > meltDownTemp) { MeltDown(); return; } else if (temperature == 0.0f) { if (powerUpTask == null || powerUpTask.IsFinished) { powerUpTask = new PropertyTask(item, IsRunning, 50.0f, "Power up the reactor"); } } load = 0.0f; List <Connection> connections = item.Connections; if (connections != null && connections.Count > 0) { foreach (Connection connection in connections) { if (!connection.IsPower) { continue; } foreach (Connection recipient in connection.Recipients) { Item it = recipient.Item as Item; if (it == null) { continue; } PowerTransfer pt = it.GetComponent <PowerTransfer>(); if (pt == null) { continue; } load = Math.Max(load, pt.PowerLoad); } } } //item.Condition -= temperature * deltaTime * 0.00005f; if (temperature > shutDownTemp) { CoolingRate += 0.5f; FissionRate -= 0.5f; } else if (autoTemp) { //take deltaTemp into account to slow down the change in temperature when getting closer to the desired value float target = temperature + deltaTemp * 100.0f; //-1.0f in order to gradually turn down both rates when the target temperature is reached FissionRate += (MathHelper.Clamp(load - target, -10.0f, 10.0f) - 1.0f) * deltaTime; CoolingRate += (MathHelper.Clamp(target - load, -5.0f, 5.0f) - 1.0f) * deltaTime; } //the power generated by the reactor is equal to the temperature currPowerConsumption = -temperature * powerPerTemp; if (item.CurrentHull != null) { //the sound can be heard from 20 000 display units away when running at full power item.CurrentHull.SoundRange = Math.Max(temperature * 2, item.CurrentHull.AiTarget.SoundRange); } UpdateGraph(deltaTime); ExtraCooling = 0.0f; AvailableFuel = 0.0f; item.SendSignal(0, ((int)temperature).ToString(), "temperature_out", null); sendUpdateTimer = Math.Max(sendUpdateTimer - deltaTime, 0.0f); if (unsentChanges && sendUpdateTimer <= 0.0f) { if (GameMain.Server != null) { item.CreateServerEvent(this); } else if (GameMain.Client != null) { item.CreateClientEvent(this); } sendUpdateTimer = NetworkUpdateInterval; unsentChanges = false; } }
/// <summary> /// Allows the game component to update itself. /// </summary> /// <param name="gameTime">Provides a snapshot of timing values.</param> public override void Update(GameTime gameTime) { HandleInput(gameTime); if (recenter) { Recenter(gameTime); recenter = false; } else { // tratar da rotacao e posicao do tank _turnAmount = MathHelper.Clamp(_turnAmount, -1, 1); _facingDirection += _turnAmount * _rotationSpeed * (float)gameTime.ElapsedGameTime.TotalSeconds; //_facingDirection = MathHelper.WrapAngle(FacingDirection); } _facingDirectionMatrix = Matrix.CreateRotationY(_facingDirection); if (_camera is ChaseCamera) { UpdateChaseCameraDirection((ChaseCamera)_camera); } Vector3 velocity = Vector3.Transform(_movement, _orientation); velocity *= _maxSpeed * (float)gameTime.ElapsedGameTime.TotalSeconds; Vector3 newPosition = Position + velocity; // calculate tank orientation Vector3 normal; normal = _terrain.GetInterpolatedNormalAt(newPosition.X, newPosition.Z); UpdateTankOrientation(normal); UpdateTankTurretOrientation(normal); UpdateTankCanonOrientation(normal); //calculate wheel rotation float distanceMoved = Vector3.Distance(_position, newPosition); float theta = distanceMoved / _tankWheelRadius; int rollDirection = _movement.Z < 0 ? 1 : -1; wheelRollMatrix *= Matrix.CreateRotationX(theta * rollDirection); _position = newPosition; _position.Y = _terrain.GetInterpolatedHeightAt(_position.X, _position.Z); if (distanceMoved > 0 && !soundIsPlaying) { _soundTankGoInstance.Play(); soundIsPlaying = true; } else { _soundTankGoInstance.Stop(); } if (_camera != null) { UpdateCamera(gameTime); } UpdateCanonManager(gameTime); UpdateTank(gameTime); base.Update(gameTime); }
private string TransformProperties(PropertyTransformerVm vm, BackgroundWorker worker, DoWorkEventArgs _) { bool doFilterMatch = vm.MatchFilter != -1 && vm.EnableFilters; bool doFilterRange = (vm.MinTimeFilter != -1 || vm.MaxTimeFilter != -1) && vm.EnableFilters; double min = vm.MinTimeFilter == -1 ? double.NegativeInfinity : vm.MinTimeFilter; double max = vm.MaxTimeFilter == -1 ? double.PositiveInfinity : vm.MaxTimeFilter; var reader = EditorReaderStuff.GetFullEditorReaderOrNot(); foreach (string path in vm.ExportPaths) { Editor editor; if (Path.GetExtension(path) == ".osb") { editor = new StoryboardEditor(path); } else { editor = EditorReaderStuff.GetNewestVersionOrNot(path, reader); } if (editor is BeatmapEditor beatmapEditor) { Beatmap beatmap = beatmapEditor.Beatmap; List<TimingPointsChange> timingPointsChanges = new List<TimingPointsChange>(); foreach (TimingPoint tp in beatmap.BeatmapTiming.TimingPoints) { // Offset if (vm.TimingpointOffsetMultiplier != 1 || vm.TimingpointOffsetOffset != 0) { if (Filter(tp.Offset, tp.Offset, doFilterMatch, doFilterRange, vm.MatchFilter, min, max)) { tp.Offset = Math.Round(tp.Offset * vm.TimingpointOffsetMultiplier + vm.TimingpointOffsetOffset); } } // BPM if (vm.TimingpointBPMMultiplier != 1 || vm.TimingpointBPMOffset != 0) { if (tp.Uninherited) { if (Filter(tp.GetBpm(), tp.Offset, doFilterMatch, doFilterRange, vm.MatchFilter, min, max)) { double newBPM = tp.GetBpm() * vm.TimingpointBPMMultiplier + vm.TimingpointBPMOffset; newBPM = vm.ClipProperties ? MathHelper.Clamp(newBPM, 15, 10000) : newBPM; // Clip the value if specified tp.MpB = 60000 / newBPM; } } } // Slider Velocity if (vm.TimingpointSVMultiplier != 1 || vm.TimingpointSVOffset != 0) { if (Filter(beatmap.BeatmapTiming.GetSvMultiplierAtTime(tp.Offset), tp.Offset, doFilterMatch, doFilterRange, vm.MatchFilter, min, max)) { TimingPoint tpchanger = tp.Copy(); double newSV = beatmap.BeatmapTiming.GetSvMultiplierAtTime(tp.Offset) * vm.TimingpointSVMultiplier + vm.TimingpointSVOffset; newSV = vm.ClipProperties ? MathHelper.Clamp(newSV, 0.1, 10) : newSV; // Clip the value if specified tpchanger.MpB = -100 / newSV; timingPointsChanges.Add(new TimingPointsChange(tpchanger, mpb: true)); } } // Index if (vm.TimingpointIndexMultiplier != 1 || vm.TimingpointIndexOffset != 0) { if (Filter(tp.SampleIndex, tp.Offset, doFilterMatch, doFilterRange, vm.MatchFilter, min, max)) { int newIndex = (int) Math.Round(tp.SampleIndex * vm.TimingpointIndexMultiplier + vm.TimingpointIndexOffset); tp.SampleIndex = vm.ClipProperties ? MathHelper.Clamp(newIndex, 0, 100) : newIndex; } } // Volume if (vm.TimingpointVolumeMultiplier != 1 || vm.TimingpointVolumeOffset != 0) { if (Filter(tp.Volume, tp.Offset, doFilterMatch, doFilterRange, vm.MatchFilter, min, max)) { int newVolume = (int) Math.Round(tp.Volume * vm.TimingpointVolumeMultiplier + vm.TimingpointVolumeOffset); tp.Volume = vm.ClipProperties ? MathHelper.Clamp(newVolume, 5, 100) : newVolume; } } } UpdateProgressBar(worker, 20); // Hitobject time if (vm.HitObjectTimeMultiplier != 1 || vm.HitObjectTimeOffset != 0) { foreach (HitObject ho in beatmap.HitObjects) { if (Filter(ho.Time, ho.Time, doFilterMatch, doFilterRange, vm.MatchFilter, min, max)) { ho.Time = Math.Round(ho.Time * vm.HitObjectTimeMultiplier + vm.HitObjectTimeOffset); } // Transform end time of hold notes and spinner if ((ho.IsHoldNote || ho.IsSpinner) && Filter(ho.EndTime, ho.EndTime, doFilterMatch, doFilterRange, vm.MatchFilter, min, max)) { ho.EndTime = Math.Round(ho.Time * vm.HitObjectTimeMultiplier + vm.HitObjectTimeOffset); } } } UpdateProgressBar(worker, 30); // Bookmark time if (vm.BookmarkTimeMultiplier != 1 || vm.BookmarkTimeOffset != 0) { List<double> newBookmarks = new List<double>(); List<double> bookmarks = beatmap.GetBookmarks(); foreach (double bookmark in bookmarks) { if (Filter(bookmark, bookmark, doFilterMatch, doFilterRange, vm.MatchFilter, min, max)) { newBookmarks.Add( Math.Round(bookmark * vm.BookmarkTimeMultiplier + vm.BookmarkTimeOffset)); } else { newBookmarks.Add(bookmark); } } beatmap.SetBookmarks(newBookmarks); } UpdateProgressBar(worker, 40); // Storyboarded event time if (vm.SBEventTimeMultiplier != 1 || vm.SBEventTimeOffset != 0) { foreach (Event ev in beatmap.StoryboardLayerBackground.Concat(beatmap.StoryboardLayerFail) .Concat(beatmap.StoryboardLayerPass).Concat(beatmap.StoryboardLayerForeground) .Concat(beatmap.StoryboardLayerOverlay)) { TransformEventTime(ev, vm.SBEventTimeMultiplier, vm.SBEventTimeOffset, doFilterMatch, doFilterRange, vm.MatchFilter, min, max); } } UpdateProgressBar(worker, 50); // Storyboarded sample time if (vm.SBSampleTimeMultiplier != 1 || vm.SBSampleTimeOffset != 0) { foreach (StoryboardSoundSample ss in beatmap.StoryboardSoundSamples) { if (Filter(ss.StartTime, ss.StartTime, doFilterMatch, doFilterRange, vm.MatchFilter, min, max)) { ss.StartTime = (int) Math.Round(ss.StartTime * vm.SBSampleTimeMultiplier + vm.SBSampleTimeOffset); } } } UpdateProgressBar(worker, 60); // Break time if (vm.BreakTimeMultiplier != 1 || vm.BreakTimeOffset != 0) { foreach (Break br in beatmap.BreakPeriods) { if (Filter(br.StartTime, br.StartTime, doFilterMatch, doFilterRange, vm.MatchFilter, min, max)) { br.StartTime = (int) Math.Round(br.StartTime * vm.BreakTimeMultiplier + vm.BreakTimeOffset); } if (Filter(br.EndTime, br.EndTime, doFilterMatch, doFilterRange, vm.MatchFilter, min, max)) { br.EndTime = (int) Math.Round(br.EndTime * vm.BreakTimeMultiplier + vm.BreakTimeOffset); } } } UpdateProgressBar(worker, 70); // Video start time if (vm.VideoTimeMultiplier != 1 || vm.VideoTimeOffset != 0) { foreach (Event ev in beatmap.BackgroundAndVideoEvents) { if (ev is Video video) { if (Filter(video.StartTime, video.StartTime, doFilterMatch, doFilterRange, vm.MatchFilter, min, max)) { video.StartTime = (int) Math.Round(video.StartTime * vm.VideoTimeMultiplier + vm.VideoTimeOffset); } } } } UpdateProgressBar(worker, 80); // Preview point time if (vm.PreviewTimeMultiplier != 1 || vm.PreviewTimeOffset != 0) { if (beatmap.General.ContainsKey("PreviewTime") && beatmap.General["PreviewTime"].IntValue != -1) { var previewTime = beatmap.General["PreviewTime"].DoubleValue; if (Filter(previewTime, previewTime, doFilterMatch, doFilterRange, vm.MatchFilter, min, max)) { var newPreviewTime = Math.Round(previewTime * vm.PreviewTimeMultiplier + vm.PreviewTimeOffset); beatmap.General["PreviewTime"].SetDouble(newPreviewTime); } } } UpdateProgressBar(worker, 90); TimingPointsChange.ApplyChanges(beatmap.BeatmapTiming, timingPointsChanges); // Save the file beatmapEditor.SaveFile(); UpdateProgressBar(worker, 100); } else if (editor is StoryboardEditor storyboardEditor) { StoryBoard storyboard = storyboardEditor.StoryBoard; // Storyboarded event time if (vm.SBEventTimeMultiplier != 1 || vm.SBEventTimeOffset != 0) { foreach (Event ev in storyboard.StoryboardLayerBackground.Concat(storyboard.StoryboardLayerFail) .Concat(storyboard.StoryboardLayerPass).Concat(storyboard.StoryboardLayerForeground) .Concat(storyboard.StoryboardLayerOverlay)) { TransformEventTime(ev, vm.SBEventTimeMultiplier, vm.SBEventTimeOffset, doFilterMatch, doFilterRange, vm.MatchFilter, min, max); } } UpdateProgressBar(worker, 50); // Storyboarded sample time if (vm.SBSampleTimeMultiplier != 1 || vm.SBSampleTimeOffset != 0) { foreach (StoryboardSoundSample ss in storyboard.StoryboardSoundSamples) { if (Filter(ss.StartTime, ss.StartTime, doFilterMatch, doFilterRange, vm.MatchFilter, min, max)) { ss.StartTime = (int)Math.Round(ss.StartTime * vm.SBSampleTimeMultiplier + vm.SBSampleTimeOffset); } } } UpdateProgressBar(worker, 70); // Video start time if (vm.VideoTimeMultiplier != 1 || vm.VideoTimeOffset != 0) { foreach (Event ev in storyboard.BackgroundAndVideoEvents) { if (ev is Video video) { if (Filter(video.StartTime, video.StartTime, doFilterMatch, doFilterRange, vm.MatchFilter, min, max)) { video.StartTime = (int)Math.Round(video.StartTime * vm.VideoTimeMultiplier + vm.VideoTimeOffset); } } } } UpdateProgressBar(worker, 90); // Save the file storyboardEditor.SaveFile(); UpdateProgressBar(worker, 100); } } return "Done!"; }
public virtual void DealDamage(int damage) { health -= (int)(damage - MathHelper.Clamp(defense, 0, damage - 1)); }
/// <summary> /// Allows the game to run logic such as updating the world. /// </summary> protected override void Update(GameTime gameTime) { if (GamePad.GetState(PlayerIndex.One).Buttons.Back == ButtonState.Pressed || Keyboard.GetState().IsKeyDown(Keys.Escape)) { Exit(); } var screenBounds = GraphicsDevice.Viewport.Bounds; var touchState = Keyboard.GetState(); //Down paddle control if (touchState.IsKeyDown(Keys.Left)) { PaddleBottom.X -= (float)(PaddleBottom.Speed * gameTime.ElapsedGameTime.TotalMilliseconds); } if (touchState.IsKeyDown(Keys.Right)) { PaddleBottom.X += (float)(PaddleBottom.Speed * gameTime.ElapsedGameTime.TotalMilliseconds); } //Top paddle control if (touchState.IsKeyDown(Keys.A)) { PaddleTop.X -= (float)(PaddleTop.Speed * gameTime.ElapsedGameTime.TotalMilliseconds); _paddleAi = false; } if (touchState.IsKeyDown(Keys.D)) { PaddleTop.X += (float)(PaddleTop.Speed * gameTime.ElapsedGameTime.TotalMilliseconds); _paddleAi = false; } if (_paddleAi) { PaddleTop.X = MathHelper.Lerp(PaddleTop.X, PaddleTop.X + PaddleAI.Move(PaddleTop, Ball) * (float)(PaddleTop.Speed * gameTime.ElapsedGameTime.TotalMilliseconds), Ball.GetElement(0).Speed > 1 ? 1 : (Ball.GetElement(0).Speed / 1.2f)); } //Limit paddle position PaddleBottom.X = MathHelper.Clamp(PaddleBottom.X, screenBounds.Left, screenBounds.Right - PaddleBottom.Width); PaddleTop.X = MathHelper.Clamp(PaddleTop.X, screenBounds.Left, screenBounds.Right - PaddleTop.Width); foreach (var ball in Ball) { //Ball movement var ballPositionChange = ball.Direction * (float)(gameTime.ElapsedGameTime.TotalMilliseconds * ball.Speed); ball.X += ballPositionChange.X; ball.Y += ballPositionChange.Y; // Ball hitting side walls if (CollisionDetector.Overlaps(ball, Walls.GetElement(0)) || CollisionDetector.Overlaps(ball, Walls.GetElement(1))) { HitSound.Play(0.2f, 0, 0); ball.Direction.invertX(); if (ball.Speed < GameConstants.DefaultMaxBallSpeed) { ball.Speed *= ball.BumpSpeedIncreaseFactor; } } // Ball hitting goals if (CollisionDetector.Overlaps(ball, Goals.GetElement(0))) { Score.Player1++; if (Ball.Count == 1) { ResetBall(); } else { Ball.Remove(ball); } } if (CollisionDetector.Overlaps(ball, Goals.GetElement(1))) { Score.Player2++; if (Ball.Count == 1) { ResetBall(); } else { Ball.Remove(ball); } } // Ball hitting paddles if (CollisionDetector.Overlaps(ball, PaddleTop) || CollisionDetector.Overlaps(ball, PaddleBottom)) { HitSound.Play(0.2f, 0, 0); ball.Direction.invertY(); if (ball.Speed < GameConstants.DefaultMaxBallSpeed) { ball.Speed *= ball.BumpSpeedIncreaseFactor; } if (ball == Ball.GetElement(0)) { SpawnPickups(); } } if (Timer.Equals("0")) { foreach (var pickup in Pickups) { if (!CollisionDetector.Overlaps(ball, pickup)) { continue; } pickup.Activate(this); Pickups.Remove(pickup); } } } //Ball outside of the screen if (!new Rectangle(-GameConstants.WallDefaultSize, -GameConstants.WallDefaultSize, screenBounds.Width + GameConstants.WallDefaultSize, screenBounds.Height + GameConstants.WallDefaultSize) .Intersects(new Rectangle((int)Ball.GetElement(0).X, (int)Ball.GetElement(0).Y, Ball.GetElement(0).Width, Ball.GetElement(0).Height))) { ResetBall(); } base.Update(gameTime); }
public virtual void Update(GameTime gameTime) { float elapsedSeconds = (float)gameTime.ElapsedGameTime.TotalSeconds; float elapsedMilliseconds = (float)gameTime.ElapsedGameTime.Milliseconds; position += elapsedMilliseconds * velocity; Vector2 p = new Vector2(MathHelper.Clamp(position.X, width / 2, Game1.WINDOW_WIDTH - width / 2), MathHelper.Clamp(position.Y, height / 2, Game1.WINDOW_HEIGHT - height / 2)); position = p; List <Player> tile = GridManager.GridTile(position); if (gridTile != tile) { gridTile.Remove(this); tile.Add(this); gridTile = tile; } if (!moving) { playerAnimation.Stop(); } else { playerAnimation.Play(); } if (health <= 0) { isAlive = false; gridTile.Remove(this); } playerAnimation.UpdateFrame(elapsedSeconds); }
public void SetAlpha(float whenOver, float whenOut) { alphaOver = MathHelper.Clamp(whenOver, 0f, 1f); alphaOut = MathHelper.Clamp(whenOut, 0f, 1f); }
public static void Update(GameTime gameTime, float timer) { IsUpdating = true; //CleanList(); foreach (var entity in Entities) { // var collision = CheckCollision(entity); switch (entity) { case MainPlayer mp: //check if player has been hit. if (mp.Invulnerable == true) { if (playerStatusChecked == false) { playerStatusChecked = true; playerStartNoDamage = gameTime.TotalGameTime; } if (gameTime.TotalGameTime - playerStartNoDamage >= playerInvulnerable) { mp.Invulnerable = false; playerStatusChecked = false; } } //Prevent player from going out of bounds mp.Position.X = MathHelper.Clamp(entity.Position.X, GameArt.MainPlayer.Width, GameRoot.GraphicsDevice.Viewport.Width); mp.Position.Y = MathHelper.Clamp(entity.Position.Y, 0, GameRoot.GraphicsDevice.Viewport.Height - GameArt.MainPlayer.Height); break; case StandardEnemy se: if (se.Position.X > 0 && se.Position.X < GameRoot.GraphicsDevice.Viewport.Width && se.Position.Y > 0 && se.Position.Y < GameRoot.GraphicsDevice.Viewport.Height) { se.Onscreen = true; } else { //if onscreen is true, but we are now off screen, time to delete. if (se.Onscreen == true) { se.Die(se); } } break; case GameBoss gb: if (gb.Position.X > 0 && gb.Position.X < GameRoot.GraphicsDevice.Viewport.Width && gb.Position.Y > 0 && gb.Position.Y < GameRoot.GraphicsDevice.Viewport.Height) { gb.Onscreen = true; } else { //if onscreen is true, but we are now off screen, time to delete. if (gb.Onscreen == true) { gb.Die(gb); } } break; case PlayerBullet pb: //check if bullet has gone out of bounds if (pb.Position.X > GameRoot.GraphicsDevice.Viewport.Width || pb.Position.Y < 0) { pb.Die(pb); } break; } entity.Update(gameTime, Entities); } if (EntitiesToRemove != null) { foreach (var entity in EntitiesToRemove) { Entities.Remove(entity); } EntitiesToRemove.Clear(); } // IMPLEMENT NEXT TIME //// 5 seconds of loading - then start with phase one //// Phase1 from 3 - 48 seconds (45 seconds) //// normal enemies the whole time //if (gameTime.TotalGameTime.TotalSeconds == 3) //{ // Phase1(); //} //else if (gameTime.TotalGameTime.TotalSeconds == 48) //{ // //for now clear enemies and bring out mid boss // Entities.Clear(); // //Mid boss fight (technically, bullets from phase one do not clear) // MidBoss(); //} //else if (gameTime.TotalGameTime.TotalSeconds == 75) //{ // Entities.Clear(); // //regular enemies again // Phase2(); //} //else if (gameTime.TotalGameTime.TotalSeconds == 92) //{ // Entities.Clear(); // //There's a cutscene here before starting the boss battle. //} //else if (gameTime.TotalGameTime.TotalSeconds == 95) //{ // //B //} //if (gameTime.TotalGameTime.TotalSeconds == 15) //{ // Entities.Clear(); //} IsUpdating = false; foreach (var entity in AddedEntities) { Entities.Add(entity); } AddedEntities.Clear(); // remove any expired entities. // Entities = Entities.Where(x => x.IsActive()).ToList(); }
private void FindAndCaculateFromAdvancedStatic(GridSimulationData simData) { // Instead of using uniform distribution of support between all fixed nodes, calculate non-uniform distribution based on vectors for few closest nodes // Use this distribution when setting support weight and transferring mass // SupportingWeights: x * support // ? TransferMass: x * numStaticBlocksForCurrentDynamicBlock * TransferMass int keepLookingDistance = (int)ClosestDistanceThreshold; // How far keep looking when closest static block is found simData.Queue.Clear(); // Set initial distance to max for all dynamic foreach (var dyn in simData.DynamicBlocks) { dyn.Distance = int.MaxValue; } // Wide search from all static blocks foreach (var stat in simData.StaticBlocks) { stat.Distance = 0; var path = new PathInfo() { EndNode = stat, StartNode = stat, Distance = 0, DirectionRatio = 1 }; #if ENHANCED_DEBUG path.PathNodes.Add(stat); #endif simData.Queue.Enqueue(path); } while (simData.Queue.Count > 0) { var path = simData.Queue.Dequeue(); foreach (var neighbour in path.EndNode.Neighbours) { if (neighbour.IsStatic) { continue; } PathInfo neighbourPath; if (!neighbour.Paths.TryGetValue(path.StartNode, out neighbourPath)) { if ((path.Distance - keepLookingDistance) <= neighbour.Distance) { neighbour.Distance = Math.Min(neighbour.Distance, path.Distance); neighbourPath = new PathInfo(); neighbourPath.Distance = path.Distance + 1; neighbourPath.StartNode = path.StartNode; neighbourPath.EndNode = neighbour; #if ENHANCED_DEBUG neighbourPath.PathNodes = path.PathNodes.ToList(); neighbourPath.PathNodes.Add(neighbour); #endif neighbourPath.Parents.Add(path); float t = neighbour.PhysicalMaterial.HorisontalTransmissionMultiplier * path.EndNode.PhysicalMaterial.HorisontalTransmissionMultiplier; float massRatio = MathHelper.Clamp(path.EndNode.Mass / (neighbour.Mass + path.EndNode.Mass), 0, 1); t *= neighbour.Mass * massRatio; //Horisontal transmission is very low on weak objects (floor, roof). Should be correctly get from mount point area float[] horisontalTransmission = new float[] { t, 1, t }; int component = ((Vector3D)(neighbour.Pos - path.EndNode.Pos)).AbsMaxComponent(); neighbourPath.DirectionRatio = path.DirectionRatio * DirectionRatios[component] * horisontalTransmission[component]; neighbour.Paths.Add(path.StartNode, neighbourPath); simData.Queue.Enqueue(neighbourPath); path.StartNode.OwnedPaths.Push(neighbourPath); } } else if (neighbourPath.Distance == path.Distance + 1) // Another path with same length { neighbourPath.Parents.Add(path); } } } // Iterate all dynamic blocks and calculate support ratio for each static foreach (var dyn in simData.DynamicBlocks) { dyn.PathCount = 1; if (dyn.Pos == new Vector3I(-6, 6, 0)) { } // Uniform distribution //foreach (var s in dyn.Paths) //{ // s.Value.Ratio = 1.0f / dyn.Paths.Count; //} //continue; // Non-uniform distribution // Calculate angle between one vector and all other // Split weight support based on sum angle ratio float totalAngles = 0; if (dyn.Paths.Count > 1) { foreach (var s in dyn.Paths) { Vector3 localVector1 = (dyn.Pos - s.Value.StartNode.Pos) * m_grid.GridSize; Vector3 worldVector1 = Vector3.TransformNormal(localVector1, m_grid.WorldMatrix); // float sumAngle = 0; float sumAngleReduced = 0; foreach (var s2 in dyn.Paths) { if (s.Key == s2.Key) { continue; } Vector3 localVector2 = (dyn.Pos - s2.Value.StartNode.Pos) * m_grid.GridSize; Vector3 worldVector2 = Vector3.TransformNormal(localVector2, m_grid.WorldMatrix); float angle = MyUtils.GetAngleBetweenVectorsAndNormalise(worldVector1, worldVector2); float dot1 = Math.Abs(Vector3.Normalize(worldVector1).Dot(Vector3.Up)); float dot2 = Math.Abs(Vector3.Normalize(worldVector2).Dot(Vector3.Up)); float lowerBound = 0.1f; dot1 = MathHelper.Lerp(lowerBound, 1, dot1); dot2 = MathHelper.Lerp(lowerBound, 1, dot2); float reducedAngle = angle; if (!MyPetaInputComponent.OLD_SI) { //Reduce dependent on gravity reducedAngle = angle * dot1 * s.Value.DirectionRatio; } //sumAngle += angle; sumAngleReduced += reducedAngle; } s.Value.Ratio = sumAngleReduced; totalAngles += sumAngleReduced; } foreach (var s in dyn.Paths) { if (totalAngles > 0) { s.Value.Ratio /= totalAngles; if (s.Value.Ratio < 0.000001f) { s.Value.Ratio = 0; } } else { s.Value.Ratio = 1; } } } else { foreach (var s in dyn.Paths) { s.Value.Ratio = 1.0f; } } } // Iterate all static blocks and calculate support mass and mass transfer foreach (var staticBlock in simData.StaticBlocks) { // Initial mass and ratio foreach (var path in staticBlock.OwnedPaths) { path.EndNode.TransferMass = 0; } // For each block in path (ordered by distance, furthest first) while (staticBlock.OwnedPaths.Count > 0) { var pathInfo = staticBlock.OwnedPaths.Pop(); var node = pathInfo.EndNode; Debug.Assert(pathInfo.StartNode == staticBlock, "Wrong path"); Debug.Assert(!node.IsStatic, "Static node unexpected"); float outgoing = node.TransferMass + node.Mass * pathInfo.Ratio; //float outgoindTotal = 0; //foreach (var p in pathInfo.Parents) // outgoindTotal += p.DirectionRatio; if (node.Pos == new Vector3I(-1, 1, 0)) { } float outgoingPerParent = outgoing / pathInfo.Parents.Count; foreach (var parent in pathInfo.Parents) { var delta = parent.EndNode.Pos - node.Pos; // Node to parent int index, parentIndex; if (delta.X + delta.Y + delta.Z > 0) { index = delta.Y + delta.Z * 2; // UnitX = 0, UnitY = 1, UnitZ = 2 parentIndex = index + 3; } else { index = -delta.X * 3 - delta.Y * 4 - delta.Z * 5; // // -UnitX = 3, -UnitY = 4, -UnitZ = 5 parentIndex = index - 3; } //outgoingPerParent = outgoing * parent.DirectionRatio / outgoindTotal; #if ENHANCED_DEBUG node.OutgoingNodeswWithWeights[index].Add(new Tuple <Node, float>(parent.EndNode, outgoingPerParent)); #endif if (index == 0 || index == 2 || index == 3 || index == 5) { node.SupportingWeights[index] -= node.PhysicalMaterial.HorisontalFragility * outgoingPerParent; } else { node.SupportingWeights[index] -= outgoingPerParent; } if (parentIndex == 0 || parentIndex == 2 || parentIndex == 3 || parentIndex == 5) { parent.EndNode.SupportingWeights[parentIndex] += parent.EndNode.PhysicalMaterial.HorisontalFragility * outgoingPerParent; } else { parent.EndNode.SupportingWeights[parentIndex] += outgoingPerParent; } #if ENHANCED_DEBUG parent.EndNode.SupportingNodeswWithWeights[parentIndex].Add(new Tuple <Node, float>(node, outgoingPerParent)); #endif parent.EndNode.TransferMass += outgoingPerParent; } node.TransferMass -= outgoing; } } using (Stats.Timing.Measure("SI - Sum", VRage.Stats.MyStatTypeEnum.Sum | VRage.Stats.MyStatTypeEnum.DontDisappearFlag)) { foreach (var node in simData.All) { //node.Value.TotalSupportingWeight = 0; } foreach (var node in simData.All) { if (node.Key == new Vector3I(-1, 1, 0)) { } float sum = 0; for (int i = 0; i < 6; i++) { float sideWeight = node.Value.SupportingWeights[i]; sum += Math.Abs(sideWeight); //sum = Math.Max(sum, Math.Abs(node.Value.SupportingWeights[i])); } if (!(sum == 0 && node.Value.PathCount == 0)) { // sum = sum * 2 - 1; node.Value.TotalSupportingWeight += node.Value.IsStatic ? 0 : (sum * 0.5f / node.Value.PathCount); } } // Idea behind blur: // When block is supporting too much weight, it deforms still supports something, but allows neighbour block to support more weight, thus sharing support List <Node> supportingNeighbours = new List <Node>(); foreach (var node in simData.All) { supportingNeighbours.Clear(); float totalSharedSupport = node.Value.TotalSupportingWeight; float totalMass = node.Value.Mass; foreach (var neighbour in node.Value.Neighbours) { bool isHorisontalNeighbour = neighbour.Pos.Y == node.Key.Y; bool isVerticallySupported = neighbour.Paths.Any(x => (x.Key.Pos.X == node.Key.X && x.Key.Pos.Z == node.Key.Z)); if (isHorisontalNeighbour && isVerticallySupported) { totalSharedSupport += neighbour.TotalSupportingWeight; totalMass += neighbour.Mass; supportingNeighbours.Add(neighbour); } } if (supportingNeighbours.Count > 0) { float supportPerNode = totalSharedSupport / totalMass; foreach (var neighbour in supportingNeighbours) { neighbour.TotalSupportingWeight = supportPerNode * neighbour.Mass; } node.Value.TotalSupportingWeight = supportPerNode * node.Value.Mass; } } foreach (var node in simData.All) { simData.TotalMax = Math.Max(simData.TotalMax, node.Value.TotalSupportingWeight); } // var timeMs = (Stopwatch.GetTimestamp() - ts) / (float)Stopwatch.Frequency * 1000.0f; //Console.WriteLine(String.Format("Generated structural integrity, time: {0}ms, object name: {1}", timeMs, m_grid.ToString())); } }
public override void Update(float distance) { Vector3 currentTranslation = AxisTranslation * MathHelper.Clamp(distance, Min, Max); currentTransform = Matrix4.CreateTranslation(currentTranslation); }
private static void UpdateWaterAmbience(float ambienceVolume, float deltaTime) { if (GameMain.SoundManager.Disabled) { return; } //how fast the sub is moving, scaled to 0.0 -> 1.0 float movementSoundVolume = 0.0f; float insideSubFactor = 0.0f; foreach (Submarine sub in Submarine.Loaded) { float movementFactor = (sub.Velocity == Vector2.Zero) ? 0.0f : sub.Velocity.Length() / 10.0f; movementFactor = MathHelper.Clamp(movementFactor, 0.0f, 1.0f); if (Character.Controlled == null || Character.Controlled.Submarine != sub) { float dist = Vector2.Distance(GameMain.GameScreen.Cam.WorldViewCenter, sub.WorldPosition); movementFactor /= Math.Max(dist / 1000.0f, 1.0f); insideSubFactor = Math.Max(1.0f / Math.Max(dist / 1000.0f, 1.0f), insideSubFactor); } else { insideSubFactor = 1.0f; } movementSoundVolume = Math.Max(movementSoundVolume, movementFactor); if (!MathUtils.IsValid(movementSoundVolume)) { string errorMsg = "Failed to update water ambience volume - submarine's movement value invalid (" + movementSoundVolume + ", sub velocity: " + sub.Velocity + ")"; DebugConsole.Log(errorMsg); GameAnalyticsManager.AddErrorEventOnce("SoundPlayer.UpdateWaterAmbience:InvalidVolume", GameAnalyticsSDK.Net.EGAErrorSeverity.Error, errorMsg); movementSoundVolume = 0.0f; } } for (int i = 0; i < 3; i++) { float volume = 0.0f; Sound sound = null; switch (i) { case 0: volume = ambienceVolume * (1.0f - movementSoundVolume) * insideSubFactor; sound = waterAmbienceIn; break; case 1: volume = ambienceVolume * movementSoundVolume * insideSubFactor; sound = waterAmbienceMoving; break; case 2: volume = 1.0f - insideSubFactor; sound = waterAmbienceOut; break; } if ((waterAmbienceChannels[i] == null || !waterAmbienceChannels[i].IsPlaying) && volume > 0.01f) { waterAmbienceChannels[i] = sound.Play(volume, "waterambience"); waterAmbienceChannels[i].Looping = true; } else if (waterAmbienceChannels[i] != null) { waterAmbienceChannels[i].Gain += deltaTime * Math.Sign(volume - waterAmbienceChannels[i].Gain); if (waterAmbienceChannels[i].Gain < 0.01f) { waterAmbienceChannels[i].FadeOutAndDispose(); } } } }
private float calculateGap(float value) => MathHelper.Clamp(value, 0, target_clamp) * targetBreakMultiplier;
// tick: renders one frame public void Tick() { screen.Clear(0); //move the lights if (dir % 2 == 0) { lightbuffer[0] += TW(0.1f); lightbuffer[5] -= TW(0.1f); lightbuffer[11] += TW(0.1f); lightbuffer[16] -= TW(0.1f); } else { lightbuffer[0] -= TW(0.1f); lightbuffer[5] += TW(0.1f); lightbuffer[11] -= TW(0.1f); lightbuffer[16] += TW(0.1f); } if (TW(worldsize) < lightbuffer[0] || lightbuffer[0] < TX(-worldsize)) { dir++; } Thread t1 = new Thread(() => { plot(TX((-worldsize + (0f / 8f * worldsize * 2))), TX((-worldsize + (1f / 8f * worldsize * 2)))); }); Thread t2 = new Thread(() => { plot(TX((-worldsize + (1f / 8f * worldsize * 2))), TX((-worldsize + (2f / 8f * worldsize * 2)))); }); Thread t3 = new Thread(() => { plot(TX((-worldsize + (2f / 8f * worldsize * 2))), TX((-worldsize + (3f / 8f * worldsize * 2)))); }); Thread t4 = new Thread(() => { plot(TX((-worldsize + (3f / 8f * worldsize * 2))), TX((-worldsize + (4f / 8f * worldsize * 2)))); }); Thread t5 = new Thread(() => { plot(TX((-worldsize + (4f / 8f * worldsize * 2))), TX((-worldsize + (5f / 8f * worldsize * 2)))); }); Thread t6 = new Thread(() => { plot(TX((-worldsize + (5f / 8f * worldsize * 2))), TX((-worldsize + (6f / 8f * worldsize * 2)))); }); Thread t7 = new Thread(() => { plot(TX((-worldsize + (6f / 8f * worldsize * 2))), TX((-worldsize + (7f / 8f * worldsize * 2)))); }); Thread t8 = new Thread(() => { plot(TX((-worldsize + (7f / 8f * worldsize * 2))), (TX((-worldsize + (8f / 8f * worldsize * 2)))) - 1); }); tarr[0] = t1; tarr[1] = t2; tarr[2] = t3; tarr[3] = t4; tarr[4] = t5; tarr[5] = t6; tarr[6] = t7; tarr[7] = t8; for (int td = 0; td < tarr.Length; td++) { tarr[td].Start(); } for (int td = 0; td < tarr.Length; td++) { tarr[td].Join(); } for (int i = 0; i < (screen.width - 1); i++) { for (int j = 0; j < (screen.height - 1); j++) { screen.Plot(i, j, MixColor(MathHelper.Clamp(floatbuffer[i, j][0], 0, 1), MathHelper.Clamp(floatbuffer[i, j][1], 0, 1), MathHelper.Clamp(floatbuffer[i, j][2], 0, 1))); } } primitivesDraw(); }
/// <summary> /// Interpolates the positional error of a physics body towards zero. /// </summary> public static Vector2 InterpolateSimPositionError(Vector2 simPositionError, float?smoothingFactor = null) { float lengthSqr = simPositionError.LengthSquared(); //correct immediately if the error is very large if (lengthSqr > 100.0f) { return(Vector2.Zero); } float positionSmoothingFactor = smoothingFactor ?? MathHelper.Lerp(0.95f, 0.8f, MathHelper.Clamp(lengthSqr, 0.0f, 1.0f)); return(simPositionError *= positionSmoothingFactor); }