private void ChangeColors() { const double ALPHAMULT = .33d; if (this.IsEnabled) { this.ArrowBorderFinal = new SolidColorBrush(this.ArrowBorder); this.ArrowBackgroundFromFinal = this.ArrowBackgroundFrom; this.ArrowBackgroundToFinal = this.ArrowBackgroundTo; } else { ColorHSV hsv = this.ArrowBorder.ToHSV(); double a = UtilityCore.GetScaledValue_Capped(0d, 255d, 0d, 255d, this.ArrowBorder.A * ALPHAMULT); this.ArrowBorderFinal = new SolidColorBrush(UtilityWPF.HSVtoRGB(Convert.ToByte(a), hsv.H, 0d, hsv.V)); hsv = this.ArrowBackgroundFrom.ToHSV(); a = UtilityCore.GetScaledValue_Capped(0d, 255d, 0d, 255d, this.ArrowBackgroundFrom.A * ALPHAMULT); this.ArrowBackgroundFromFinal = UtilityWPF.HSVtoRGB(Convert.ToByte(a), hsv.H, 0d, hsv.V); hsv = this.ArrowBackgroundTo.ToHSV(); a = UtilityCore.GetScaledValue_Capped(0d, 255d, 0d, 255d, this.ArrowBackgroundTo.A * ALPHAMULT); this.ArrowBackgroundToFinal = UtilityWPF.HSVtoRGB(Convert.ToByte(a), hsv.H, 0d, hsv.V); } }
private Tuple <Point3D, Vector3D> GetPositionVelocity(double mass) { //mass of ice = .46 //mass of platinum = 10.7 //small asteroid = 80-226 //large asteroid = 550-916 // Percent (more massive toward the center) double percent = UtilityCore.GetScaledValue_Capped(.05, .85, 0, 1000, mass); percent = 1d - percent; //GetScaledValue can't handle inverted ranges, so invert outside of it percent = percent * percent * percent; // it works better with nonlinear // Position Vector3D posXY = Math3D.GetRandomVector_Circular(_boundryMax.X * (percent - .03), _boundryMax.X * (percent + .03)); double z = Math1D.GetNearZeroValue(_boundryMax.Z) * .15; Point3D position = new Point3D(posXY.X, posXY.Y, z); // Velocity double speed = UtilityCore.GetScaledValue_Capped(_boundryMax.X * .001, _boundryMax.X * .05, 0, 1, percent); Vector3D velocity = posXY.ToUnit().GetRotatedVector(new Vector3D(0, 0, 1), -90) * speed; return(Tuple.Create(position, velocity)); }
private void trkSimulationSpeed_ValueChanged(object sender, RoutedPropertyChangedEventArgs <double> e) { if (_world == null || trkSimulationSpeed == null || lblSimSpeed == null) { return; } double speed = 1d; double halfRange = trkSimulationSpeed.Minimum + ((trkSimulationSpeed.Maximum - trkSimulationSpeed.Minimum) / 2d); if (trkSimulationSpeed.Value >= halfRange) { speed = UtilityCore.GetScaledValue_Capped(1d, 10d, halfRange, trkSimulationSpeed.Maximum, trkSimulationSpeed.Value); } else { speed = UtilityCore.GetScaledValue_Capped(.1d, 1d, trkSimulationSpeed.Minimum, halfRange, trkSimulationSpeed.Value); } _world.SimulationSpeed = speed; speed = Math.Round(speed, 3); lblSimSpeed.Content = speed.ToString(); }
private static (double speed, double error) GetWeaponSpeedError(ArcBot2 bot, double minSpeed, double maxSpeed, double maxSpeed2) { Vector3D relativeSpeed = bot.Weapon.VelocityWorld - bot.VelocityWorld; // This is kind of rough, because it will be the speed of the center point. May also need angular velocity double speed = relativeSpeed.Length; double error = 0; if (speed < minSpeed) { error = UtilityCore.GetScaledValue_Capped(0, 1, minSpeed, 0, speed); } else if (speed > maxSpeed) { if (speed > maxSpeed2) { error = 1; } else { error = UtilityCore.GetScaledValue_Capped(0, 1, maxSpeed, maxSpeed2, speed); } } return(speed, error); }
private void UpdateNeurons_progressiveRadius(Vector3D gravity, double magnitude) { if (Math3D.IsNearZero(gravity)) { // There is no gravity to report for (int cntr = 0; cntr < _neurons.Length; cntr++) { _neurons[cntr].Value = 0d; } return; } for (int cntr = 0; cntr < _neurons.Length; cntr++) { if (_neurons[cntr].PositionUnit == null) { // This neuron is sitting at 0,0,0 _neurons[cntr].Value = magnitude; } else { // Scale minDot double radiusPercent = _neurons[cntr].PositionLength / _neuronMaxRadius; _neurons[cntr].Value = UtilityCore.GetScaledValue_Capped(0d, 1d, 0d, 1d, 1d - radiusPercent); } } }
private void trkCrossoverDistance_Scroll(object sender, EventArgs e) { double distance = UtilityCore.GetScaledValue_Capped(double.Parse(lblCrossoverMin.Text), double.Parse(lblCrossoverMax.Text), trkCrossoverDistance.Minimum, trkCrossoverDistance.Maximum, trkCrossoverDistance.Value); toolTip1.SetToolTip(trkCrossoverDistance, distance.ToString()); _shipController.MachineGunCrossoverDistance = distance; }
private void GetMineralBlipSprtCacheProps() { // Get the min/max values double minDollars = double.MaxValue; double maxDollars = double.MinValue; SortedList <MineralType, double> dollars = new SortedList <MineralType, double>(); foreach (MineralType mineralType in Enum.GetValues(typeof(MineralType))) { if (mineralType == MineralType.Custom) { continue; } decimal suggestedDollars = Mineral.GetSuggestedValue(mineralType); double suggestedDollarsScaled = Math.Sqrt(Convert.ToDouble(suggestedDollars)); // taking the square root, because the values are exponential, and I want the color scale more linear dollars.Add(mineralType, suggestedDollarsScaled); if (suggestedDollarsScaled < minDollars) { minDollars = suggestedDollarsScaled; } if (suggestedDollarsScaled > maxDollars) { maxDollars = suggestedDollarsScaled; } } // Store color based on those values _mineralColors = new SortedList <MineralType, MineralBlipProps>(); Color maxColor = Colors.Chartreuse; foreach (MineralType mineralType in Enum.GetValues(typeof(MineralType))) { MineralBlipProps props = new MineralBlipProps(); if (mineralType == MineralType.Custom) { props.DiffuseColor = Colors.HotPink; // not sure what to do here. maybe I'll know more if I ever use custom minerals :) props.SpecularColor = props.DiffuseColor; props.Size = 4; } else { double dollar = dollars[mineralType]; double colorPercent = UtilityCore.GetScaledValue_Capped(.33d, 1d, minDollars, maxDollars, dollar); props.DiffuseColor = UtilityWPF.AlphaBlend(maxColor, Colors.Transparent, colorPercent); props.SpecularColor = props.DiffuseColor; props.Size = UtilityCore.GetScaledValue_Capped(2d, 5d, minDollars, maxDollars, dollar); } _mineralColors.Add(mineralType, props); } }
private void PhysicsBody_BodyMoved(object sender, EventArgs e) { if (!_isVisualAdded) { return; } // Graphics need to be updated here. If I wait until world update, this graphic will be one frame // behind, which is very noticable when the bot has a high velocity double damageMult = GetDamageMultiplier(); Vector3D velocity = _bot.VelocityWorld; var dna = this.DNA; // Light size double lightSize = UtilityCore.GetScaledValue_Capped(0, _bot.Radius * 4, 0, dna.DamageMult * 20, damageMult); UtilityWPF.SetAttenuation(_light, lightSize, .1d); _light.Color = Color.FromArgb(Convert.ToByte(UtilityCore.GetScaledValue_Capped(0, 192, 0, dna.DamageMult * 10, damageMult)), 255, 0, 0); // Scale double scale; if (damageMult < dna.DamageMult * 4) { scale = 0; } else { scale = UtilityCore.GetScaledValue_Capped(0, _bot.Radius, dna.DamageMult * 4, dna.DamageMult * 25, damageMult); } _scale.ScaleX = scale; _scale.ScaleY = scale; _scale.ScaleZ = scale; // Translate Point3D position = _bot.PositionWorld + (velocity.ToUnit() * (_bot.Radius * UtilityCore.GetScaledValue_Capped(1.05, 1.3, 0, dna.DamageMult * 25, damageMult))); _translate.OffsetX = position.X; _translate.OffsetY = position.Y; _translate.OffsetZ = position.Z; // Rotate Vector3D xAxis = new Vector3D(1, 0, 0); Vector3D axis = Vector3D.CrossProduct(xAxis, velocity); double angle = Vector3D.AngleBetween(xAxis, velocity); if (Math3D.IsNearZero(axis) || Math1D.IsNearZero(angle)) { _rotate.Quaternion = Quaternion.Identity; } else { _rotate.Quaternion = new Quaternion(axis, angle); } }
/// <summary> /// This will return null if it's not a multiplier, or not valid to do a multiplier /// </summary> private ConvertProps IsMultiplier() { if (this.Parent == null) { return(null); } else if (!this.Parent.IsMultiplier) { return(null); } // They want log, make sure min and max are appropriate double absMin = Math.Abs(this.Parent.Minimum); double absMax = Math.Abs(this.Parent.Maximum); if (absMin > 1 || absMax < 1) { // 1 needs to be between them return(null); } else if (absMin == 0) { // Min can't be zero, that's an asymptote return(null); } bool isMinPositive = this.Parent.Minimum > 0; bool isMaxPositive = this.Parent.Maximum > 0; if (isMinPositive != isMaxPositive) { // They must either both be negative, or both be positive return(null); } // Use the ratio of min:max to figure out the percent along the progress bar one should be at. If the ratio is the same // (.25 to 4, or .1 to 10, etc), then the % should be .5. If there is more to the right than left, then adjust the mid point // left a bit so that more of the progress bar is available double invertAbsMin = 1d / absMin; double ratio = invertAbsMin / absMax; if (ratio < 1) { ratio = UtilityCore.GetScaledValue_Capped(.25d, .5, .1, 1, ratio); //reusing the ratio variable to be % along progress bar. never let it go less than .25 so that the progress bar stays usable } else { ratio = UtilityCore.GetScaledValue_Capped(.5d, .75, 1, 10, ratio); } double absMiddle = absMin + ((absMax - absMin) * ratio); // Need to do a multiplier scale. Return a filled out object return(new ConvertProps(absMin, absMax, absMiddle, isMinPositive)); }
/// <summary> /// This sets all the neurons from 0 to magnitude. Magnitude needs to be from 0 to 1, and is based on the currently felt gravity compared /// to what the sensor has seen as the max felt /// </summary> internal static void UpdateNeurons(Neuron_SensorPosition[] neurons, double neuronMaxRadius, Vector3D vector, double magnitude) { const double MINDOT = 1.25d; if (Math3D.IsNearZero(vector)) { // There is no gravity to report for (int cntr = 0; cntr < neurons.Length; cntr++) { neurons[cntr].Value = 0d; } return; } Vector3D gravityUnit = vector.ToUnit(); for (int cntr = 0; cntr < neurons.Length; cntr++) { if (neurons[cntr].PositionUnit == null) { // This neuron is sitting at 0,0,0 neurons[cntr].Value = magnitude; } else { // Figure out how aligned this neuron is with the gravity vector double dot = Vector3D.DotProduct(gravityUnit, neurons[cntr].PositionUnit.Value); dot += 1d; // get this to scale from 0 to 2 instead of -1 to 1 // Scale minDot double radiusPercent = neurons[cntr].PositionLength / neuronMaxRadius; double revisedMinDot = UtilityCore.GetScaledValue_Capped(0d, MINDOT, 0d, 1d, radiusPercent); // Rig it so that the lower radius neurons will fire stronger double minReturn = 1d - radiusPercent; if (minReturn < 0d) { minReturn = 0d; } // Figure out what percentage of magnitude to use double percent; if (dot < revisedMinDot) { percent = UtilityCore.GetScaledValue_Capped(0d, minReturn, 0d, revisedMinDot, dot); } else { percent = UtilityCore.GetScaledValue_Capped(minReturn, 1d, revisedMinDot, 2d, dot); } // Set the neuron neurons[cntr].Value = percent * magnitude; } } }
private void UpdateNeurons() { const double MINDOT = 1.75d; //it's dot+1, so dot goes from 0 to 2 // Get the direction from the current position to the home point Vector3D direction = GetDirectionModelCoords(); if (Math3D.IsNearZero(direction)) { // They are sitting on the home point. Zero everything out and exit for (int cntr = 0; cntr < _neurons.Length; cntr++) { _neurons[cntr].Value = 0d; } return; } // Get max neuron value double directionLength = direction.Length; double magnitude; if (directionLength < _homeRadius) { magnitude = directionLength / _homeRadius; } else { magnitude = 1; } Vector3D directionUnit = direction.ToUnit(); for (int cntr = 0; cntr < _neurons.Length; cntr++) { if (_neurons[cntr].PositionUnit == null) { // This neuron is sitting at 0,0,0 _neurons[cntr].Value = 0d; } else { double dot = Vector3D.DotProduct(directionUnit, _neurons[cntr].PositionUnit.Value); dot += 1d; // get this to scale from 0 to 2 instead of -1 to 1 if (dot < MINDOT) { _neurons[cntr].Value = 0d; } else { _neurons[cntr].Value = UtilityCore.GetScaledValue_Capped(0d, magnitude, MINDOT, 2d, dot); } } } }
public FitnessInfo?EvaluateTick(double elapedTime) { if (!_isEvaluating) { // This is called after the score has been given, but before a new phenome is assigned throw new InvalidOperationException("EvaluateTick was called at an invalid time. Either StartNewEvaluation was never called, or the current phenome has returned a final score and this class is waiting for a new call to StartNewEvaluation"); } // Get the bot's distance from home double distance = (_bot.PositionWorld - _homePoint).Length; // Run that distance through a scoring function double thisError = 0d; if (distance < _minDistance) { thisError = UtilityCore.GetScaledValue_Capped(1, 0, 0, _minDistance, distance); } else if (distance > _maxDistance2) { thisError = 1; } else if (distance > _maxDistance) { thisError = UtilityCore.GetScaledValue_Capped(0, 1, _maxDistance, _maxDistance2, distance); } // Add the error to the total (cap it if time is exceeded) double actualElapsed = elapedTime; if (_runningTime + elapedTime > _maxEvalTime) { actualElapsed = _maxEvalTime - _runningTime; } thisError *= actualElapsed; _error += thisError; _runningTime += elapedTime; // If the counter is a certain amount, return the final score if (_runningTime >= _maxEvalTime) { // It's been tested long enough. Return the score (score needs to grow, so an error of zero will give max score) double fitness = _runningTime - _error; return(new FitnessInfo(fitness, fitness)); } else { // Still evaluating return(null); } }
public void SetPercent(double percent) { //if (percent < 0) percent = 0; // capped caps the output anyway //else if (percent > 1) percent = 1; // If it gets much smaller than .75, it won't be visible, and much bigger than .92, it will poke though the outer visual double scale = UtilityCore.GetScaledValue_Capped(.75, .92, 0, 1, percent); this.Scale.ScaleX = scale; this.Scale.ScaleY = scale; this.Scale.ScaleZ = scale; }
/// <summary> /// This will emulate sounds coming from locations relative to the listener /// </summary> /// <remarks> /// Note that sound intensity doesn't diminish linearly from by distance, but by: /// I = P/(4*pi*r^2) /// /// I is final intensity /// P is intensity at the source /// r is distance from the listener /// </remarks> /// <param name="volume">0 (none) to 1 (full)</param> /// <param name="balance">-1 (all left) to 1 (all right)</param> /// <param name="offset">The location of the sound relative to the listener</param> /// <param name="sourceVolume">0 (none) to 1 (full) - this is how loud the source would be at the listener</param> private void GetPositionalSoundSettings(out double volume, out double balance, Vector3D offset, double sourceVolume) { #region Calculate Volume // I won't range check the input volume - I'll leave it up to the media player to either bomb or cap it double intensityRatio = 1d; double offsetLength = offset.Length; if (_distanceFalloffRatio == 0d || Math1D.IsNearZero(offsetLength)) { volume = sourceVolume; } else { double distance = offsetLength * _distanceFalloffRatio; intensityRatio = 1d / (4d * Math.PI * distance * distance); // I need this intensity when calculating balance volume = sourceVolume * intensityRatio; } #endregion #region Calculate Balance // This means that if a sound is a distance of very near zero, and all the way to the left or right, then instead of +-1, it is +-.5 const double MAXOPPOSITE_EAR = .5d; // When the intensity would be 75% of max, then I won't add anything to the opposite ear const double MAXOPPOSITE_DISTANCEINTENSITY = .75d; // Getting the angle (I don't want Z) double angle = Vector3D.AngleBetween(new Vector3D(1, 0, 0), new Vector3D(offset.X, offset.Y, 0)); // cos(0) is 1, cos(90) is 0, cos(180) is -1. Exactly what I need balance = Math.Cos(Math1D.DegreesToRadians(angle)); //NOTE: The problem with a pure cosine is that if a loud sound is sitting very near the person, but on the left, then in reality, the right // ear would hear something, but a simple cosine would be all the way -1 // // So, I'm going to approach .5 for objects that are near (still on the left, but can be heard on the right) if (intensityRatio > MAXOPPOSITE_DISTANCEINTENSITY) { // So when the intensity is 1 (right next to the head), then I will give back .5 // When the intensity is at the limit, then balance will be the pure cosine value // Anywhere in between is a linear interpelation balance = UtilityCore.GetScaledValue_Capped(balance, MAXOPPOSITE_EAR * balance, MAXOPPOSITE_DISTANCEINTENSITY, 1d, intensityRatio); } #endregion //TODO: Take in relative velocity, then manipulate playback speed to emulate doppler (unless there is a way to change pitch directly) }
private static Color GetNodeColor_Finish(Tuple <double, double, double> raw) { // Scale to bytes. This assumes that the weights are normalized between -1 and 1 //TODO: Handle negatives Color orig = Color.FromRgb( Convert.ToByte(UtilityCore.GetScaledValue_Capped(0, 255, 0, 1, Math.Abs(raw.Item1))), Convert.ToByte(UtilityCore.GetScaledValue_Capped(0, 255, 0, 1, Math.Abs(raw.Item2))), Convert.ToByte(UtilityCore.GetScaledValue_Capped(0, 255, 0, 1, Math.Abs(raw.Item3)))); // Bring up the saturation ColorHSV hsv = UtilityWPF.RGBtoHSV(orig); return(UtilityWPF.HSVtoRGB(hsv.H, Math.Max(hsv.S, 40), hsv.V)); }
private Color GetGreenRedColor(double minTarget, double maxTarget, double actualValue, double sizePercent) { if (sizePercent < .9d) { return(Color.OliveDrab); } else { double derivedMinTarget = UtilityCore.GetScaledValue(minTarget, maxTarget, 0d, 1d, .9d); double colorPercent = UtilityCore.GetScaledValue_Capped(0d, 1d, derivedMinTarget, maxTarget * 3d, actualValue); return(UtilityGDI.AlphaBlend(Color.Firebrick, Color.OliveDrab, colorPercent)); } }
/// <summary> /// This returns a linear gradient brush to paint an arrow. The arrow gets darker as the speed increases /// </summary> private static LinearGradientBrush GetArrowBrush(double speed) { // Since the speed is distance cubed, I want to take the cube root so the darkness grows linearly. If I don't // then it stays light for most of the range, and spikes to dark. //double cubeRoot = Math.Pow(speed, .33333333333d); double cubeRoot = Math.Pow(speed, .5d); // actually, I decided to take the square root, sort of splitting the difference between linear and extreme //double darkAlpha = UtilityHelper.GetScaledValue_Capped(45, 192, 0, 500, speed); //double darkAlpha = UtilityHelper.GetScaledValue_Capped(45, 192, 0, 7.9370052d, cubeRoot); double darkAlpha = UtilityCore.GetScaledValue_Capped(45, 192, 0, 22.3606798d, cubeRoot); double lightAlpha = darkAlpha / 1.4d; return(new LinearGradientBrush(Color.FromArgb(Convert.ToByte(darkAlpha), 0, 0, 0), Color.FromArgb(Convert.ToByte(lightAlpha), 0, 0, 0), 90)); }
private void FireAttractEvent() { if (this.AttractionChanged == null) { return; } BodyAttractionType attractionType = GetAttractionType(); double distance = trkDistance.Value; double strength; switch (attractionType) { case BodyAttractionType.Gravity: strength = UtilityCore.GetScaledValue_Capped(0, 125, trkStrength.Minimum, trkStrength.Maximum, trkStrength.Value); break; case BodyAttractionType.Spring: strength = UtilityCore.GetScaledValue_Capped(0, 10, trkStrength.Minimum, trkStrength.Maximum, trkStrength.Value); break; case BodyAttractionType.SpringDesiredDistance: strength = UtilityCore.GetScaledValue_Capped(0, 50, trkStrength.Minimum, trkStrength.Maximum, trkStrength.Value); distance = UtilityCore.GetScaledValue_Capped(0, 100, trkDistance.Minimum, trkDistance.Maximum, trkDistance.Value); break; case BodyAttractionType.SpringInverseDist: strength = UtilityCore.GetScaledValue_Capped(0, 10, trkStrength.Minimum, trkStrength.Maximum, trkStrength.Value); break; case BodyAttractionType.Tangent: strength = UtilityCore.GetScaledValue_Capped(0, 200, trkStrength.Minimum, trkStrength.Maximum, trkStrength.Value); distance = UtilityCore.GetScaledValue_Capped(0, 50, trkDistance.Minimum, trkDistance.Maximum, trkDistance.Value); break; case BodyAttractionType.Constant: strength = UtilityCore.GetScaledValue_Capped(0, 20, trkStrength.Minimum, trkStrength.Maximum, trkStrength.Value); break; default: strength = UtilityCore.GetScaledValue_Capped(0, 100, trkStrength.Minimum, trkStrength.Maximum, trkStrength.Value); break; } BodyAttractionArgs args = new BodyAttractionArgs(GetAttractionType(), GetIsToward(), strength, distance); this.AttractionChanged(this, args); }
private void AdjustPlates() { // Pixels if (chkShowPixels.IsChecked.Value) { grdPixels.Visibility = Visibility.Visible; grdPixels.Opacity = UtilityCore.GetScaledValue_Capped(0d, 1d, trkPixelOpacity.Minimum, trkPixelOpacity.Maximum, trkPixelOpacity.Value); } else { grdPixels.Visibility = Visibility.Collapsed; } // Polygons if (chkShowPolygons.IsChecked.Value) { grdPolygons.Visibility = Visibility.Visible; grdPolygons.Opacity = UtilityCore.GetScaledValue_Capped(0d, 1d, trkPolygonOpacity.Minimum, trkPolygonOpacity.Maximum, trkPolygonOpacity.Value); } else { grdPolygons.Visibility = Visibility.Collapsed; } // Triangles if (chkShowTriangles.IsChecked.Value) { grdTriangles.Visibility = Visibility.Visible; grdTriangles.Opacity = UtilityCore.GetScaledValue_Capped(0d, 1d, trkTriangleOpacity.Minimum, trkTriangleOpacity.Maximum, trkTriangleOpacity.Value); } else { grdTriangles.Visibility = Visibility.Collapsed; } // Circles if (chkShowCircles.IsChecked.Value) { grdCircles.Visibility = Visibility.Visible; grdCircles.Opacity = UtilityCore.GetScaledValue_Capped(0d, 1d, trkCircleOpacity.Minimum, trkCircleOpacity.Maximum, trkCircleOpacity.Value); } else { grdCircles.Visibility = Visibility.Collapsed; } grdTriangles_SizeChanged(this, null); }
private void GetMineralBlipSprtCacheProps() { // Get the min/max values double minDollars = double.MaxValue; double maxDollars = double.MinValue; SortedList <MineralType, double> dollars = new SortedList <MineralType, double>(); foreach (MineralType mineralType in Enum.GetValues(typeof(MineralType))) { //decimal suggestedDollars = Mineral.GetSuggestedCredits(mineralType); decimal suggestedDollars = ItemOptionsAstMin2D.GetCredits_Mineral(mineralType); double suggestedDollarsScaled = Math.Sqrt(Convert.ToDouble(suggestedDollars)); // taking the square root, because the values are exponential, and I want the color scale more linear dollars.Add(mineralType, suggestedDollarsScaled); if (suggestedDollarsScaled < minDollars) { minDollars = suggestedDollarsScaled; } if (suggestedDollarsScaled > maxDollars) { maxDollars = suggestedDollarsScaled; } } // Store color based on those values _mineralColors = new SortedList <MineralType, MineralBlipProps>(); Color maxColor = Colors.Chartreuse; foreach (MineralType mineralType in Enum.GetValues(typeof(MineralType))) { Color diffuse, specular; double size; double dollar = dollars[mineralType]; double colorPercent = UtilityCore.GetScaledValue_Capped(.33d, 1d, minDollars, maxDollars, dollar); diffuse = UtilityWPF.AlphaBlend(maxColor, Colors.Transparent, colorPercent); specular = diffuse; //size = UtilityCore.GetScaledValue_Capped(2d, 5d, minDollars, maxDollars, dollar); size = UtilityCore.GetScaledValue_Capped(4d, 10d, minDollars, maxDollars, dollar); _mineralColors.Add(mineralType, new MineralBlipProps(diffuse, specular, size)); } }
//TODO: This functionality should be part of MapObjectChaseVelocity private static Point3D?AdjustIfOffPlane(Point3D itemPos, double itemRadius, DragHitShape dragPlane, Point3D?chasePoint) { const double MAXOFFSET = 1.5; const double PERCENTATMAX = .01; // even if they are really far off the plane, don't completely chase the plane, some percent needs to go toward the chase point passed in Point3D?pointOnPlane = dragPlane.CastRay(itemPos); if (pointOnPlane == null) { // Don't know where they are relative to the plane (this should never happen) return(chasePoint); } else if (Math3D.IsNearValue(pointOnPlane.Value, itemPos)) { // They're position is the same as the point on the plane (they are already on the plane) return(chasePoint); } Vector3D vectToPlane = (itemPos - pointOnPlane.Value); double distToPlane = vectToPlane.Length; if (distToPlane < itemRadius * .01) { // They are less than a percent of their body size off the plane, just return the point passed in return(chasePoint); } if (chasePoint == null) { // Null was passed in, just go straight for the plane (this should never happen) return(pointOnPlane); } // Figure out how much to dive for the plane vs go for the chase point double offset = distToPlane / itemRadius; double percent = PERCENTATMAX; if (offset < MAXOFFSET) { // They are less than the max allowable distance from the plane percent = UtilityCore.GetScaledValue_Capped(PERCENTATMAX, 1d, 0, MAXOFFSET, MAXOFFSET - offset); } Vector3D direction = chasePoint.Value - pointOnPlane.Value; return(pointOnPlane.Value + (direction * percent)); }
public override bool Update(double elapsedTime) { bool retVal = base.Update(elapsedTime); if (retVal) { RemoveVisual(); } else { #region Update Visual // Transparency double transparency = UtilityCore.GetScaledValue_Capped(0d, 1d, _visualStartRadius, this.MaxRadius * .75d, this.Radius); // I want it to become invisible sooner _material.Brush = new SolidColorBrush(UtilityWPF.AlphaBlend(Colors.Transparent, _baseColor, transparency)); // Scale (this is what Body.OnBodyMoved does, plus scale) //NOTE: The radius gets huge, but the force drops off quickly, so it doesn't look right if I scale it to full size double scale = UtilityCore.GetScaledValue_Capped(1d, (this.MaxRadius * .05d) / _visualStartRadius, _visualStartRadius, this.MaxRadius, this.Radius); Transform3DGroup transform = new Transform3DGroup(); transform.Children.Add(new ScaleTransform3D(scale, scale, scale)); if (this.Body == null) { transform.Children.Add(new TranslateTransform3D(this.Position.ToVector())); } else { transform.Children.Add(new MatrixTransform3D(this.Body.OffsetMatrix)); } _visual.Transform = transform; //NOTE: The shell is smaller than this.Radius (once it overtakes _visualStartRadius) if (this.Radius > _visualStartRadius * 2) { _pointLight.Range = this.Radius; } #endregion } // Exit Function return(retVal); }
private static (double distance, double error) GetDistanceError(Bot bot, Point3D center, double maxDistance, double maxDistance2) { // Get the bot's distance from home double distance = (bot.PositionWorld - center).Length; // Run that distance through a scoring function double error = 0d; if (distance > maxDistance2) { error = 1; } else if (distance > maxDistance) { error = UtilityCore.GetScaledValue_Capped(0, 1, maxDistance, maxDistance2, distance); } return(distance, error); }
private void ResizeColorBar() { #region Figure out percent double percent = 0d; // If they don't add up, don't throw an error, just make it invisible (they are probably in the middle of setting the properties if (_minimum >= _maximum || _value < _minimum) { percent = 0d; } else if (_value > _maximum) { percent = 1d; } else { percent = UtilityCore.GetScaledValue_Capped(0d, 1d, _minimum, _maximum, _value); } #endregion #region Set grid column widths if (percent == 0d) { barWidth.Width = new GridLength(0d); remainderWidth.Width = new GridLength(1d, GridUnitType.Star); } else if (percent == 1d) { barWidth.Width = new GridLength(1d, GridUnitType.Star); remainderWidth.Width = new GridLength(0d); } else { // I propably don't need to multiply by 100, but I feel better barWidth.Width = new GridLength(percent * 100, GridUnitType.Star); remainderWidth.Width = new GridLength((1d - percent) * 100, GridUnitType.Star); } #endregion }
private double GetPastingBallsOpacity() { const int INITIALDELAY = 750; const int FADEDURATION = 300; int tickCount = Environment.TickCount; if (tickCount - _lastMouseMove <= INITIALDELAY) { return(1d); } if (tickCount - _lastMouseMove < INITIALDELAY + FADEDURATION) { int fadeElapse = FADEDURATION - (tickCount - _lastMouseMove - INITIALDELAY); // I reversed it so I can run the result through the LERP function return(UtilityCore.GetScaledValue_Capped(0d, 1d, 0, FADEDURATION, fadeElapse)); } return(0d); }
private Model3D GetRing() { double size = UtilityCore.GetScaledValue_Capped(.025d, .15d, .1d, 10d, _radius); GeometryModel3D retVal = new GeometryModel3D(); MaterialGroup material = new MaterialGroup(); DiffuseMaterial diffuse = new DiffuseMaterial(new SolidColorBrush(this.EditorColors.DraggableModifier)); this.MaterialBrushes.Add(new MaterialColorProps(diffuse, diffuse.Brush, this.EditorColors.DraggableModifier)); material.Children.Add(diffuse); SpecularMaterial specular = new SpecularMaterial(new SolidColorBrush(this.EditorColors.DraggableModifier_SpecularColor), this.EditorColors.DraggableModifier_SpecularPower); this.MaterialBrushes.Add(new MaterialColorProps(specular)); material.Children.Add(specular); retVal.Material = material; retVal.BackMaterial = material; retVal.Geometry = UtilityWPF.GetRing(50, _radius - (size * .5d), _radius + (size * .5d), size, _initialRotateTransform); return(retVal); }
private static (double speed, double error) GetSpeedError(Bot bot, double minSpeed, double maxSpeed, double maxSpeed2) { double speed = bot.VelocityWorld.Length; double error = 0; if (speed < minSpeed) { error = UtilityCore.GetScaledValue_Capped(0, 1, minSpeed, 0, speed); } else if (speed > maxSpeed2) { error = 1; } else if (speed > maxSpeed) { error = UtilityCore.GetScaledValue_Capped(0, 1, maxSpeed, maxSpeed2, speed); } return(speed, error); }
/// <summary> /// Take the slider value, and map it to the public value /// </summary> public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) { double valueCast = (double)value; ConvertProps props = IsMultiplier(); if (props != null) { double absValue = Math.Abs(valueCast); double retVal; if (absValue > props.AbsMiddle) { double percent = (absValue - props.AbsMiddle) / (props.AbsMax - props.AbsMiddle); // Scale that to go from 1 to max retVal = UtilityCore.GetScaledValue_Capped(1d, props.AbsMax, 0d, 1d, percent); } else { double percent = (absValue - props.AbsMin) / (props.AbsMiddle - props.AbsMin); // Scale that to go from min to 1 retVal = UtilityCore.GetScaledValue_Capped(props.AbsMin, 1d, 0d, 1d, percent); } if (!props.IsPositive) { // Negate retVal *= -1d; } return(retVal); } else { return(valueCast); } }
private void UpdateNeurons_fixed(Vector3D gravity, double magnitude) { const double MINDOT = 1d; if (Math3D.IsNearZero(gravity)) { // There is no gravity to report for (int cntr = 0; cntr < _neurons.Length; cntr++) { _neurons[cntr].Value = 0d; } return; } Vector3D gravityUnit = gravity.ToUnit(); for (int cntr = 0; cntr < _neurons.Length; cntr++) { if (_neurons[cntr].PositionUnit == null) { // This neuron is sitting at 0,0,0 _neurons[cntr].Value = magnitude; } else { double dot = Vector3D.DotProduct(gravityUnit, _neurons[cntr].PositionUnit.Value); dot += 1d; // get this to scale from 0 to 2 instead of -1 to 1 if (dot < MINDOT) { _neurons[cntr].Value = 0d; } else { _neurons[cntr].Value = UtilityCore.GetScaledValue_Capped(0d, 1d, MINDOT, 2d, dot); } } } }
private static Quaternion?DoStep_Rotate(Vector3D torque, double size, double penetrationScale) { const double MAXANGLE = 12d; //22.5d; if (Math3D.IsNearZero(torque)) { return(null); } double length = torque.Length; Vector3D axis = torque / length; // Since the max torque will be a full penetration out at radius, that will be penetration cross radius. So the length of that will be // roughly (size/2)^2 //double maxExpected = Math.Pow(size * .33d, 2d); // make the max size a bit smaller than half, since a max penetration would be really rare //double maxExpected = size * size; double maxExpected = (size * .5d) * (size * penetrationScale); // Make the angle to be some proportion between the torque's length and the average size of the part double angle = UtilityCore.GetScaledValue_Capped(0d, MAXANGLE, 0d, maxExpected, length); return(new Quaternion(axis, angle)); }