private VisualizerData ChooseBordersWithEmpty(PointL position)
{
var currentBlock = gameWorld.GetItem(position);
if (currentBlock == null || currentBlock == Block.Either)
{
return(null);
}
var currentBTextures = currentBlock.BlockType.Textures.GetOrderedTextures();
var currentCore = currentBlock.BlockType.Core;
var result = new List <FaceData>();
for (var i = 0; i < TextureInfo.Order.Length; i++)
{
var element = TextureInfo.Order[i];
if (currentCore == BlockCore.Ore || currentCore == BlockCore.Transparent)
{
result.Add(new FaceData(currentBTextures[i], i, TextureInfo.Brightness[element]));
continue;
}
var offset = CollateShift(element);
var neighboringBlock = gameWorld.GetItem(position.Add(offset));
if (neighboringBlock == null || neighboringBlock == Block.Either ||
neighboringBlock.BlockType.Core == BlockCore.Transparent)
{
result.Add(new FaceData(currentBTextures[i], i, TextureInfo.Brightness[element]));
}
}
return(result.Count != 0 ? new VisualizerData(position, result) : null);
}
public DisplayConfigDesktopImageInfo(PointL pathSourceSize, RectangleL desktopImageRegion,
RectangleL desktopImageClip)
{
PathSourceSize = pathSourceSize;
DesktopImageRegion = desktopImageRegion;
DesktopImageClip = desktopImageClip;
}
public Piece(World <Chunk <Block>, Block> world, PointL center, int radius, IReadOnlyList <Mob> mobs)
{
Mobs = mobs;
this.world = world;
Center = center;
Radius = radius;
}
public DeviceMode(
string deviceName,
PointL position,
DisplayOrientation orientation,
DisplayFixedOutput fixedOutput,
uint bpp,
uint width,
uint height,
DisplayFlags displayFlags,
uint displayFrequency) : this(
deviceName,
DeviceModeFields.Position |
DeviceModeFields.DisplayOrientation |
DeviceModeFields.DisplayFixedOutput |
DeviceModeFields.BitsPerPixel |
DeviceModeFields.PelsWidth |
DeviceModeFields.PelsHeight |
DeviceModeFields.DisplayFlags |
DeviceModeFields.DisplayFrequency
)
{
Position = position;
DisplayOrientation = orientation;
DisplayFixedOutput = fixedOutput;
BitsPerPixel = bpp;
PixelsWidth = width;
PixelsHeight = height;
DisplayFlags = displayFlags;
DisplayFrequency = displayFrequency;
}
public override void ViewportChanged(IMapViewport viewport, ViewportChangeAction action)
{
if (this.Image == null)
{
base.ViewportChanged(viewport, action);
return;
}
long mapSize = MapTileSystemHelper.MapSize(viewport.ZoomLevel);
if ((action & ViewportChangeAction.Zoom) != 0)
{
this.pixelLocation = MapTileSystemHelper.LatLongToPixelXY(this.Location, viewport.ZoomLevel);
}
if ((action & ViewportChangeAction.Pan) != 0)
{
this.drawRect = new RectangleL(pixelLocation.X - this.Image.Size.Width / 2, pixelLocation.Y - this.Image.Size.Height, this.Image.Size.Width, this.Image.Size.Height);
}
RectangleL wraparoundDrawRect = this.drawRect;
for (int i = 0; i <= viewport.NumberOfWraparounds; i++)
{
if (wraparoundDrawRect.IntersectsWith(viewport.ViewportInPixels))
{
this.isImageInViewPort = true;
break;
}
wraparoundDrawRect.Offset(mapSize, 0L);
}
if (!this.IsInViewport)
{
return;
}
}
public DisplayConfigSourceMode(uint width, uint height, DisplayConfigPixelFormat pixelFormat, PointL position)
{
Width = width;
Height = height;
PixelFormat = pixelFormat;
Position = position;
}
public Block GetItem(PointL position)
{
if (!ContainsPosition(position))
{
return(Block.Either);
}
return(world.GetItem(position));
}
public override bool HitTest(PointG pointG, PointL pointL, IMapViewport viewport)
{
if (this.Image == null)
{
return(base.HitTest(pointG, pointL, viewport));
}
return(this.drawRect.Contains(pointL));
}
public override VisualizerData GetItem(PointL position)
{
var(cPosition, ePosition) = Translate2LocalNotation(position);
if (chunks.ContainsKey(cPosition) && Chunk <VisualizerData> .CheckBounds(ePosition))
{
return(chunks[cPosition][ePosition]);
}
return(null);
}
public override Block GetItem(PointL position)
{
var(cPosition, bPosition) = Translate2LocalNotation(position);
if (chunks.ContainsKey(cPosition) && Chunk <Block> .CheckBounds(bPosition))
{
return(chunks[cPosition][bPosition]);
}
return(Block.Either);
}
public (PointI cPosition, PointB elementPosition) Translate2LocalNotation(PointL point)
{
var elementX = (byte)(point.X % Chunk <TItem> .XLength);
var elementZ = (byte)(point.Z % Chunk <TItem> .ZLength);
var chunkX = (int)(point.X / Chunk <TItem> .XLength);
var chunkZ = (int)(point.Z / Chunk <TItem> .ZLength);
return(PointI.CreateXZ(chunkX, chunkZ), new PointB(elementX, (byte)point.Y, elementZ));
}
public override bool TrySetItem(PointL position, Block value)
{
var(cPosition, bPosition) = Translate2LocalNotation(position);
if (!chunks.ContainsKey(cPosition) || !Chunk <Block> .CheckBounds(bPosition))
{
return(false);
}
chunks[cPosition][bPosition] = value;
return(true);
}
internal void SetDx()
{
this.Delta = new PointL(Top.X - Bottom.X, Top.Y - Bottom.Y);
IsHorizontal = Delta.Y == 0;
Dx = IsHorizontal
? ClippingHelper.Horizontal
: (double)Delta.X / Delta.Y;
}
public override bool TrySetItem(PointL position, VisualizerData value)
{
var(cPosition, ePosition) = Translate2LocalNotation(position);
if (chunks.ContainsKey(cPosition) && Chunk <VisualizerData> .CheckBounds(ePosition))
{
chunks[cPosition][ePosition] = value;
return(true);
}
return(false);
}
internal void ReverseHorizontal()
{
// swap horizontal edges' top and bottom x's so they follow the natural
// progression of the bounds - ie so their xbots will align with the
// adjoining lower edge. [Helpful in the ProcessHorizontal() method.]
// GeometryHelper.Swap(ref Top.X, ref Bottom.X);
var tmp = this.Top.X;
this.Top = new PointL(this.Bottom.X, this.Top.Y);
this.Bottom = new PointL(tmp, this.Bottom.Y);
}
internal void InitializeGeometry()
{
if (Current.Y >= Next.Current.Y)
{
Bottom = Current;
Top = Next.Current;
}
else
{
Top = Current;
Bottom = Next.Current;
}
SetDx();
}
public DeviceMode(string deviceName, PointL position, uint bpp, uint width, uint height, uint displayFrequency)
: this(
deviceName,
DeviceModeFields.Position |
DeviceModeFields.BitsPerPixel |
DeviceModeFields.PelsWidth |
DeviceModeFields.PelsHeight |
DeviceModeFields.DisplayFrequency)
{
Position = position;
BitsPerPixel = bpp;
PixelsWidth = width;
PixelsHeight = height;
DisplayFrequency = displayFrequency;
}
public override void Follow(PointL target, Piece piece, float time, float distance)
{
if (Mover.Position.GetDistance(target.AsPointF()) <= distance)
{
return;
}
var targetView = target.AsVector() - Mover.Position.AsVector();
if (targetView.Equals(Vector3.Zero))
{
return;
}
targetView = Vector3.Normalize(targetView);
var currentView = mover.Front;
var coef = GetCoefficient(targetView, currentView, time);
var view = targetView * coef + currentView * (1 - coef);
if (view.Equals(Vector3.Zero))
{
return;
}
mover.SetView(view);
var pos = Mover.Position;
var directions = new List <Direction> {
Direction.Forward
};
if (isSlowed)
{
directions.Add(Direction.Up);
isSlowed = false;
}
if (view.X != 0 && view.Z != 0)
{
Mover.Move(piece, directions, time);
}
if (Mover.Position.GetSquaredDistance(pos) < mover.Speed * time / 2)
{
isSlowed = true;
}
}
public IEnumerable <(PointL position, Block block)> Helper()
{
/*for (var i = 1; i <= Radius; i++)
* {
* foreach (var p in Center.GetCubicNeighbourhood(i))
* {
* yield return (p, GetItem(p));
* }
* }*/
for (var i = -Radius; i <= Radius; i++)
{
for (var j = -Radius; j <= Radius; j++)
{
for (var k = -Radius; k <= Radius; k++)
{
var position = new PointL(i, j, k).Add(Center);
yield return(position, GetItem(position));
}
}
}
}
public abstract void Follow(PointL target, Piece piece, float time, float distance);
public abstract void GoTo(PointL target, Piece piece, float time);
public abstract TItem GetItem(PointL position);
public bool ContainsPosition(PointL position)
{
return(Center.GetDistance(position) <= Radius);
}
public abstract bool TrySetItem(PointL position, TItem value);
public bool Contains(PointL pt)
{
return(pt.x >= Left && pt.x <= Right && pt.y >= Top && pt.y <= Bottom);
}
internal static extern IntPtr MonitorFromPoint(
[In] PointL point,
MonitorFromFlag flag
);
public static Geometry GetGeometry(BlockType blockType, PointL position)
{
return(Geometry.Identity(blockType.Form.Shift(position.AsVector())));
}
public VisualizerData(PointL position, List <FaceData> faces)
{
this.Position = position;
Faces = faces;
}
public void PutBlock(BlockType blockType, PointL position)
{
var(cPosition, ePosition) = world.Translate2LocalNotation(position);
world[cPosition][ePosition] = blockType == null ? null : new Block(blockType, ePosition);
OnUpdateAlert(position);
}
private void OnUpdateAlert(PointL position)
{
UpdateAlert?.Invoke(position);
}
