protected override void ClientSetupExplosionBlueprint(Tile tile, IClientBlueprint blueprint)
{
ProcessExplosionDirection(-1, 0); // left
ProcessExplosionDirection(0, 1); // top
ProcessExplosionDirection(1, 0); // right
ProcessExplosionDirection(0, -1); // bottom
void ProcessExplosionDirection(int xOffset, int yOffset)
{
foreach (var(_, offsetIndex) in
WeaponExplosionSystem.SharedEnumerateExplosionBombermanDirectionTilesWithTargets(
positionEpicenter: tile.Position.ToVector2D(),
damageDistanceFullDamage: DamageRadiusFullDamage,
damageDistanceMax: DamageRadiusMax,
Api.Client.World,
xOffset,
yOffset))
{
var rectangle = new Rectangle()
{
Width = 1 * ScriptingConstants.TileSizeVirtualPixels - 10,
Height = 1 * ScriptingConstants.TileSizeVirtualPixels - 10,
StrokeThickness = 4
};
if (offsetIndex <= DamageRadiusFullDamage)
{
rectangle.Stroke = ExplosionBlueprintBorderBrushRed.Value;
rectangle.Fill = ExplosionBlueprintFillBrushRed.Value;
}
else
{
switch (offsetIndex)
{
case 5:
case 6:
case 7:
rectangle.Stroke = ExplosionBlueprintBorderBrushYellow.Value;
rectangle.Fill = ExplosionBlueprintFillBrushYellow.Value;
break;
default:
throw new Exception("Should be impossible");
}
}
// workaround for NoesisGUI
rectangle.SetValue(Shape.StrokeDashArrayProperty, "2,1");
Api.Client.UI.AttachControl(
blueprint.SceneObject,
positionOffset: this.Layout.Center
+ (offsetIndex * xOffset,
offsetIndex * yOffset),
uiElement: rectangle,
isFocusable: false,
isScaleWithCameraZoom: true);
}
}
}
public override void ClientSetupBlueprint(Tile tile, IClientBlueprint blueprint)
{
base.ClientSetupBlueprint(tile, blueprint);
if (!ConstructionPlacementSystem.IsInObjectPlacementMode &&
!ConstructionRelocationSystem.IsInObjectPlacementMode)
{
return;
}
var bounds = this.Layout.Bounds;
var sizeX = bounds.MaxX - bounds.MinX + 2 * this.WateringDistance;
var sizeY = bounds.MaxY - bounds.MinY + 2 * this.WateringDistance;
Api.Client.UI.AttachControl(
blueprint.SceneObject,
positionOffset: this.Layout.Center,
uiElement: new Rectangle()
{
Width = sizeX * ScriptingConstants.TileSizeVirtualPixels,
Height = sizeY * ScriptingConstants.TileSizeVirtualPixels,
Fill = BlueprintFillBrush.Value,
Stroke = BlueprintBorderBrush.Value,
StrokeThickness = 4,
},
isFocusable: false,
isScaleWithCameraZoom: true);
}
public override void ClientSetupBlueprint(Tile tile, IClientBlueprint blueprint)
{
base.ClientSetupBlueprint(tile, blueprint);
if (!ConstructionPlacementSystem.IsObjectPlacementComponentEnabled)
{
return;
}
// display area only when player placing a blueprint
var areaSprite = Api.Client.Rendering.CreateSpriteRenderer(
blueprint.SceneObject,
null,
DrawOrder.Overlay);
ClientBlueprintAreaRenderingMaterial.EffectParameters.Set(
"Color",
blueprint.IsCanBuild
? ColorGreen
: ColorRed);
areaSprite.RenderingMaterial = ClientBlueprintAreaRenderingMaterial;
areaSprite.SortByWorldPosition = false;
areaSprite.IgnoreTextureQualityScaling = true;
areaSprite.Scale = this.LandClaimSize;
var offset = LandClaimSystem.SharedCalculateLandClaimObjectCenterTilePosition(Vector2Ushort.Zero, this);
areaSprite.PositionOffset = (offset.X - this.LandClaimSize / 2,
offset.Y - this.LandClaimSize / 2);
}
public override void ClientSetupBlueprint(Tile tile, IClientBlueprint blueprint)
{
base.ClientSetupBlueprint(tile, blueprint);
if (ConstructionPlacementSystem.IsInObjectPlacementMode)
{
ProtoObjectLandClaimPlacementDisplayHelper.SetupBlueprint(tile, blueprint, this);
}
}
public override void ClientSetupBlueprint(Tile tile, IClientBlueprint blueprint)
{
base.ClientSetupBlueprint(tile, blueprint);
var rendererBase = Client.Rendering.CreateSpriteRenderer(blueprint.SceneObject,
null);
rendererBase.RenderingMaterial = blueprint.SpriteRenderer.RenderingMaterial;
this.ClientSetupRendererBase(rendererBase);
}
public override void ClientSetupBlueprint(Tile tile, IClientBlueprint blueprint)
{
var renderer = blueprint.SpriteRenderer;
var isHorizontalDoor = DoorHelper.IsHorizontalDoorNeeded(tile, checkExistingDoor: true);
renderer.PositionOffset = (0,
isHorizontalDoor
? DrawWorldOffsetYHorizontalDoor
: DrawWorldOffsetYVerticalDoor);
renderer.TextureResource = isHorizontalDoor
? this.lazyHorizontalDoorBlueprintTexture.Value
: this.lazyVerticalDoorBlueprintTexture.Value;
}
public override void ClientSetupBlueprint(Tile tile, IClientBlueprint blueprint)
{
var renderer = blueprint.SpriteRenderer;
renderer.TextureResource = this.DefaultTexture;
// setup drawing of the top left chunk of the texture
renderer.CustomTextureSourceRectangle =
new RectangleInt(0, 0, ScriptingConstants.TileSizeRealPixels, ScriptingConstants.TileSizeRealPixels);
// change draw world position and origin to draw the top left chunk of the texture
renderer.PositionOffset = (0, 1);
renderer.SpritePivotPoint = (0, 1);
this.ClientSetupRenderer(renderer);
}
protected virtual void ClientSetupExplosionBlueprint(Tile tile, IClientBlueprint blueprint)
{
var bounds = this.Layout.Bounds;
var sizeX = bounds.MaxX - bounds.MinX + 2 * this.DamageRadius - 1;
var sizeY = bounds.MaxY - bounds.MinY + 2 * this.DamageRadius - 1;
var ellipse = new Ellipse()
{
Width = sizeX * ScriptingConstants.TileSizeVirtualPixels,
Height = sizeY * ScriptingConstants.TileSizeVirtualPixels,
Fill = ExplosionBlueprintFillBrush.Value,
Stroke = ExplosionBlueprintBorderBrush.Value,
StrokeThickness = 4
};
// workaround for NoesisGUI
ellipse.SetValue(Shape.StrokeDashArrayProperty, "5,2.5");
Api.Client.UI.AttachControl(
blueprint.SceneObject,
positionOffset: this.Layout.Center,
uiElement: ellipse,
isFocusable: false,
isScaleWithCameraZoom: true);
}
public void ClientSetupBlueprint(Tile tile, IClientBlueprint blueprint)
{
blueprint.SpriteRenderer.TextureResource = TextureResource.NoTexture;
}
public override void ClientSetupBlueprint(
Tile tile,
IClientBlueprint blueprint)
{
ProtoObjectWallHelper.ClientSetupBlueprint(this, tile, blueprint);
}
public override void ClientSetupBlueprint(Tile tile, IClientBlueprint blueprint)
{
base.ClientSetupBlueprint(tile, blueprint);
ClientAddPlantRenderingOffsetFromFarm(tile, blueprint.SpriteRenderer);
}
public override void ClientSetupBlueprint(
Tile tile,
IClientBlueprint blueprint)
{
blueprint.SpriteRenderer.TextureResource = this.Icon;
}
public static void ClientSetupBlueprint(IProtoObjectWall protoWall, Tile tile, IClientBlueprint blueprint)
{
var textureAtlas = ClientGetTextureAtlas(protoWall);
var result = SharedGetAtlasTextureChunkPosition(tile,
protoWall,
isConsiderDestroyed: false,
isConsiderConstructionSites: true);
blueprint.SpriteRenderer.TextureResource = textureAtlas.Chunk((byte)result.Primary.AtlasChunkPosition.X,
(byte)result.Primary.AtlasChunkPosition.Y);
result.Dispose();
}
public override void ClientSetupBlueprint(Tile tile, IClientBlueprint blueprint)
{
base.ClientSetupBlueprint(tile, blueprint);
blueprint.SpriteRenderer.TextureResource = this.cachedTextureBlueprintAndIconResource;
}
public override void ClientSetupBlueprint(Tile tile, IClientBlueprint blueprint)
{
blueprint.SpriteRenderer.TextureResource = this.ClientGetTextureForTile(tile);
}
public override void ClientSetupBlueprint(Tile tile, IClientBlueprint blueprint)
{
base.ClientSetupBlueprint(tile, blueprint);
if (!ConstructionPlacementSystem.IsObjectPlacementComponentEnabled)
{
return;
}
// display area only when player placing a blueprint
Color color;
var sizeWithGraceArea = this.LandClaimWithGraceAreaSize;
if (blueprint.IsCanBuild)
{
color = BlueprintAreaColorGreen;
ClientBlueprintAreaRenderingMaterial.EffectParameters.Set("Color", color);
CreateBlueprintAreaRenderer(ClientBlueprintAreaRenderingMaterial, this.LandClaimSize);
CreateBlueprintAreaRenderer(ClientBlueprintGraceAreaRenderingMaterial, sizeWithGraceArea);
// can build a land claim area, but highlight the restricted tiles
var world = Client.World;
var startTilePosition = tile.Position;
var halfSize = sizeWithGraceArea / 2;
for (var x = 1 - halfSize; x <= halfSize; x++)
{
for (var y = 1 - halfSize; y <= halfSize; y++)
{
var checkTile = world.GetTile(startTilePosition.X + x,
startTilePosition.Y + y,
logOutOfBounds: false);
ProcessFutureLandClaimAreaTile(checkTile, x, y);
}
}
}
else // cannot build a land claim there
{
color = BlueprintAreaColorRed;
ClientBlueprintAreaRenderingMaterial.EffectParameters.Set("Color", color);
CreateBlueprintAreaRenderer(ClientBlueprintAreaRenderingMaterial,
size: sizeWithGraceArea);
}
void CreateBlueprintAreaRenderer(RenderingMaterial renderingMaterial, int size)
{
var offset = LandClaimSystem.SharedCalculateLandClaimObjectCenterTilePosition(Vector2Ushort.Zero, this);
var areaBlueprint = Api.Client.Rendering.CreateSpriteRenderer(
blueprint.SceneObject,
null,
DrawOrder.Overlay);
areaBlueprint.RenderingMaterial = renderingMaterial;
areaBlueprint.SortByWorldPosition = false;
areaBlueprint.IgnoreTextureQualityScaling = true;
areaBlueprint.Scale = size;
areaBlueprint.PositionOffset = (offset.X - size / 2,
offset.Y - size / 2);
}
void ProcessFutureLandClaimAreaTile(Tile checkTile, int offsetX, int offsetY)
{
if (!checkTile.IsValidTile)
{
return;
}
var isRestrictedTile = IsRestrictedTile(checkTile);
if (!isRestrictedTile)
{
foreach (var neighborTile in checkTile.EightNeighborTiles)
{
if (IsRestrictedTile(neighborTile))
{
isRestrictedTile = true;
break;
}
}
}
if (!isRestrictedTile)
{
return;
}
// display red tile as player cannot construct there
var tileRenderer = Api.Client.Rendering.CreateSpriteRenderer(
blueprint.SceneObject,
ClientLandClaimGroupRenderer.TextureResourceLandClaimAreaCell,
DrawOrder.Overlay);
tileRenderer.RenderingMaterial = ClientBlueprintRestrictedTileRenderingMaterial;
tileRenderer.SortByWorldPosition = false;
tileRenderer.IgnoreTextureQualityScaling = true;
tileRenderer.Scale = 1;
tileRenderer.PositionOffset = (offsetX, offsetY);
}
bool IsRestrictedTile(Tile t)
=> t.IsCliffOrSlope ||
t.ProtoTile.Kind != TileKind.Solid ||
t.ProtoTile.IsRestrictingConstruction;
}
public static void SetupBlueprint(
Tile tile,
IClientBlueprint blueprint,
IProtoObjectLandClaim protoObjectLandClaim)
{
if (!blueprint.IsEnabled)
{
return;
}
var sceneObject = blueprint.SceneObject;
var world = Api.Client.World;
var rendering = Api.Client.Rendering;
var character = ClientCurrentCharacterHelper.Character;
var startTilePosition = LandClaimSystem.SharedCalculateLandClaimObjectCenterTilePosition(
tile.Position,
protoObjectLandClaim);
var sizeWithGraceArea = protoObjectLandClaim.LandClaimWithGraceAreaSize;
var blueprintAreaBounds = LandClaimSystem.SharedCalculateLandClaimAreaBounds(startTilePosition,
sizeWithGraceArea);
SetupBoundsForLandClaimsInScope(sceneObject,
sceneObjectPosition: tile.Position.ToVector2D(),
startTilePosition,
blueprintAreaBounds,
protoObjectLandClaim);
using var tempListExceptBounds = Api.Shared.GetTempList <RectangleInt>();
CollectLabelExclusionBoundsForBlueprint(blueprintAreaBounds, tempListExceptBounds.AsList());
ClientLandClaimAreaManager.AddBlueprintRenderer(startTilePosition,
protoObjectLandClaim);
// additionally highlight the restricted tiles
var halfSize = sizeWithGraceArea / 2;
for (var x = 1 - halfSize; x <= halfSize; x++)
{
for (var y = 1 - halfSize; y <= halfSize; y++)
{
var checkTile = world.GetTile(startTilePosition.X + x,
startTilePosition.Y + y,
logOutOfBounds: false);
ProcessFutureLandClaimAreaTile(checkTile, x, y);
}
}
AddBoundSquares(sceneObject,
protoObjectLandClaim,
positionOffset: (0, 0));
AddBoundLabels(sceneObject,
sceneObjectPosition: tile.Position.ToVector2D(),
exceptBounds: tempListExceptBounds.AsList(),
protoObjectLandClaim,
positionOffset: (0, 0));
void ProcessFutureLandClaimAreaTile(Tile checkTile, int offsetX, int offsetY)
{
if (!checkTile.IsValidTile)
{
return;
}
var isRestrictedTile = IsRestrictedTile(checkTile);
if (!isRestrictedTile)
{
foreach (var neighborTile in checkTile.EightNeighborTiles)
{
if (IsRestrictedTile(neighborTile))
{
isRestrictedTile = true;
break;
}
}
}
if (!isRestrictedTile)
{
return;
}
// display red tile as player cannot construct there
var tileRenderer = rendering.CreateSpriteRenderer(
sceneObject,
ClientLandClaimGroupRenderer.TextureResourceLandClaimAreaCell,
DrawOrder.Overlay);
tileRenderer.RenderingMaterial = ClientBlueprintRestrictedTileRenderingMaterial;
tileRenderer.SortByWorldPosition = false;
tileRenderer.Scale = 1;
tileRenderer.PositionOffset = (offsetX + 1, offsetY + 1);
}
bool IsRestrictedTile(Tile t)
=> t.IsCliffOrSlope ||
t.ProtoTile.Kind != TileKind.Solid ||
t.ProtoTile.IsRestrictingConstruction ||
!LandClaimSystem.SharedIsPositionInsideOwnedOrFreeArea(
t.Position,
character,
addGracePaddingWithoutBuffer: true);
}
/// <summary>
/// Gets the texture used for construction place selection (blueprint). Usually the same texture is used for the object
/// rendering as well.
/// </summary>
/// <param name="tile">World tile.</param>
public virtual void ClientSetupBlueprint(Tile tile, IClientBlueprint blueprint)
{
blueprint.SpriteRenderer.TextureResource = this.DefaultTexture;
this.ClientSetupRenderer(blueprint.SpriteRenderer);
}
public sealed override void ClientSetupBlueprint(Tile tile, IClientBlueprint blueprint)
{
base.ClientSetupBlueprint(tile, blueprint);
this.ClientSetupExplosionBlueprint(tile, blueprint);
}
