public void Update(AbstractHumanoid currentPlayer, RayTracer rayTracer, AbstractMap map, Surface surface)
{
int columnXLeftMargin = 0;
for (int columnId = 0; columnId < columnCount; columnId++)
{
double straightDistance = Optics.GetStraightDistance(currentPlayer, rayTracer[columnId]);
double columnHeight = Optics.GetColumnHeight(straightDistance, screenHeight, heightDistanceRatio);
double topMargin = Optics.GetColumnTopMargin(screenHeight, columnHeight, currentPlayer.PositionZ, currentPlayer.IsCrouch, currentPlayer.MouseLook);
Rectangle rectangle = rectangleCache[columnId];
rectangle.X = columnXLeftMargin;
rectangle.Y = (int)topMargin;
rectangle.Height = (int)columnHeight;
columnXLeftMargin += columnWidthPixel;
double brightness = Optics.GetBrightness(Math.Min(screenHeight, columnHeight), screenHeight);
double red, green, blue;
map.GetColors(rayTracer[columnId].X, rayTracer[columnId].Y, brightness, out red, out green, out blue);
if (echolocationCycle.IsHighlightedColumn(columnId))
{
red = Math.Max(0, Math.Min(255, 256 - red));
green = Math.Max(0, Math.Min(255, 256 - green));
blue = Math.Max(0, Math.Min(255, 256 - blue));
this.echolocationBeeper.Beep(straightDistance, columnId, columnCount);
}
surface.Fill(rectangle, Color.FromArgb(255, (byte)(red), (byte)(green), (byte)(blue)));
}
}
public void SortByDistance(AbstractSprite referenceSprite)
{
foreach (AbstractSprite sprite in internalList)
{
sprite.DistanceToReferenceSprite = Optics.GetStraightDistance(referenceSprite, sprite);
}
internalList.Sort();
}
public bool IsSpriteViewable(AbstractHumanoid viewerSprite, AbstractHumanoid viewedSprite, AbstractMap map, int fov)
{
Dictionary <AbstractHumanoid, bool> viewedList;
if (!internalList.TryGetValue(viewerSprite, out viewedList))
{
viewedList = new Dictionary <AbstractHumanoid, bool>();
internalList.Add(viewerSprite, viewedList);
}
bool isViewed;
if (!viewedList.TryGetValue(viewedSprite, out isViewed))
{
isViewed = Optics.IsSpriteViewable(viewerSprite, viewedSprite, map, fov);
viewedList.Add(viewedSprite, isViewed);
}
return(isViewed);
}
/// <summary>
/// Whether sprite 1 can attack or block sprite 2 because angle allows it
/// </summary>
/// <param name="sprite1">sprite 1</param>
/// <param name="sprite2">sprite 2</param>
/// <returns>Whether sprite 1 can attack or block sprite 2 because angle allows it</returns>
public static bool IsInAttackOrBlockAngle(AbstractHumanoid sprite1, AbstractHumanoid sprite2)
{
double angleToSprite = Optics.GetSpriteAngleToSpriteRadian(sprite1, sprite2);
double attackAngleRange = sprite1.AttackAngleRange;
if (Math.Abs(angleToSprite - sprite1.AngleRadian) < attackAngleRange)
{
return(true);
}
else if (Math.Abs(angleToSprite - sprite1.AngleRadian + Math.PI * 2.0) < attackAngleRange)
{
return(true);
}
else if (Math.Abs(angleToSprite - sprite1.AngleRadian + Math.PI * 2.0) < attackAngleRange)
{
return(true);
}
return(false);
}
public List <RayTracerPoint> Trace(AbstractHumanoid viewerSprite, AbstractMap map)
{
double startAngle = viewerSprite.AngleDegree - fov / 2;
double endAngle = viewerSprite.AngleDegree + fov / 2;
double angleResolution = (double)fov / (double)columnCount;
startAngle = Optics.FixAngleDegree(startAngle);
endAngle = Optics.FixAngleDegree(endAngle);
int pointCounter = 0;
for (double angle = startAngle; pointCounter < columnCount; angle += angleResolution)
{
angle = Optics.FixAngleDegree(angle);
pointList[pointCounter].Trace(viewerSprite, angle, rayDistanceResolution, map);
pointCounter++;
}
return(pointList);
}
public void Animate(AbstractHumanoid predator, AbstractMap map, SpritePool spritePool, SharedConsciousness sharedConsciousness, double timeDelta, int fov, Random random, AbstractHumanoid currentPlayer)
{
AbstractHumanoid prey;
if (random.Next(howManyFrameBeforeChoosingPreyAgain) == 0)
{
prey = TryChoosePrey(predator, spritePool, sharedConsciousness, map, fov, currentPlayer);
predator.LatestSelectedPrey = prey;
}
else
{
prey = predator.LatestSelectedPrey;
}
predator.IsNeedToJumpAgain = false;
predator.IsBlock = false;
byte currentStateJumpCrouch = predator.StateJumpCrouch.GetCurrentState();
//We manage jumping state
if (currentStateJumpCrouch == SpriteStates.Jump)
{
predator.IsCrouch = false;
Physics.MakeJump(predator, timeDelta);
}
//We manage crouch state
if (currentStateJumpCrouch == SpriteStates.Crouch)
{
predator.IsCrouch = true;
}
//We manage standing state
if (currentStateJumpCrouch == SpriteStates.Stand)
{
predator.IsCrouch = false;
predator.IsNeedToJumpAgain = false;
}
//We manage walking
if (prey != null)
{
if (random.Next(5) == 0 && !predator.SpinAttackCycle.IsFired)
{
predator.AngleRadian = Optics.GetSpriteAngleToSpriteRadian(predator, prey);
}
byte currentAttackBlockState = predator.StateAttackBlock.GetCurrentState();
byte currentAttackTypeState = predator.StateAttackType.GetCurrentState();
byte currentMovementState = predator.StateMovement.GetCurrentState();
if (currentAttackBlockState == SpriteStates.SpinCharge)
{
predator.StateAttackType.Reset();
}
if (predator.SpinChargeAttackCycle.IsFired)
{
currentAttackBlockState = SpriteStates.SpinCharge;
}
if (currentMovementState == SpriteStates.Offensive)
{
Physics.TryMakeWalk(predator, spritePool, map, timeDelta);
}
else if (currentMovementState == SpriteStates.Defensive)
{
Physics.TryMakeWalk(predator, Math.PI, spritePool, map, timeDelta);
}
else if (currentMovementState == SpriteStates.FurtiveLeft)
{
Physics.TryMakeWalk(predator, Math.PI * 1.5, spritePool, map, timeDelta);
}
else if (currentMovementState == SpriteStates.FurtiveRight)
{
Physics.TryMakeWalk(predator, Math.PI * 0.5, spritePool, map, timeDelta);
}
//We manage attacking, and blocking
bool isWithinAttackRange = BattlePhysics.IsWithinAttackRange(predator, prey);
bool isWithinAttackOrBlockAngle = BattlePhysics.IsInAttackOrBlockAngle(predator, prey);
if (currentAttackBlockState == SpriteStates.Block && predator.PositionZ > 0)
{
currentAttackBlockState = SpriteStates.Attack;
}
if (isWithinAttackRange || isWithinAttackOrBlockAngle)
{
if (predator.ReceivedAttackCycle.IsAtBegining)
{
if (currentAttackBlockState == SpriteStates.Attack)
{
if (currentAttackTypeState == SpriteStates.FastAttack)
{
if (random.Next(2) == 1)
{
if (BattlePhysics.IsWithinAttackRange(predator, prey, 1.5) && isWithinAttackOrBlockAngle)
{
predator.FastAttackCycle.UnFire();
predator.FastAttackCycle.Fire();
}
}
}
else if (currentAttackTypeState == SpriteStates.StrongAttack)
{
if (random.Next(2) == 1)
{
if (BattlePhysics.IsWithinAttackRange(predator, prey, 1.5) && isWithinAttackOrBlockAngle)
{
predator.StrongAttackCycle.UnFire();
predator.StrongAttackCycle.Fire();
}
}
}
predator.SpinChargeAttackCycle.Reset();
}
else if (currentAttackBlockState == SpriteStates.SpinCharge)
{
if (IsReadyToSpin(predator) && BattlePhysics.IsWithinAttackRange(predator, prey, 1.5))
{
if (random.Next(3) == 1)
{
predator.SpinAttackCycle.Reset();
predator.SpinAttackCycle.Fire();
predator.SpinChargeAttackCycle.Reset();
predator.StateAttackBlock.Reset();
}
}
else if (!predator.SpinAttackCycle.IsFired)
{
if (predator.SpinChargeAttackCycle.IsFired)
{
predator.SpinChargeAttackCycle.Update(timeDelta);
}
else
{
predator.SpinChargeAttackCycle.Fire();
}
}
}
else if (currentAttackBlockState == SpriteStates.Block && !predator.SpinAttackCycle.IsFired)
{
predator.StrongAttackCycle.UnFire();
predator.SpinAttackCycle.UnFire();
predator.SpinChargeAttackCycle.Reset();
predator.FastAttackCycle.UnFire();
predator.IsBlock = true;
}
else
{
predator.SpinChargeAttackCycle.Reset();
}
}
}
predator.StateAttackBlock.Update(timeDelta, random);
predator.StateAttackType.Update(timeDelta, random);
predator.StateMovement.Update(timeDelta, random);
}
else
{
if (!predator.SpinAttackCycle.IsFired && !Physics.TryMakeWalk(predator, spritePool, map, timeDelta))
{
predator.AngleDegree = (double)random.Next(360);
}
}
predator.StateJumpCrouch.Update(timeDelta, random);
}
public static double BuildSpinAttackRotation(double firstAngle, double percentComplete)
{
return(Optics.FixAngleRadian(firstAngle + (percentComplete * 2.0 * Math.PI)));
}
