/// <inheritdoc />
protected override Task HandleSubMessage(IPeerMessageContext <PSOBBGamePacketPayloadClient> context, TPositionChangeCommandType command)
{
int entityGuid = EntityGuid.ComputeEntityGuid(EntityType.Player, command.Identifier);
//TODO: is this the best approach, just ignoring/ditching the position of players
//if they aren't in our zone?
if (!MovementManagerMappable.ContainsKey(entityGuid))
{
return(Task.CompletedTask);
}
//We can safely assume they have a known world transform or they can't have been spawned.
Vector2 position = Scaler.ScaleYasZ(command.Position);
MovementManagerMappable[entityGuid].RegisterState(CreateMovementGenerator(position, command));
//New position commands should be direcly updating the entity's position. Even though "MovementGenerators" handle true movement by learping them.
//They aren't the source of Truth since they aren't deterministic/authorative like is REAL MMOs. So, the true source of truth is the WorldTransform.
Vector3 positionIn3dSpace = new Vector3(position.x, WorldTransformMappable[entityGuid].Position.y, position.y);
WorldTransformMappable[entityGuid] = new WorldTransform(positionIn3dSpace, WorldTransformMappable[entityGuid].Rotation);
return(Task.CompletedTask);
}
private void Awake()
{
var gameHandler = this.gameObject.GetComponent <GameHandler>();
gameHandler.WaveStarts += StartSpawningWave;
this.scaler = gameHandler.Scaler;
}
/// <inheritdoc cref="Series{TModel, TVisual, TLabel, TDrawingContext}.SoftDeletePoint(ChartPoint, Scaler, Scaler)"/>
protected override void SoftDeletePoint(ChartPoint point, Scaler primaryScale, Scaler secondaryScale)
{
var visual = (TVisual?)point.Context.Visual;
if (visual == null)
{
return;
}
var chartView = (ICartesianChartView <TDrawingContext>)point.Context.Chart;
if (chartView.Core.IsZoomingOrPanning)
{
visual.CompleteAllTransitions();
visual.RemoveOnCompleted = true;
return;
}
var p = primaryScale.ToPixels(pivot);
var secondary = secondaryScale.ToPixels(point.SecondaryValue);
visual.X = secondary;
visual.Y = p;
visual.Height = 0;
visual.RemoveOnCompleted = true;
if (dataProvider == null)
{
throw new Exception("Data provider not found");
}
dataProvider.DisposePoint(point);
}
private void Start()
{
handler = GetComponent <AnimatedUIHandler>();
game = FindObjectOfType <Game>();
game.BestScore.AddListener(BestScore);
scaler = FindObjectOfType <Scaler>();
}
private void PerformZoom()
{
if (Config.Zoom == 100)
{
ShipLabel.Name.BaseFont = Form.Font;
ShipLabel.Name.LatinFont = LatinFont();
return;
}
var prev = Form.CurrentAutoScaleDimensions;
foreach (var control in new Control[]
{
Form, _c.fleetPanel.Guide, _c.hqPanel.Login,
_contextMenuMain
}.Concat(_main.Controls))
{
control.Font = ZoomFont(control.Font);
}
_listFormGroup.Font = ZoomFont(_listFormGroup.Font);
foreach (var toolTip in new[] { _toolTip, _tooltipCopy })
{
toolTip.Font = ZoomFont(toolTip.Font);
}
ShipLabel.Name.BaseFont = Form.Font;
ShipLabel.Name.LatinFont = LatinFont();
var cur = Form.CurrentAutoScaleDimensions;
Scaler.Factor = Scaler.Scale(cur.Width / prev.Width, cur.Height / prev.Height);
}
/// <summary>
/// Softs the delete point.
/// </summary>
/// <param name="point">The point.</param>
/// <param name="primaryScale">The primary scale.</param>
/// <param name="secondaryScale">The secondary scale.</param>
protected override void SoftDeletePoint(ChartPoint point, Scaler primaryScale, Scaler secondaryScale)
{
var visual = (TVisual?)point.Context.Visual;
if (visual is null)
{
return;
}
var p = primaryScale.ToPixels(pivot);
var secondary = secondaryScale.ToPixels(point.SecondaryValue);
visual.X = secondary;
visual.Y = p;
visual.Height = 0;
visual.RemoveOnCompleted = true;
if (dataProvider is null)
{
throw new Exception("Data provider not found");
}
dataProvider.DisposePoint(point);
var label = (TLabel?)point.Context.Label;
if (label is null)
{
return;
}
label.TextSize = 1;
label.RemoveOnCompleted = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="VideoStream"/> class.
/// </summary>
/// <param name="video">The video stream.</param>
/// <param name="options">The decoder settings.</param>
internal VideoStream(InputStream <VideoFrame> video, MediaOptions options)
{
stream = video;
mediaOptions = options;
frame = VideoFrame.CreateEmpty();
scaler = new Scaler();
}
public void IsFirstRun()
{
var s = new Scaler <object>();
var result = s.IsFirstRun(1);
Assert.IsTrue(result);
}
public void Resize(int i, int width)
{
var labels = _labelList[i];
labels.BackPanel.Width = width;
labels.Name.AdjustWidth(Scaler.DownWidth(width) - ListForm.PanelWidth);
}
/// <summary>
/// Set autoscale of input.
/// </summary>
/// <param name="input">Input signal to autoscale</param>
public void AutoScale(double input)
{
int newScaler = (int)scaler;
if (newScaler > 26)
{
newScaler = 26;
}
else if (newScaler < 0)
{
newScaler = 0;
}
if (input > 5.500001 && newScaler < 27)
{
newScaler++;
Send(newScaler);
}
else if (input < 0.0100001 && newScaler > 0)
{
newScaler--;
Send(newScaler);
}
if (newScaler > 26)
{
newScaler = 26;
}
else if (newScaler < 1)
{
newScaler = 1;
}
_scaler = (Scaler)newScaler;
}
public BodyPart(GameObject bodyPart, string sensor)
{
this.bodyPart = bodyPart;
targetRotation = bodyPart.transform.rotation;
this.sensor = sensor;
this.scaler = bodyPart.GetComponentInChildren <Scaler>();
}
public void ScaleUpFactoryNull()
{
var s = new Scaler<object>();
s.ScaleUp(null, new object(), Guid.NewGuid().ToString());
Assert.AreEqual(1, s.CurrentUnits);
}
/// <summary>
/// Performs a zoom operation on a bitmap and then scale the zoomed in bitmap to a specific size.
/// The zoom and scale operations are combined so that the pixels are only interpolated once.
/// </summary>
/// <param name="bmp">Source bitmap.</param>
/// <param name="zoomPercent">Percentage that the bitmap should be zoomed in by.</param>
/// <param name="interpolationMode">Intepolation method used when scaling combined zoom/scale operation.</param>
/// <param name="outSize">Size to scale the zoomed in bitmap to.</param>
/// <param name="dispose">Whether or not to dispose of the source bitmap.</param>
/// <returns>Zoomed in bitmap.</returns>
public static Bitmap ZoomAndScale(Bitmap bmp, float zoomPercent, Scaler.InterpolationMode interpolationMode, Size outSize, bool dispose)
{
if (zoomPercent < 0)
{
throw new Exception("Can't zoom a negative percent.");
}
if (outSize.Width <= 0 || outSize.Height <= 0)
{
throw new Exception("Scaled size is non-positive. Both the width and height of the scaled size must be positive.");
}
Bitmap outBmp;
Point centerPoint = new Point((int)(bmp.Width / 2f), (int)(bmp.Height / 2f));
float zoomFactor = 1 + (zoomPercent / 100f);
float inverseZoomFactor = 1 / zoomFactor;
int x = centerPoint.X - (int)((bmp.Width * inverseZoomFactor) / 2f);
int y = centerPoint.Y - (int)((bmp.Height * inverseZoomFactor) / 2f);
int width = (int)(bmp.Width * inverseZoomFactor);
int height = (int)(bmp.Height * inverseZoomFactor);
Rectangle rectangle = new Rectangle(x, y, width, height);
Bitmap croppedBmp = (Bitmap)bmp.Clone(rectangle, bmp.PixelFormat);
outBmp = Scaler.Scale(croppedBmp, outSize, interpolationMode);
croppedBmp.Dispose();
if (dispose)
{
bmp.Dispose();
}
return(outBmp);
}
public void ScaleUpServiceNameNull()
{
var factory = Substitute.For<ITaskFactory<object>>();
var s = new Scaler<object>();
s.ScaleUp(factory, new object(), null);
}
public void ShouldScale()
{
var s = new Scaler <object>();
var result = s.ShouldScale();
Assert.AreEqual(null, result);
}
void Awake()
{
if (instance == null)
{
instance = this;
}
}
private void SetRecord(int i)
{
var e = _data[i];
var labels = _labelList[i];
labels.Fleet.Text = e.Fleet;
labels.Fleet.Tag = "";
labels.Name.SetName(e.Ship);
if (e.Ship2 != "")
{
ToolTip.SetToolTip(labels.Name, e.Ship2);
}
labels.Equip.Text = e.Equip.ToString(Scaler.DownWidth(labels.BackPanel.Width) - ListForm.PanelWidth);
labels.EquipColor.Visible = e.Equip.ToString() != "";
labels.EquipColor.BackColor = e.Color;
labels.Spec.Text = e.Spec;
if (e.Fleet != "" && e.Fleet2 != "")
{
ToolTip.SetToolTip(labels.Fleet, e.Fleet2);
labels.Fleet.Tag = e.Fleet2;
}
ToolTip.SetToolTip(labels.Equip, e.AircraftSpec != "" ? e.AircraftSpec : "");
ToolTip.SetToolTip(labels.Spec, e.Spec2 != "" ? e.Spec2 : "");
labels.BackPanel.Visible = true;
}
void Awake()
{
prefabsManager = GameObject.FindGameObjectWithTag(Tags.PREFABS_MANAGER).GetComponent <PrefabsManager>();
observable = new FCObservable();
movers = new List <Mover> ();
scaler = GetComponent <Scaler> ();
scaler.AddListener(this, FCEvent.END);
}
private int CalcEnemyNameLeft(int hpWidth)
{
var nameSpace = _adjust / 2;
var hpAdjust = Scaler.ScaleWidth(12);
var wideHp = hpWidth > Scaler.ScaleWidth(47);
return(Scaler.ScaleWidth(EnemyNameLeft) + _adjust + (wideHp && nameSpace < hpAdjust ? hpAdjust : nameSpace));
}
public void ScaleUpServiceNameNull()
{
var factory = Substitute.For <ITaskFactory <object> >();
var s = new Scaler <object>();
Assert.That(() => s.ScaleUp(factory, new object(), null), Throws.TypeOf <ArgumentException>());
}
public void IsFirstRunMinimumZero()
{
var factory = Substitute.For <ITaskFactory <object> >();
var s = new Scaler <object>();
s.IsFirstRun(0);
}
public void InitializeMinimumZero()
{
var factory = Substitute.For <ITaskFactory <object> >();
var s = new Scaler <object>();
Assert.That(() => s.Initialize(0, factory, new object(), Guid.NewGuid().ToString()), Throws.TypeOf <ArgumentException>());
}
/// <summary>
/// Generates points trained points from learning.
/// </summary>
private async Task <double[][]> ComputeTrainedPoints(double[][] correctPoints)
{
return(await Task.Run(() =>
{
lock (_threadLocker)
{
try
{
_network = (ActivationNetwork)Network.Load(ConfigurationPath());
}
catch (Exception ex)
{
throw ex;
}
Scaler scaler = new Scaler(correctPoints);
var inputScaledData = correctPoints.Select(a => a.ToArray()).ToArray();
scaler.Scale(ref inputScaledData);
var solution = inputScaledData.Select(a => a.ToArray()).ToArray();
var networkInput = new double[2 * _inputPoints];
for (int j = _inputPoints; j < solution.GetLength(0); j++)
{
for (int k = _inputPoints, l = 0; k > 0; k--, l = l + 2)
{
networkInput[l] = solution[j - k][0];
networkInput[l + 1] = solution[j - k][1];
}
try
{
var result = _network.Compute(networkInput);
solution[j][0] = result[0];
solution[j][1] = result[1];
}
catch
{
solution[j][0] = double.NaN;
solution[j][1] = double.NaN;
}
}
for (int i = 0; i < solution.GetLength(0); i++)
{
if (double.IsNaN(solution[i][0]) || double.IsNaN(solution[i][1]))
{
continue;
}
solution[i][0] = scaler.Rescale(solution[i][0], XYEnum.X);
solution[i][1] = scaler.Rescale(solution[i][1], XYEnum.Y);
}
_network.Save(ConfigurationPath());
_network = null;
return solution;
}
}));
}
public void CopyFrameData(uint[] nextFrame)
{
for (int i = 0; i < nextFrame.Length; i++)
{
backBuffer[i] = nextFrame[i];
}
Scaler.ScaleImage(backBuffer, frontBuffer, baseWidth, baseHeight, baseScale);
Dispatcher.BeginInvoke(new BlitDelegate(Blit));
}
/// <summary>
/// This is called when the game should draw itself.
/// </summary>
/// <param name="gameTime">Provides a snapshot of timing values.</param>
protected override void Draw(GameTime gameTime)
{
if (IsActive)
{
Scaler.SetRenderTarget();
_screen.Draw(gameTime);
Scaler.Draw();
}
}
public void ScaleUp()
{
var factory = Substitute.For<ITaskFactory<object>>();
var s = new Scaler<object>();
s.ScaleUp(factory, new object(), Guid.NewGuid().ToString());
Assert.AreEqual(1, s.CurrentUnits);
}
/// <summary>
/// Initializes a new instance of the <see cref="VideoOutputStream"/> class.
/// </summary>
/// <param name="stream">The video stream.</param>
/// <param name="config">The stream setting.</param>
internal VideoOutputStream(OutputStream <VideoFrame> stream, VideoEncoderSettings config)
{
this.stream = stream;
Configuration = config;
scaler = new Scaler();
var(size, format) = GetStreamLayout(stream);
encodedFrame = VideoFrame.Create(size, format);
}
public void Scale_CheckRightCenterPoint()
{
var scaler = new Scaler(0, 100, TEST_MIN_SIZE);
scaler.Scale(1, true);
var actual = scaler.GetCurrentScaleInfo();
actual.CurrentStop.Should().Be(100);
}
void OnEnable()
{
_completeActionRaised = false;
Vector2 targetScale = _scaleToScreenSize.Simulate(false);
var data = new ScaleData(transform, targetScale, scaleSpeed);
_scaler = new ScalerFactory().Make(scaleType, data);
}
public void ScaleUp()
{
var factory = Substitute.For <ITaskFactory <object> >();
var s = new Scaler <object>();
s.ScaleUp(factory, new object(), Guid.NewGuid().ToString());
Assert.AreEqual(1, s.CurrentUnits);
}
public void InitializeMulitple()
{
var factory = Substitute.For <ITaskFactory <object> >();
var s = new Scaler <object>();
s.Initialize(5, factory, new object(), Guid.NewGuid().ToString());
Assert.AreEqual(5, s.CurrentUnits);
}
void OnEnable()
{
_currentIndex = -1;
_numToSpawn = (int)Random.Range(numToSpawnMinMax.x, numToSpawnMinMax.y);
_angleToAdd = 360 / _numToSpawn;
_scale.onScaleComplete += SpawnObject;
_scaleDown = null;
}
protected override void DrawCore(RenderDrawContext contextParameters)
{
var input = GetInput(0);
var output = GetOutput(0) ?? input;
if (input == null)
{
return;
}
// Downscale to 1/2
var halfSize = input.Size.Down2();
var halfSizeRenderTarget = NewScopedRenderTarget2D(halfSize.Width, halfSize.Height, input.Format);
Scaler.SetInput(input);
Scaler.SetOutput(halfSizeRenderTarget);
Scaler.Draw(contextParameters, "Downsize to 0.5");
// Work on a blurred bright map
var blurredBright = NewScopedRenderTarget2D(halfSizeRenderTarget.Description);
blur.Radius = 8;
blur.SetInput(halfSizeRenderTarget);
blur.SetOutput(blurredBright);
((RendererBase)blur).Draw(contextParameters);
// Draws a few artifacts
var flareRenderTargetInitial = NewScopedRenderTarget2D(halfSizeRenderTarget.Description);
var flareRenderTarget = NewScopedRenderTarget2D(halfSizeRenderTarget.Description);
flareArtifactEffect.Parameters.Set(FlareArtifactKeys.Count, ZoomOffsetsDistortions.Length);
flareArtifactEffect.Parameters.Set(FlareArtifactShaderKeys.ZoomOffsetsDistortions, ZoomOffsetsDistortions);
flareArtifactEffect.Parameters.Set(FlareArtifactShaderKeys.AberrationStrength, ColorAberrationStrength);
flareArtifactEffect.Parameters.Set(FlareArtifactShaderKeys.ColorAberrations, ColorAberrations);
flareArtifactEffect.Parameters.Set(FlareArtifactShaderKeys.Amount, Amount * 0.0005f);
flareArtifactEffect.SetInput(0, blurredBright);
flareArtifactEffect.SetOutput(flareRenderTargetInitial);
((RendererBase)flareArtifactEffect).Draw(contextParameters);
// Replicates the artifacts around
flareReplicateEffect.Parameters.Set(FlareReplicateKeys.Amount, Amount * 0.0005f);
flareReplicateEffect.Parameters.Set(FlareReplicateKeys.HaloFactor, Amount * 0.0005f * HaloFactor);
flareReplicateEffect.SetInput(0, flareRenderTargetInitial);
flareReplicateEffect.SetInput(1, blurredBright);
flareReplicateEffect.SetOutput(flareRenderTarget);
((RendererBase)flareReplicateEffect).Draw(contextParameters);
// Adds the result to the scene
Scaler.BlendState = BlendStates.Additive;
Scaler.SetInput(flareRenderTarget);
Scaler.SetOutput(output);
((RendererBase)Scaler).Draw(contextParameters);
Scaler.BlendState = BlendStates.Default;
}
public void DisposeMany()
{
var factory = Substitute.For<ITaskFactory<object>>();
using (var s = new Scaler<object>())
{
s.ScaleUp(factory, new object(), Guid.NewGuid().ToString());
s.ScaleUp(factory, new object(), Guid.NewGuid().ToString());
s.ScaleUp(factory, new object(), Guid.NewGuid().ToString());
}
}
public override void Run()
{
if (OutputDevice.InstalledDevices.Count == 0)
{
Console.WriteLine("Can't do anything with no output device.");
return;
}
float beatsPerMinute = 180;
Clock clock = new Clock(beatsPerMinute);
OutputDevice outputDevice = OutputDevice.InstalledDevices[0];
outputDevice.Open();
Drummer drummer = new Drummer(clock, outputDevice, 4);
InputDevice inputDevice = null;
if (InputDevice.InstalledDevices.Count > 0)
{
// Just pick the first input device. This will throw an exception if there isn't
// one.
inputDevice = InputDevice.InstalledDevices[0];
inputDevice.Open();
}
Scaler scaler = new Scaler(clock, inputDevice, outputDevice);
clock.Start();
if (inputDevice != null)
{
inputDevice.StartReceiving(clock);
}
bool done = false;
while (!done)
{
Console.Clear();
Console.WriteLine("BPM = {0}, Playing = {1}, Scale = {2}", clock.BeatsPerMinute,
clock.IsRunning, scaler.GetScaletoUse());
Console.WriteLine("Escape : Quit");
Console.WriteLine("Down : Slower");
Console.WriteLine("Up: Faster");
Console.WriteLine("Left: Previous Scale");
Console.WriteLine("Right: Next Scale");
Console.WriteLine("Space = Toggle Play");
ConsoleKey key = Console.ReadKey(true).Key;
Note note;
if (key == ConsoleKey.Escape)
{
done = true;
}
else if (key == ConsoleKey.DownArrow)
{
clock.BeatsPerMinute -= 2;
}
else if (key == ConsoleKey.UpArrow)
{
clock.BeatsPerMinute += 2;
}
else if (key == ConsoleKey.RightArrow)
{
scaler.NextScale();
}
else if (key == ConsoleKey.LeftArrow)
{
scaler.PreviousScale();
}
else if (key == ConsoleKey.Spacebar)
{
if (clock.IsRunning)
{
clock.Stop();
if (inputDevice != null)
{
inputDevice.StopReceiving();
}
outputDevice.SilenceAllNotes();
}
else
{
clock.Start();
if (inputDevice != null)
{
inputDevice.StartReceiving(clock);
}
}
}
else if (key == ConsoleKey.D1)
{
NoteOnMessage msg = new NoteOnMessage(outputDevice, Channel.Channel1, Note.C4,
80, clock.BeatTime);
NoteOffMessage msg2 = new NoteOffMessage(outputDevice, Channel.Channel1,
Note.C4, 80, clock.BeatTime+0.99f);
clock.Schedule(msg);
clock.Schedule(msg2);
scaler.NoteOn(msg);
}
else if (ExampleUtil.IsMockNote(key, out note))
{
NoteOnMessage noteOn = new NoteOnMessage(outputDevice, 0, note, 100,
clock.BeatTime);
NoteOffMessage noteOff = new NoteOffMessage(outputDevice, 0, note, 100,
clock.BeatTime + 1);
clock.Schedule(noteOn);
clock.Schedule(noteOff);
scaler.NoteOn(noteOn);
}
}
if (clock.IsRunning)
{
clock.Stop();
if (inputDevice != null)
{
inputDevice.StopReceiving();
}
outputDevice.SilenceAllNotes();
}
outputDevice.Close();
if (inputDevice != null)
{
inputDevice.Close();
}
}
public void InitializeMinimumZero()
{
var factory = Substitute.For<ITaskFactory<object>>();
var s = new Scaler<object>();
s.Initialize(0, factory, new object(), Guid.NewGuid().ToString());
}
public void ScaleDown()
{
var factory = Substitute.For<ITaskFactory<object>>();
var task = Substitute.For<IRoleTaskManager<object>>();
task.OnStop();
task.Dispose();
var s = new Scaler<object>();
s.ScaleUp(factory, new object(), Guid.NewGuid().ToString());
s.ScaleDown(Guid.NewGuid().ToString());
Assert.AreEqual(0, s.CurrentUnits);
task.Received().OnStop();
task.Received().Dispose();
}
public void IsFirstRunMinimumZero()
{
var factory = Substitute.For<ITaskFactory<object>>();
var s = new Scaler<object>();
s.IsFirstRun(0);
}
public void InitializeServiceNameNull()
{
var factory = Substitute.For<ITaskFactory<object>>();
var s = new Scaler<object>();
s.Initialize(1, factory, new object(), null);
}
public void ShouldScale()
{
var s = new Scaler<object>();
var result = s.ShouldScale();
Assert.AreEqual(null, result);
}
public void IsNotFirstRun()
{
var factory = Substitute.For<ITaskFactory<object>>();
var s = new Scaler<object>();
s.ScaleUp(factory, new object(), Guid.NewGuid().ToString());
var result = s.IsFirstRun(1);
Assert.IsFalse(result);
}
public void IsFirstRun()
{
var s = new Scaler<object>();
var result = s.IsFirstRun(1);
Assert.IsTrue(result);
}
public void ScaleDownServiceNameNull()
{
var s = new Scaler<object>();
s.ScaleDown(null);
}
public void InitializeFactoryNull()
{
var s = new Scaler<object>();
s.Initialize(1, null, new object(), Guid.NewGuid().ToString());
}
public void ShouldScaleDown()
{
var task = Substitute.For<IScalable>();
task.Scale.Returns(false);
var manager = Substitute.For<IRoleTaskManager<object>>();
manager.Tasks.Returns(new[] { task });
var stack = new ConcurrentStack<IRoleTaskManager<object>>();
stack.Push(manager);
var s = new Scaler<object>(stack);
var result = s.ShouldScale();
Assert.AreEqual(false, result);
}
public void InitializeMulitple()
{
var factory = Substitute.For<ITaskFactory<object>>();
var s = new Scaler<object>();
s.Initialize(5, factory, new object(), Guid.NewGuid().ToString());
Assert.AreEqual(5, s.CurrentUnits);
}
