public EquipmentInstallationResult AddEquipment(int equipmentIdentifier, MountPoint mp)
{
EquipmentInstallationResult result = new EquipmentInstallationResult();
ActiveEquipment ae = provide.CreateActiveEquipmentInstance(equipmentIdentifier);
if (ae == null)
{
throw new BdBaseException("The engine provider refused to create the equipment, unexpected.");
}
result.EquipmentId = equipmentIdentifier;
result.InstanceId = ae.InstanceId;
result.Result = InstallationResult.Installed;
if (!installedKit.ContainsKey(mp))
{
// installedKit.Add(mp, new List<EquipmentInstallationResult>());
b.Warning.Log("Warning, failing to install kit because the frame has no mountpoint at the position requested", string.Format("kitid {0} mpId {1} ", equipmentIdentifier, mp));
result.Result = InstallationResult.Fail_InvalidMountpoint;
return(result);
}
bool canInstall = provide.IsValidEquipmentLocation(equipmentIdentifier, mp);
if (!canInstall)
{
result.Result = InstallationResult.Fail_InvalidMountpoint;
return(result);
}
//Must check for space
if (!WillEquipmentFitInMountPoint(ae, mp))
{
result.Result = InstallationResult.Fail_NoSpace;
return(result);
}
installedKit[mp].Add(result);
kitByIdentity.Add(result.InstanceId, ae);
if (ae.Classification == ItemClassification.PowerPack)
{
if (hasPowerpackBeenInstalled)
{
result.Result = InstallationResult.Fail_InvalidCombination;
}
else
{
hasPowerpackBeenInstalled = true;
}
}
return(result);
}
// TODO : Unit test that forces this to fail
private bool WillEquipmentFitInMountPoint(ActiveEquipment ae, MountPoint mp)
{
b.Warning.Log("This is hardcoded");
int spaceTaken = 0;
foreach (var ep in GetEquipmentInMountPoint(mp))
{
spaceTaken += kitByIdentity[ep.InstanceId].UnderlyingItem.SpaceRequired;
}
int space = activeFrame.GetTotalSpaceForMountPoint(mp);
return(space >= ae.UnderlyingItem.SpaceRequired);
}
private EquipmentInstallationResult PerformEquipmentInstallation(Message_BotPerformAction actionMessage)
{
EquipmentInstallationContext eic = (EquipmentInstallationContext)actionMessage.RequestContext;
EquipmentInstallationResult result = new EquipmentInstallationResult();
var baseEquipment = equipment.GetEquipmentTypeById(eic.EquipmentIdentifier);
ActiveEquipment ei = new ActiveEquipment(baseEquipment);
result.InstanceId = ei.InstanceId = Guid.NewGuid();
result.EquipmentId = ei.EquipmentId = eic.EquipmentIdentifier;
result.Result = InstallationResult.Installed;
ei.OwningBotId = eic.OwningBotIdentity;
ei.MountPoint = eic.MountPoint;
ei.Classification = KnownEquipmentIds.GetClassificationFromId(eic.EquipmentIdentifier);
if (ei.Classification == ItemClassification.OffsensiveWeapon)
{
var eq = equipment.GetWeaponEquipmentById(eic.EquipmentIdentifier);
ei.RoundsRemaining = eq.InitialAmmunition;
}
installedEquipment.Add(ei);
return(result);
}
private EquipmentUseResult PerformScannerUsage(ScannerEquipmentItem equipTemplate, ActiveEquipment activeEquipmentInstance, MappedBot owningBot)
{
ScanEquipmentUseResult result = new ScanEquipmentUseResult();
if (!owningBot.ConsumeCharge(equipTemplate.ChargeConsumed))
{
result.State = UsageEndState.Fail_NoCharge;
return(result);
}
Point mapOffset = owningBot.Position;
foreach (var vSrc in equipTemplate.GetAllScanPoints())
{
Point v = new Point(vSrc.X + mapOffset.X, vSrc.Y + mapOffset.Y);
ScanTileResult str = ScanTileResult.Unscanned;
MapTile mt = MapTile.DefaultGround;
if (activeWorld.IsValidSpace(v))
{
var tileOccupant = GetTileOccupantByLocation(v);
if (tileOccupant != null)
{
if (tileOccupant.EngineId == owningBot.EngineId)
{
str = ScanTileResult.You;
}
else
{
int ctk = CreateTemporaryScanKey(owningBot.EngineId, tileOccupant.EngineId);
result.AddPointOfInterest(v, ctk);
str = tileOccupant.IsAlive() ? ScanTileResult.Bot : ScanTileResult.Wreckage;
}
}
else
{
mt = activeWorld.Map.GetTileAtPosition(v);
}
}
else
{
mt = MapTile.BoundaryWall1;
}
if (str == ScanTileResult.Unscanned)
{
// If there was not an active occupant, then look to the map.
switch (mt)
{
case MapTile.BoundaryWall1: str = ScanTileResult.SolidWall; break;
case MapTile.DefaultGround: str = ScanTileResult.Unoccupied; break;
default: throw new BdBaseException("DEFAULT - invalid tile mapping - " + mt.ToString());
}
}
result.SetDimensions(equipTemplate.MinimumXScanned, equipTemplate.MinimumYScanned, equipTemplate.TotalWidthScanned, equipTemplate.TotalHeightScanned);
result.SetScanResultAtPosition(vSrc, str);
}
return(result);
}
private EquipmentUseResult PerformFireWeapon(OffensiveWeaponEquipmentItem owi, ActiveEquipment activeEquipmentInstance, MappedBot attacker, EquipmentUseRequestContext ctxt)
{
EquipmentUseResult result = new EquipmentUseResult();
if (activeEquipmentInstance.CooldownTicksRemaining > 0)
{
result.State = UsageEndState.Fail_CooldownActive;
return(result);
}
MappedBot victim = ConvertTemporaryScanKeyToBot(attacker.EngineId, ctxt.IParam);
if (victim == null)
{
result.State = UsageEndState.Fail_InvalidTarget;
b.Warning.Log("The bot tried to target an invalid key. This shouldnt happen");
return(result);
}
b.Assert.True(attacker.EngineId != victim.EngineId, "You cant shoot at yourself.");
activeEquipmentInstance.RoundsRemaining -= 1;
if (activeEquipmentInstance.RoundsRemaining <= 0)
{
result.State = UsageEndState.Fail_NoAmmo;
return(result);
}
if (!attacker.ConsumeCharge(owi.BaseChargeCost))
{
result.State = UsageEndState.Fail_NoCharge;
return(result);
}
CombatAttack ca = new CombatAttack();
ca.Attacker = attacker;
ca.Victim = victim;
ca.Weapon = owi;
ca.WeaponInstance = activeEquipmentInstance;
CombatResult cr = combatCore.ResolveAttack(ca);
UICombatContext context = new UICombatContext();
context.AggressorId = attacker.EngineId;
context.VictimId = victim.EngineId;
context.WeaponTypeId = owi.UniqueId;
context.DidHit = cr.DidHit;
context.Damage = cr.TotalDamage;
hub.Launch <Message_Ui>(new Message_Ui(MainMessageKind.UIMessage, KnownSubkinds.WeaponFire)
{
RequestContext = context
});
if (cr.DidHit)
{
ApplyWeaponfireHit(victim, cr);
}
result.State = UsageEndState.Success;
return(result);
}
