internal void Split()
{
if (Game.TickCount < SplitTicks)
{
return;
}
if (Owner.Blobs.Count >= Game.Settings.MaxPlayerBlobCount)
{
return;
}
if (Mass < Game.Settings.MinMassSplit)
{
return;
}
SplitTicks = Game.TickCount + Game.Settings.SplitWaitTicks;
var newMass = Mass / 2.0f;
Mass = newMass;
var split = new PlayerBlob(Owner, Game, _physics, StateTracker, Position, false)
{
Mass = newMass,
Velocity = Velocity * Game.Settings.SplitSpeedFactor
};
split.UpdateRecombineInstant();
UpdateRecombineInstant();
Game.AddBlob(split);
}
internal void AddBlob(PlayerBlob blob)
{
lock (BlobsLock)
{
_blobs.Add(blob);
}
}
private void TryConsume(PlayerBlob blob)
{
if (!CanConsume(blob))
{
return;
}
var maxSplits = (int)Math.Floor(blob.Mass / Game.Settings.MaxPlayerBlobCount);
var numSplits = Game.Settings.MaxPlayerBlobCount - blob.Owner.Blobs.Count;
numSplits = Math.Min(numSplits, maxSplits);
var splitMass = Math.Min(blob.Mass / (numSplits + 1), Game.Settings.MinMassSplit);
if (numSplits <= 0)
{
return;
}
blob.Mass += Mass;
Game.RemoveBlob(this);
var bigSplits = 0;
var endMass = blob.Mass - (numSplits * splitMass);
if ((endMass > 300) && (numSplits > 0))
{
bigSplits++;
numSplits--;
}
if ((endMass > 1200) && (numSplits > 0))
{
bigSplits++;
numSplits--;
}
if ((endMass > 3000) && (numSplits > 0))
{
bigSplits++;
numSplits--;
}
for (var i = 0; i < numSplits; i++)
{
var direction = GetVectorInDirection(2.0 * Math.PI * (i / (double)numSplits));
SplitConsumer(blob, splitMass, direction);
blob.Mass -= splitMass;
}
for (var i = 0; i < bigSplits; i++)
{
var direction = GetVectorInDirection(Game.Random.NextDouble() * 2 * Math.PI);
splitMass = blob.Mass / 4;
SplitConsumer(blob, splitMass, direction);
blob.Mass -= splitMass;
}
blob.UpdateRecombineInstant();
}
private bool CanMerge(PlayerBlob playerBlob)
{
if (OwnedBlobsCollides(playerBlob))
{
return(false);
}
return(Mass >= playerBlob.Mass);
}
private void TryMerge(PlayerBlob playerBlob)
{
if (!CanMerge(playerBlob))
{
return;
}
TryConsume(playerBlob);
}
private void TryConsume(PlayerBlob playerBlob)
{
if (!CanConsume(playerBlob))
{
return;
}
Mass += playerBlob.Mass;
Game.RemoveBlob(playerBlob);
}
private bool CanConsume(PlayerBlob playerBlob)
{
var distance = playerBlob.Position.Dist(Position) - playerBlob.Radius;
if (playerBlob.Owner == Owner)
{
return(distance < GetEatingRange() && Mass >= playerBlob.Mass);
}
return(distance < GetEatingRange() && Mass >= playerBlob.Mass * Game.Settings.StandardEatingMassMultiplier);
}
private void TryConsume(PlayerBlob playerBlob)
{
if (!CanConsume(playerBlob))
{
return;
}
Mass += playerBlob.Mass;
Mass = Math.Min(Mass, Game.Settings.MaxPlayerBlobMass);
Game.RemoveBlob(playerBlob);
}
private void SplitConsumer(PlayerBlob consumer, float splitMass, Vector direction)
{
var speed = consumer.Velocity.Length * Game.Settings.SplitSpeedFactor;
var split = new PlayerBlob(consumer.Owner, Game, _physics, StateTracker, consumer.Position, false)
{
Velocity = direction * speed,
Mass = splitMass
};
split.UpdateRecombineInstant();
Game.AddBlob(split);
}
private bool CanConsume(PlayerBlob playerBlob)
{
var distance = playerBlob.Position.Dist(Position) - playerBlob.Radius;
if (playerBlob.Owner == Owner)
{
return distance < GetEatingRange() && Mass >= playerBlob.Mass;
}
return distance < GetEatingRange() && Mass >= playerBlob.Mass * Game.Settings.StandardEatingMassMultiplier;
}
private bool CanConsume(PlayerBlob playerBlob)
{
var distance = playerBlob.Position.Dist(Position) - playerBlob.Radius;
return(distance < GetEatingRange() && playerBlob.Mass >= GetMinConsumerMass());
}
private bool OwnedBlobsCollides(PlayerBlob playerBlob)
{
return(Game.TickCount < playerBlob.RecombineTicks || Game.TickCount < RecombineTicks);
}
internal void Split()
{
if (Game.TickCount < SplitTicks)
{
return;
}
if (Owner.Blobs.Count >= Game.Settings.MaxPlayerBlobCount)
{
return;
}
if (Mass < Game.Settings.MinMassSplit)
{
return;
}
SplitTicks = Game.TickCount + Game.Settings.SplitWaitTicks;
var newMass = Mass / 2.0f;
Mass = newMass;
var split = new PlayerBlob(Owner, Game, _physics, StateTracker, Position, false)
{
Mass = newMass,
Velocity = Velocity * Game.Settings.SplitSpeedFactor
};
split.UpdateRecombineInstant();
UpdateRecombineInstant();
Game.AddBlob(split);
}
internal void RemoveBlob(PlayerBlob blob)
{
lock (BlobsLock)
{
_blobs.Remove(blob);
}
}
private void TryMerge(PlayerBlob playerBlob)
{
if (!CanMerge(playerBlob))
{
return;
}
TryConsume(playerBlob);
}
private void TryConsume(PlayerBlob playerBlob)
{
if (!CanConsume(playerBlob))
{
return;
}
Mass += playerBlob.Mass;
Game.RemoveBlob(playerBlob);
}
private bool OwnedBlobsCollides(PlayerBlob playerBlob)
{
return Game.TickCount < playerBlob.RecombineTicks || Game.TickCount < RecombineTicks;
}
private bool CanMerge(PlayerBlob playerBlob)
{
if (OwnedBlobsCollides(playerBlob))
{
return false;
}
return Mass >= playerBlob.Mass;
}
private void ApplyPlayerDecisions()
{
lock (BlobsListLock)
{
foreach (var player in _playerRepository.Players)
{
if (player.Join)
{
var position = RemoveFoodAndGetSpawnPosition();
var playerBlob = new PlayerBlob(player, this, _physics, _stateTracker, position, true);
AddBlob(playerBlob);
player.Join = false;
continue;
}
if (!player.Blobs.Any())
{
continue;
}
var center = DetermineGoosCenter(player.Blobs);
var direction = player.PlayerDecisions.Velocity;
foreach (var blob in player.Blobs.Where(x => x.ControlledByPlayer))
{
var normalizedVelocity = (center + direction - blob.Position).Normalize();
var speed = Math.Min(direction.Length, PlayerBlob.GetMaxSpeed(blob.Mass));
blob.Velocity = normalizedVelocity * speed;
switch (player.PlayerDecisions.Activity)
{
case Activity.None:
break;
case Activity.Split:
blob.Split();
break;
case Activity.EjectMass:
blob.EjectMass();
break;
default:
throw new ArgumentOutOfRangeException();
}
}
player.PlayerDecisions.Activity = Activity.None;
}
}
}
