////////////////
public override void Action(CommandCaller caller, string input, string[] args)
{
int brambleType = ModContent.TileType <CursedBrambleTile>();
Main.NewText("Begun map-wide bramble cleanup...", Color.Lime);
int count = 0;
int lastPercent = 0;
Parallel.For(0, Main.maxTilesX, (tileX) => {
//Parallel.For( 0, Main.maxTilesY, ( tileY ) => {
for (int tileY = 0; tileY < Main.maxTilesY; tileY++)
{
Tile tile = Main.tile[tileX, tileY];
if (tile == null || !tile.active() || tile.type != brambleType)
{
continue;
}
lock (BrambleGoneCommand.MyLock) {
TileHelpers.KillTile(tileX, tileY, false, false);
}
}
lock (BrambleGoneCommand.MyLock) {
count++;
int newPercent = ((100 * count) / Main.maxTilesX);
if (newPercent != lastPercent)
{
Main.NewText(newPercent + "% cleaned up");
lastPercent = newPercent;
}
}
});
}
////
public static float ComputeHitDamage(Tile tile, int baseDamage, int totalHits)
{
var config = DestructibleTilesConfig.Instance;
float dmg = (float)baseDamage / (float)totalHits;
float scale = 1f;
string tileName = TileID.GetUniqueKey(tile.type);
float armor = config.TileArmor.ContainsKey(tileName)
? (float)config.TileArmor[tileName].Amount : 0f;
if (armor >= dmg)
{
return(0);
}
if (config.SpecificTileDamageScales.ContainsKey(tileName))
{
scale = config.SpecificTileDamageScales[tileName].Amount;
}
if (config.UseVanillaTileDamageScalesUnlessOverridden)
{
bool isAbsolute;
scale *= TileHelpers.GetDamageScale(tile, dmg, out isAbsolute);
if (isAbsolute)
{
return(100f); // max
}
}
return((dmg - armor) * scale);
}
////////////////
public static bool IsValidTile(int tileX, int tileY)
{
if (!WorldGen.InWorld(tileX, tileY, 0))
{
return(false);
}
Tile tile = Framing.GetTileSafely(tileX, tileY);
if (TileHelpers.IsAir(tile))
{
return(false);
}
if (!tile.active())
{
return(false);
}
if (!Main.tileSolid[(int)tile.type])
{
return(false);
}
if (Main.tileSolidTop[(int)tile.type])
{
return(false);
}
return(true);
}
////////////////
private void AttemptShoot(CustomEntity ent, Player targetPlayer)
{
if (!this.IgnoresSolidCover)
{
bool isBlocked = false;
Utils.PlotTileLine(ent.Core.Center, targetPlayer.Center, 1f, (x, y) => {
if (TileHelpers.IsSolid(Main.tile[x, y]))
{
isBlocked = true;
return(false);
}
return(true);
});
if (isBlocked)
{
return;
}
}
if (this.Cooldown <= 0)
{
this.Cooldown = this.MaxCooldown;
this.Shoot(ent, targetPlayer);
}
}
public void TestGetNeighbors_DoesNotWrap_PositiveY()
{
// Arrange
int maxX = 3;
int maxY = 3;
Tile[,] tiles = new Tile[maxX, maxY];
for (int x = 0; x < maxX; x++)
{
for (int y = 0; y < maxY; y++)
{
var tile = new Tile
{
X = x,
Y = y
};
tiles[x, y] = tile;
}
}
// Act
List <Tile> neighbors = TileHelpers.GetSurrounding(tiles, maxX, maxY, tiles[1, 2]);
// Assert
Assert.AreEqual(8, neighbors.Count);
}
private void RandomizeVirtualTarget(DowsingMod mymod, Player player)
{
float max_tile_range = (float)Math.Max(mymod.Config.Data.MaxVirtualTargetRangeInTiles, 100);
Vector2 pos = Vector2.Zero;
int i = 0, tile_x, tile_y;
do
{
if (i++ >= 100)
{
break;
}
float rand_range_tiles = (Main.rand.NextFloat() * (max_tile_range - 100f)) + 99f;
float rand_range = 16f * rand_range_tiles;
Vector2 rand_heading = Vector2.UnitX.RotatedBy((double)Main.rand.NextFloat() * (Math.PI * 2d));
pos = player.Center + (rand_heading * rand_range);
tile_x = (int)pos.X / 16;
tile_y = (int)pos.Y / 16;
} while(!TileWorldHelpers.IsWithinMap(tile_x, tile_y) || TileHelpers.IsSolid(Framing.GetTileSafely(tile_x, tile_y)));
this.VirtualTargetPosition = TileWorldHelpers.DropToGround(pos);
this.ReAimVirtualTarget();
}
public static int SeesPlayer(NPC npc)
{
for (int i = 0; i < Main.player.Length; i++)
{
Player plr = Main.player[i];
if (plr == null || !plr.active)
{
continue;
}
if (!plr.dead)
{
var myplayer = Main.LocalPlayer.GetModPlayer <MonsterAlertnessPlayer>();
if (!myplayer.IsLit)
{
continue;
}
bool sees = Utils.PlotTileLine(npc.Center, Main.LocalPlayer.Center, 1f, (x, y) => {
return(!TileHelpers.IsTileSolid(Main.tile[x, y]));
});
if (sees)
{
return(i);
}
}
if (Main.netMode == 0)
{
break;
}
}
return(-1);
}
private void AttackPlayer(PlayerUnitController player)
{
PlayerVulnerability vulnerability = player.di.vulnerability;
Vector2 lookVector = new Vector2(physics.flip.Direction.ToFloat(), 1);
if (vulnerability.IsGuardingInOpposingDirection(physics.flip.Direction))
{
float recoilTileForce;
if (IsFullAssembly(player))
{
stateMachine.attack.StartStagger();
recoilTileForce = data.guardFullAssemblyRecoilTileForce;
// TODO: short stagger?
}
else
{
recoilTileForce = data.guardPartialAssemblyRecoilTileForce;
Vector2 playerRecoil = RecoilHelpers.GetRecoilFromTo(player.transform, controller.transform, recoilTileForce);
player.di.stateMachine.SetRecoilState(playerRecoil);
}
}
else if (vulnerability.IsVulnerable())
{
PlayerDamageModule damage = player.di.damage;
Vector2 collisionRecoil = RecoilHelpers.GetRecoilNormalFromTo(player.transform, controller.transform);
if (IsFullAssembly(player))
{
damage.TakeDamage(data.attackDamage, TileHelpers.TileToWorld(data.attackFullAssemblyRecoilTileForce) * collisionRecoil);
}
else
{
damage.TakeDamage(data.attackDamage, TileHelpers.TileToWorld(data.attackPartialAssemblyRecoilTileForce) * collisionRecoil);
}
}
}
public static Vector2?ScanForExitCandidate(Vector2 src, float rad, float range)
{
var dir = new Vector2(
(float)Math.Cos(rad),
-(float)Math.Sin(rad)
);
var dest = src + (dir * range * 16);
int x = (int)(dest.X / 16f);
int y = (int)(dest.Y / 16f);
for (int i = x; i < x + TrainTunnelTile.Width; i++)
{
for (int j = y; j < y + TrainTunnelTile.Height; j++)
{
Tile tile = Main.tile[i, j];
if (tile.wall == 0 || TileHelpers.IsSolid(tile) || tile.type != 0)
{
return(null);
}
}
}
return(dest);
}
private Vector2 GenerateRelictVelocity()
{
Vector2 normal = Vector2Helpers.DegreeToVector2(RandomHelpers.Range(relicAngle));
float velocity = TileHelpers.TileToWorld(RandomHelpers.Range(relicTileVelocity));
return(normal * velocity);
}
public void FindRandomTile(out int tile_x, out int tile_y)
{
do
{
tile_x = WorldGen.genRand.Next(0, Main.maxTilesX);
tile_y = WorldGen.genRand.Next(0, Main.maxTilesY);
} while(TileHelpers.IsAir(Framing.GetTileSafely(tile_x, tile_y)));
}
protected bool CastRareNpcDowse(Player player, Vector2 aiming_at, int tile_range)
{
var mymod = (DowsingMod)this.mod;
var modplayer = player.GetModPlayer <DowsingPlayer>();
bool dowsed = false;
var npc_poses = this.GetNpcPositions();
NPC npc = null;
var rare_npc_type_list = WitchingTargetData.GetCurrentRareNpcTypes();
if (rare_npc_type_list.Count == 0)
{
return(false);
}
var rare_npc_type_set = new HashSet <int>(rare_npc_type_list);
int traveled = 0;
this.CurrentBeamTravelDistance = 0;
this.CastDowseBeamWithinCone(player, aiming_at, new Utils.PerLinePoint(delegate(int tile_x, int tile_y) {
if (!TileWorldHelpers.IsWithinMap(tile_x, tile_y) || traveled >= tile_range)
{
return(false);
}
if (npc_poses.ContainsKey(tile_x) && npc_poses[tile_x].ContainsKey(tile_y))
{
npc = Main.npc[npc_poses[tile_x][tile_y]];
if (rare_npc_type_set.Contains(npc.type))
{
dowsed = true;
}
}
if (dowsed)
{
this.RenderRodHitFX(player, tile_x, tile_y);
}
else
{
traveled++;
if (TileHelpers.IsSolid(Framing.GetTileSafely(tile_x, tile_y), false, false))
{
traveled++;
}
}
this.CurrentBeamTravelDistance = traveled;
if ((mymod.DEBUGFLAGS & 1) != 0)
{
DebugHelpers.Print("current rare npcs", (this.III++) + " " + string.Join(",", rare_npc_type_set.ToArray()), 20);
//var dust = Dust.NewDustPerfect( new Vector2( tile_x * 16, tile_y * 16 ), 259, Vector2.Zero, 0, Color.Red, 0.75f );
//dust.noGravity = true;
}
return(!dowsed);
}));
return(dowsed);
}
public virtual void ColorTile(PaintedHillsMod mymod, int tile_x, int tile_y)
{
if (TileHelpers.IsAir(Framing.GetTileSafely(tile_x, tile_y)))
{
return;
}
this.HueMap.AddHue(tile_x, tile_y, this.Hue);
}
public static void EditorInit()
{
KiteSettings settings = GetOrCreateSettings();
Dir4Settings.OnEditorInit(settings);
DirXSettings.OnEditorInit(settings);
DirYSettings.OnEditorInit(settings);
TileHelpers.OnSettings(settings);
}
private void CheckForSpriteRotation()
{
if (rotationFrames > 0 && rotationFramesLeft == 0)
{
Vector2 deltaMoveCheckForRotation = TileHelpers.TileToWorld(edgeMoveTileSpeed) * rotation.GetFrontVector() * Time.deltaTime * 0.5f * rotationFrames;
if (raycaster.HasNoColliderBelow(deltaMoveCheckForRotation))
{
rotationFramesLeft = rotationFrames;
float t = 1 - (float)rotationFramesLeft / rotationFrames;
spriteRenderer.transform.localRotation = Quaternion.Lerp(noRotation, counterClockwise90Rotation, t);
}
}
}
public static bool?IsMirrorTileInvalid(int tileX, int tileY)
{
if (Main.netMode == 1)
{
if (!TileChunkHelpers.IsTileSyncedForCurrentClient(tileX, tileY))
{
if (TileHelpers.IsEqual(Main.tile[tileX, tileY], new Tile()))
{
return(null);
}
}
}
return(!MountedMagicMirrorsMod.Instance.MMMTilePattern.Check(tileX, tileY));
}
private void OnTriggerStay2D(Collider2D collision)
{
PlayerUnitController unit = InteractiveHelpers.GetPlayer(collision);
if (!unit)
{
return;
}
if (unit.di.vulnerability.IsVulnerable())
{
float randomSign = Random.Range(0, 2) == 1 ? 1 : -1;
Vector2 randomPushForce = TileHelpers.TileToWorld(new Vector2(randomSign * pushTileForce.x, pushTileForce.y));
unit.di.damage.TakeFullDamage(randomPushForce);
}
}
protected bool CastVirtualTargetDowse(Player player, Vector2 aiming_at, int tile_range)
{
var mymod = (DowsingMod)this.mod;
var modplayer = player.GetModPlayer <DowsingPlayer>();
bool dowsed = false;
int traveled = 0;
this.CurrentBeamTravelDistance = 0;
this.CastDowseBeamWithinCone(player, aiming_at, new Utils.PerLinePoint(delegate(int tile_x, int tile_y) {
if (!TileWorldHelpers.IsWithinMap(tile_x, tile_y) || traveled >= tile_range)
{
return(false);
}
Vector2 from = modplayer.WitchingData.VirtualTargetPosition;
float dist_x = (from.X / 16f) - (float)tile_x;
float dist_y = (from.Y / 16f) - (float)tile_y;
float dist = (float)Math.Sqrt(dist_x * dist_x + dist_y * dist_y);
dowsed = dist <= 8;
if (dowsed)
{
PsychokineticChargeDebuff.ApplyForTargetIfAnew(mymod, player);
this.VirtualTargetIsDowsed(player);
this.RenderRodHitFX(player, tile_x, tile_y);
}
else
{
traveled++;
if (TileHelpers.IsSolid(Framing.GetTileSafely(tile_x, tile_y), false, false))
{
traveled++;
}
}
this.CurrentBeamTravelDistance = traveled;
if ((mymod.DEBUGFLAGS & 1) != 0)
{
var dust = Dust.NewDustPerfect(new Vector2(tile_x * 16, tile_y * 16), 259, Vector2.Zero, 0, Color.Red, 0.75f);
dust.noGravity = true;
}
return(!dowsed);
}));
return(dowsed);
}
protected bool CastNpcTargetDowse(Player player, Vector2 aiming_at, int npc_who, int tile_range)
{
var mymod = (DowsingMod)this.mod;
var modplayer = player.GetModPlayer <DowsingPlayer>();
bool dowsed = false;
int traveled = 0;
this.CurrentBeamTravelDistance = 0;
this.CastDowseBeamWithinCone(player, aiming_at, new Utils.PerLinePoint(delegate(int tile_x, int tile_y) {
if (!TileWorldHelpers.IsWithinMap(tile_x, tile_y) || traveled >= tile_range)
{
return(false);
}
NPC npc = Main.npc[npc_who];
if (npc == null || !npc.active)
{
return(false);
}
dowsed = npc.getRect().Intersects(new Rectangle((tile_x - 1) * 16, (tile_y - 1) * 16, 32, 32));
if (dowsed)
{
PsychokineticChargeDebuff.ApplyForTargetIfAnew(mymod, player);
this.RenderRodHitFX(player, tile_x, tile_y);
}
else
{
traveled++;
if (TileHelpers.IsSolid(Framing.GetTileSafely(tile_x, tile_y)))
{
traveled++;
}
}
this.CurrentBeamTravelDistance = traveled;
if ((mymod.DEBUGFLAGS & 1) != 0)
{
var dust = Dust.NewDustPerfect(new Vector2(tile_x * 16, tile_y * 16), 259, Vector2.Zero, 0, Color.Red, 0.75f);
dust.noGravity = true;
}
return(!dowsed);
}));
return(dowsed);
}
public static bool RemoveBrambleAt(int tileX, int tileY)
{
Tile tile = Framing.GetTileSafely(tileX, tileY);
if (tile.active() && tile.type == ModContent.TileType <CursedBrambleTile>())
{
if (AmbushesMod.Config.DebugModeInfoBrambles)
{
Main.NewText("Removed bramble at " + tileX + ", " + tileY);
}
TileHelpers.KillTile(tileX, tileY, false, false);
return(true);
}
return(false);
}
public void TileOnMoveInto(PhysicsMove move)
{
// TODO: use PlayerCollider or move.movement.controller
PlayerUnitController unit = move.hit.rigidbody.GetComponent <PlayerUnitController>();
if (!unit)
{
return;
}
if (unit.di.vulnerability.IsVulnerable())
{
float randomSign = RandomHelpers.OneOrMinusOne();
Vector2 randomPushForce = TileHelpers.TileToWorld(new Vector2(randomSign * pushTileForce.x, pushTileForce.y));
unit.di.damage.TakeFullDamage(randomPushForce);
}
}
public void AddHue(int tile_x, int tile_y, Paints hue)
{
Tile tile = Framing.GetTileSafely(tile_x, tile_y);
if (TileHelpers.IsAir(tile))
{
return;
}
tile.color((byte)hue);
if (!this.ContainsKey(tile_x))
{
this.Add(tile_x, new Dictionary <int, Paints>());
}
this[tile_x][tile_y] = hue;
}
public bool ApplyDowseIfTileIsTarget(int tile_x, int tile_y, int tile_type)
{
Tile tile = Framing.GetTileSafely(tile_x, tile_y);
if (tile.type != tile_type || TileHelpers.IsAir(tile))
{
return(false);
}
if (!this.DowsedTiles.ContainsKey(tile_type))
{
this.DowsedTiles[tile_type] = new DowsedTiles();
}
this.DowsedTiles[tile_type].AddDowseAt(tile_x, tile_y);
return(true);
}
public static bool HitTile(int damage, int tileX, int tileY, int totalHits, float percent = 1f)
{
var mymod = DestructibleTilesMod.Instance;
var config = DestructibleTilesConfig.Instance;
Tile tile = Framing.GetTileSafely(tileX, tileY);
//HitTile plrTileHits = Main.LocalPlayer.hitTile;
//int tileHitId = plrTileHits.HitObject( tileX, tileY, 1 );
int dmg = (int)(DestructibleTilesProjectile.ComputeHitDamage(tile, damage, totalHits) * percent);
if (config.DebugModeInfo)
{
Main.NewText(HamstarHelpers.Helpers.Tiles.Attributes.TileAttributeHelpers.GetVanillaTileDisplayName(tile.type) + " hit for " + dmg.ToString("N2"));
}
if (mymod.TileDataMngr.AddDamage(tileX, tileY, dmg) >= 100) //
//if( plrTileHits.AddDamage( tileHitId, dmg, true ) >= 100 ) {
// plrTileHits.Clear( tileHitId );
{
bool isTileKilled = TileHelpers.KillTileSynced(
tileX: tileX,
tileY: tileY,
effectOnly: false,
dropsItem: config.DestroyedTilesDropItems,
forceSyncIfUnchanged: true,
suppressErrors: false
);
if (isTileKilled)
{
WorldGen.SquareTileFrame(tileX, tileY); // unnecessary?
ParticleFxHelpers.MakeDustCloud(
new Vector2((tileX * 16) + 8, (tileY * 16) + 8),
1,
0.3f,
1.2f
);
}
return(isTileKilled);
}
return(false);
}
////////////////
public static void HitTilesInRadius(int tileX, int tileY, int radius, int damage)
{
int radiusTiles = (int)Math.Round((double)(radius / 16));
int radiusTilesSquared = radiusTiles * radiusTiles;
int left = tileX - (radiusTiles + 1);
int right = tileX + (radiusTiles + 1);
int top = tileY - (radiusTiles + 1);
int bottom = tileY + (radiusTiles + 1);
for (int i = left; i < right; i++)
{
if (i < 0 || i >= Main.maxTilesX - 1)
{
continue;
}
for (int j = top; j < bottom; j++)
{
if (j < 0 || j >= Main.maxTilesY - 1)
{
continue;
}
if (TileHelpers.IsAir(Framing.GetTileSafely(i, j)))
{
continue;
}
int xOff = i - tileX;
int yOff = j - tileY;
int currTileDistSquared = (xOff * xOff) + (yOff * yOff);
if (currTileDistSquared > radiusTilesSquared)
{
continue;
}
float percentToCenter = 1f - ((float)currTileDistSquared / (float)radiusTilesSquared);
DestructibleTilesProjectile.HitTile(damage, i, j, 1, percentToCenter);
}
}
}
////////////////
protected bool CastBlockDowse(Player player, Vector2 aiming_at, int tile_range, int tile_type)
{
var mymod = (DowsingMod)this.mod;
var modplayer = player.GetModPlayer <DowsingPlayer>();
bool dowsed = false;
int traveled = 0;
this.CurrentBeamTravelDistance = 0;
this.CastDowseBeamWithinCone(player, aiming_at, new Utils.PerLinePoint(delegate(int tile_x, int tile_y) {
if (!TileWorldHelpers.IsWithinMap(tile_x, tile_y) || traveled >= tile_range)
{
return(false);
}
dowsed = modplayer.TileData.ApplyDowseIfTileIsTarget(tile_x, tile_y, tile_type);
if (dowsed)
{
PsychokineticChargeDebuff.ApplyForTilesIfAnew(mymod, player);
this.RenderRodHitFX(player, tile_x, tile_y);
}
else
{
traveled++;
if (TileHelpers.IsSolid(Framing.GetTileSafely(tile_x, tile_y), false, false))
{
traveled++;
}
}
this.CurrentBeamTravelDistance = traveled;
if ((mymod.DEBUGFLAGS & 1) != 0)
{
var dust = Dust.NewDustPerfect(new Vector2(tile_x * 16, tile_y * 16), 259, Vector2.Zero, 0, Color.Red, 0.75f);
dust.noGravity = true;
}
return(!dowsed);
}));
return(dowsed);
}
public void UpdateState()
{
selectUnit.WallSlideUpdate();
if (stateMachine.ChangedState)
{
return;
}
if (physics.IsGrounded)
{
stateMachine.SetControlState();
return;
}
float wallSlideYVelocity = TileHelpers.TileToWorld(wallSlideYTileVelocity);
if (physics.velocity.Y < -wallSlideYVelocity)
{
physics.velocity.Y = -wallSlideYVelocity;
}
wallSlide.WallSlideUpdate();
jump.WallSlideUpdate();
physics.WalSlideUpdate();
}
private void MoveForwardUpdate()
{
float forwardTileSpeed = rotationFramesLeft == 0 ? moveTileSpeed : edgeMoveTileSpeed;
Vector2 forwardDeltaMove = TileHelpers.TileToWorld(forwardTileSpeed) * rotation.GetFrontVector() * Time.deltaTime;
Vector2 moveAmount = movement.TryToMove(forwardDeltaMove);
if (raycaster.HasWallInFront())
{
ReverseSnail();
}
else if (raycaster.HasNoColliderBelow())
{
if (goAround)
{
RotateSnail90();
}
else
{
ReverseSnail();
}
}
}
public int TestVirtualTargetMovement(DowsingMod mymod, Player player, out Vector2 newpos)
{
int max_range = mymod.Config.Data.MaxWitchingRangeInTiles * 16;
int min_range = mymod.Config.Data.VirtualTargetApproachTriggerInTiles * 16;
newpos = this.VirtualTargetPosition + (this.VirtualTargetHeading * 2);
int dist = (int)Vector2.Distance(newpos, player.Center);
int tile_x = (int)newpos.X / 16;
int tile_y = (int)newpos.Y / 16;
if ((mymod.DEBUGFLAGS & 1) != 0)
{
DebugHelpers.Print("dist", min_range + "(" + (dist <= min_range) + ") <= " + dist + " >= " + max_range + "(" + (dist >= max_range) + ")", 20);
}
if (dist >= max_range) // Target out-of-range
{
return(-1);
}
if (dist <= min_range) // Target reached
{
return(1);
}
if (TileHelpers.IsSolid(Framing.GetTileSafely(tile_x, tile_y))) // Target collides with solid tile?
{
return(2);
}
if (!TileWorldHelpers.IsWithinMap(tile_x, tile_y)) // Target outside map?
{
return(3);
}
if (!TileFinderHelpers.HasNearbySolid(tile_x, tile_y, 10)) // Not near solids?
{
return(4);
}
return(0);
}
public override void ChooseDowsingTypeAtMouse(Player player)
{
var item_info = this.item.GetGlobalItem <RodItemInfo>();
Rectangle screen_frame = UIHelpers.GetWorldFrameOfScreen();
Vector2 screen_mouse = UIHelpers.ConvertToScreenPosition(new Vector2(Main.mouseX, Main.mouseY) + Main.screenPosition);
Vector2 world_mouse = screen_mouse + new Vector2(screen_frame.X, screen_frame.Y);
int tile_x = (int)(world_mouse.X / 16);
int tile_y = (int)(world_mouse.Y / 16);
Tile tile = Framing.GetTileSafely(tile_x, tile_y);
if (!TileHelpers.IsAir(tile))
{
if (TileIdentityHelpers.IsObject(tile.type))
{
string text = Lang.GetMapObjectName(Main.Map[tile_x, tile_y].Type);
text = TileIdentityHelpers.GetVanillaTileName(item_info.TargetTileType);
if (text == "")
{
Main.NewText("Vining Rod now attuned to some kind of material...", RodItem.AttunedColor);
}
else
{
Main.NewText("Vining Rod now attuned to any " + text, RodItem.AttunedColor);
}
item_info.TargetTileType = tile.type;
RodItem.RenderDowseEffect(new Vector2(tile_x * 16, tile_y * 16), 5, Color.GreenYellow);
}
else
{
Main.NewText("Vining Rod may only attune to objects.", Color.Yellow);
}
}
}
