private void ChangeBelt()
{
var methodName = "ChangeBelt";
LogTrace(methodName);
if (_randomWaitObject.ShouldWait())
{
return;
}
//if I'm in station, I need to undock.
if (_meCache.InStation)
{
LogMessage(methodName, LogSeverityTypes.Standard, "Undocking to move to a belt.");
_movement.QueueDestination(new Destination(DestinationTypes.Undock, string.Empty));
return;
}
//reset the wipe stuff
_isWipingThisSpawn = false;
//Also reset the warp-in check
_doWarpInCheck = true;
_warpInCheckCounter = PulsesToWaitForRats;
//gotta work differently depending on type of belts I'm using.
//Only allow reseting of IsBeltEmpty if not in anomaly mode
if (_rattingConfiguration.IsAnomalyMode)
{
MoveToNextAnomaly();
}
else
{
MoveToNextAsteroidBelt();
}
}
protected override void ProcessPulseState()
{
var methodName = "ProcessPulseState";
LogTrace(methodName);
switch (_missionRunnerState)
{
//Update the mission cache:
case MissionRunnerStates.UpdateMissionCache:
//Initially shut the journal. Needs to be opened by ISXEVE or funky shit happens.
if (!_startupJournalShut)
{
_startupJournalShut = true;
using (var journalWindow = _eveWindowProvider.GetWindowByName(WINDOWNAME_JOURNAL))
{
if (!LavishScriptObject.IsNullOrInvalid(journalWindow))
{
journalWindow.Close();
return;
}
}
}
if (Core.StealthBot.MissionCache.UpdateCache(0, true))
{
_missionRunnerState = MissionRunnerStates.SelectAgent;
}
break;
//Pick an agent to use
case MissionRunnerStates.SelectAgent:
if (_hasMaxRuntimeExpired)
{
return;
}
//If downtime is near, don't select an agent. Instead, pause.
if (Core.StealthBot.MeCache.IsDowntimeNear)
{
LogMessage(methodName, LogSeverityTypes.Standard, "We're getting close to standard EVE downtime and are pausing missioning.");
IsEnabled = false;
return;
}
//Set the active agent
SelectAgent();
//If we didn't get an agent, return.
if (SelectedAgent == null)
{
LogMessage(methodName, LogSeverityTypes.Standard, "There are currently no agents available. We're waiting 5 minutes before checking again.");
DelayNextPulseBySeconds(300);
return;
}
//See if we have a matching, accepted mission
var cachedMission = Core.StealthBot.MissionCache.GetCachedMissionForAgentId(SelectedAgent.Id);
if (cachedMission != null && cachedMission.State == (int)MissionStates.Accepted)
{
//Set it active.
ActiveMission = cachedMission;
//Go to the MoveToStart state.
_missionRunnerState = MissionRunnerStates.RunMission;
goto case MissionRunnerStates.RunMission;
}
//No cached mission returned or it wasn't accepted, means we need to go get a mission.
_missionRunnerState = MissionRunnerStates.MoveToAgent;
goto case MissionRunnerStates.MoveToAgent;
case MissionRunnerStates.MoveToAgent:
//If I'm at the agent, go to MissionStart.
if (Core.StealthBot.MeCache.SolarSystemId == SelectedAgent.SolarSystemId &&
Core.StealthBot.MeCache.InStation && Core.StealthBot.MeCache.StationId == SelectedAgent.StationId)
{
_missionRunnerState = MissionRunnerStates.GetMissionFromAgent;
goto case MissionRunnerStates.GetMissionFromAgent;
}
if (Core.StealthBot.MeCache.InStation && Core.StealthBot.MeCache.StationId != SelectedAgent.StationId)
{
Core.StealthBot.Movement.QueueDestination(new Destination(DestinationTypes.Undock));
}
//If I'm not in the same system, first move there
if (Core.StealthBot.MeCache.SolarSystemId != SelectedAgent.SolarSystemId)
{
Core.StealthBot.Movement.QueueDestination(new Destination(DestinationTypes.SolarSystem, SelectedAgent.SolarSystemId));
}
else if (!Core.StealthBot.MeCache.InStation)
{
//Try to find a matching entitywrapper
var stationEntity = Core.StealthBot.EntityProvider.EntityWrappers.FirstOrDefault(
entityWrapper => entityWrapper.Name == SelectedAgent.Station);
//This will satisfy the conditions of the outer If check, thus it'll hit after dock.
Core.StealthBot.Movement.QueueDestination(new Destination(DestinationTypes.Entity, stationEntity.ID)
{
Distance = 200, Dock = true
});
}
break;
case MissionRunnerStates.GetMissionFromAgent:
switch (_getMissionState)
{
case GetMissionStates.Idle:
_getMissionState = GetMissionStates.GetMission;
goto case GetMissionStates.GetMission;
case GetMissionStates.GetMission:
GetMissionFromAgent();
break;
case GetMissionStates.CheckLoadout:
var npcResistanceProfiles = Core.StealthBot.MissionDatabase.GetNpcResistanceProfiles(ActiveMission);
var doneRearming = Core.StealthBot.Ship.RearmShip(npcResistanceProfiles);
if (doneRearming)
{
_getMissionState = GetMissionStates.Idle;
_missionRunnerState = MissionRunnerStates.RunMission;
}
break;
}
break;
case MissionRunnerStates.RunMission:
if (_duringMissionRandomWaitObject.ShouldWait())
{
return;
}
RunMission();
break;
case MissionRunnerStates.TurnInMission:
if (_betweenMissionsRandomWaitObject.ShouldWait())
{
return;
}
TurnInMission();
break;
}
}
public override void Pulse()
{
var methodName = "Pulse";
LogTrace(methodName);
if (!ShouldPulse())
{
return;
}
if (!_meCache.InSpace || _meCache.InStation)
{
return;
}
if (_movement.IsMoving && _movement.MovementType == MovementTypes.Warp)
{
//Make sure all modules are off
_ship.DeactivateModuleList(_ship.MiningLaserModules, true);
_ship.DeactivateModuleList(_ship.SalvagerModules, true);
if (Core.StealthBot.Config.MiningConfig.UseMiningDrones && _drones.DronesInSpace > 0)
{
_drones.RecallAllDrones(true);
}
return;
}
if (_randomWait.ShouldWait())
{
return;
}
var activeTargetId = _meCache.ActiveTargetId;
if (activeTargetId <= 0)
{
return;
}
StartPulseProfiling();
_capacitor = _meCache.Ship.Capacitor;
var activeTarget = _entityProvider.EntityWrappersById[activeTargetId];
var activeQueueTarget = _targeting.GetActiveQueueTarget();
if (activeQueueTarget != null && !_targeting.WasTargetChangedThisFrame)
{
switch (activeQueueTarget.Type)
{
case TargetTypes.Mine:
//If it's not in range, approach
//Otherwise mine
if (_entityProvider.EntityWrappersById[activeQueueTarget.Id].Distance > _ship.MaximumMiningRange &&
(_meCache.ToEntity.Approaching == null || _meCache.ToEntity.Approaching.ID != activeQueueTarget.Id))
{
//Dequeue it, shouldn't be queued any more
_targetQueue.DequeueTarget(activeQueueTarget.Id);
//Unlock it
_targeting.UnlockTarget(activeTarget);
}
break;
case TargetTypes.LootSalvage:
TractorTarget(activeQueueTarget);
break;
}
}
MineTargets();
EndPulseProfiling();
}
private BehaviorExecutionResults DropOffCargoToStation()
{
var methodName = "DropOffCargoToStation";
LogTrace(methodName);
switch (_stationDropOffState)
{
case StationDropOffStates.Idle:
//Just go to the Unload Cargo state.
_stationDropOffState = StationDropOffStates.UnloadCargoHold;
goto case StationDropOffStates.UnloadCargoHold;
case StationDropOffStates.UnloadCargoHold:
if (_doDropoffRandomWait.ShouldWait())
{
return(BehaviorExecutionResults.Incomplete);
}
if (!_ship.IsCargoHoldActive)
{
LogMessage(methodName, LogSeverityTypes.Debug, "Making my ship's cargo hold active.");
_ship.MakeCargoHoldActive();
return(BehaviorExecutionResults.Incomplete);
}
//If I'm mining, only unload ore. Otherwise, unload everything.
if (_mainConfiguration.ActiveBehavior == BotModes.Mining)
{
_ship.TransferOreInCargoHoldToStationHangar();
}
else
{
_ship.TransferCargoHoldToStationHangar();
}
_stationDropOffState = StationDropOffStates.UnloadOreHold;
break;
case StationDropOffStates.UnloadOreHold:
if (!_meCache.Ship.Ship.HasOreHold)
{
_stationDropOffState = StationDropOffStates.StackHangar;
goto case StationDropOffStates.StackHangar;
}
if (!_ship.IsOreHoldActive)
{
LogMessage(methodName, LogSeverityTypes.Debug, "Making my ship's ore hold active.");
_ship.MakeOreHoldActive();
return(BehaviorExecutionResults.Incomplete);
}
//I need to add methods for specifically unloading the ore hold.
_ship.TransferOreHoldToStationHangar();
_stationDropOffState = StationDropOffStates.StackHangar;
break;
case StationDropOffStates.StackHangar:
if (!_station.IsStationHangarActive)
{
LogMessage(methodName, LogSeverityTypes.Debug, "Making the station hangar active.");
_station.MakeStationHangarActive();
return(BehaviorExecutionResults.Incomplete);
}
_ship.StackInventory();
_stationDropOffState = StationDropOffStates.RearmCharges;
break;
case StationDropOffStates.RearmCharges:
//See if we need to rearm crystals.
var isRearmComplete = _ship.RearmMiningCrystals(null);
if (!isRearmComplete)
{
break;
}
//Set state to idle, but don't use a goto case or it'll break things.
_stationDropOffState = StationDropOffStates.Idle;
return(BehaviorExecutionResults.Complete);
}
return(BehaviorExecutionResults.Incomplete);
}
public override void Pulse()
{
var methodName = "Pulse";
LogTrace(methodName);
if (!ShouldPulse())
{
return;
}
if (!_meCache.InSpace || _meCache.InStation ||
(_movement.IsMoving && _movement.MovementType != MovementTypes.Approach))
{
return;
}
StartPulseProfiling();
var wasTargetUnlocked = UnlockUnqueuedTargets();
if (wasTargetUnlocked)
{
EndPulseProfiling();
return;
}
WasTargetChangedThisFrame = false;
//reset the modules dictionary
_modulesBuilt = false;
ModulesOnEntity.Clear();
_queueTargetsByEntityId.Clear();
if (_targetQueue.Targets.Count == 0)
{
_ship.DeactivateModuleList(_ship.SensorBoosterModules, true);
EndPulseProfiling();
return;
}
//Activate sensor boosters
_ship.ActivateModuleList(_ship.SensorBoosterModules, true);
//TargetQueue.SortQueue();
//StartMethodProfiling("BuildE_QT_Dictionary");
foreach (QueueTarget queueTarget in _targetQueue.Targets)
{
_queueTargetsByEntityId.Add(queueTarget.Id, queueTarget);
}
//EndMethodProfiling();
//StartMethodProfiling("TargetNext");
if (_randomWait.ShouldWait())
{
EndPulseProfiling();
return;
}
if (IsTargetJammed)
{
LogMessage(methodName, LogSeverityTypes.Standard, "Targeting jammed, not targeting");
_alerts.TargetJammed();
return;
}
ProcessTargetQueue();
//EndMethodProfiling();
EndPulseProfiling();
}
