private void CollectConfigMissionByLocation(MissionLocation location, Dictionary <string, object> result, ref int counter)
{
var maxLevel = 10; //
for (var i = -1; i < maxLevel; i++)
{
foreach (var category in Enum.GetValues(typeof(MissionCategory)).Cast <MissionCategory>())
{
var categoryCount = location.Agent.MyConfigMissions.Count(m => m.MissionLevel == i && m.missionCategory == category && location.id == m.LocationId);
if (categoryCount > 0)
{
var myDict = new Dictionary <string, object>
{
{ k.missionCategory, (int)category },
{ k.count, categoryCount },
{ k.missionLevel, i },
{ k.location, location.id },
};
result.Add("c" + counter++, myDict);
}
}
}
}
public static int CalculatePayment(MissionLocation fromLocation, MissionLocation toLocation,
MissionCargo missionCargo)
{
var distance = GetDistance(fromLocation, toLocation);
return((int)Math.Floor(distance * missionCargo.PayPerUnit));
}
public MissionFilter(Character character, Dictionary <int, DateTime> periodicMissionTimes, ICollection <int> finishedMissionsIds, MissionProcessor missionProcessor, MissionLocation location, MissionDataCache missionDataCache)
{
_character = character;
_agent = location.Agent;
_periodicMissionTimes = periodicMissionTimes;
_finishedMissionIds = finishedMissionsIds;
_missionProcessor = missionProcessor;
_location = location;
_missionDataCache = missionDataCache;
}
public static void InsertToDb(Mission mission, MissionLocation location, int attempts, int success, int uniquecases, int rewardAverage)
{
var res =
Db.Query().CommandText("INSERT dbo.missiontolocation ( missionid, locationid, attempts, success, uniquecases,rewardaverage) VALUES ( @missionid,@locationid,@attempts,@success,@uniquecases,@rewardAverage)")
.SetParameter("@missionid", mission.id)
.SetParameter("@locationid", location.id)
.SetParameter("@attempts", attempts)
.SetParameter("@success", success)
.SetParameter("@uniquecases", uniquecases)
.SetParameter("@rewardAverage", rewardAverage)
.ExecuteNonQuery();
(res == 1).ThrowIfFalse(ErrorCodes.SQLInsertError);
}
private void StartAsync(Character character, bool spreading, int missionId, MissionLocation location, int level)
{
Task.Run(() =>
{
using (var scope = Db.CreateTransaction())
{
Logger.Info("starting a new mission:" + missionId + " " + location);
MissionInProgress triggeredMission;
TriggeredMissionStart(character, spreading, missionId, location, level, out triggeredMission);
Transaction.Current.OnCommited(() => SendRunningMissionList(character));
scope.Complete();
}
}).LogExceptions();
}
private Dictionary <string, object> GenerateRandomMissionOptions(MissionLocation location, Character character, List <int> missionsDone, Dictionary <int, DateTime> periodicMissions, List <Mission> solvableMissions)
{
var availabilityDict = new Dictionary <string, object>();
var missionAgent = location.Agent;
var missionFilter = new MissionFilter(character, periodicMissions, missionsDone, this, location, _missionDataCache);
int[] missionIdsByAgent;
if (!_missionDataCache.GetMissionIdsByAgent(missionAgent, out missionIdsByAgent))
{
//no random mission defined for this agent
return(availabilityDict);
}
var rndMissionsHere = solvableMissions.Where(m => missionFilter.IsRandomMissionAvailable(m)).ToList();
var counter = 0;
foreach (var missionCategory in Enum.GetValues(typeof(MissionCategory)).Cast <MissionCategory>())
{
if (rndMissionsHere.All(m => m.missionCategory != missionCategory))
{
continue;
}
//one mission per category
if (missionFilter.IsMissionRunningWithThisCategory(missionCategory))
{
continue;
}
for (var missionLevel = 0; missionLevel <= location.maxMissionLevel; missionLevel++)
{
var oneEntry = new Dictionary <string, object>()
{
{ k.missionCategory, (int)missionCategory },
{ k.missionLevel, missionLevel },
{ k.oke, 1 },
};
availabilityDict.Add("r" + counter++, oneEntry);
}
}
return(availabilityDict);
}
public SictMissionZuusctand(
Int64?Bezaicner,
Int64?SictungFrühesteZaitMili,
Int64?OfferFrühesteZaitMili,
string MissionTitel,
string AgentName,
int?AgentLevel,
MissionLocation AgentLocation = null)
:
base(Bezaicner ?? -1)
{
this.SictungFrühesteZaitMili = SictungFrühesteZaitMili;
this.OfferFrühesteZaitMili = OfferFrühesteZaitMili;
this.Titel = MissionTitel;
this.AgentName = AgentName;
this.AgentLevel = AgentLevel;
this.AgentLocation = AgentLocation;
}
/// <summary>
/// Oldschool mission options.
/// </summary>
/// <param name="location"></param>
/// <param name="character"></param>
/// <param name="missionsDone"></param>
/// <param name="periodicMissions"></param>
/// <param name="solvableMissions"></param>
/// <returns></returns>
private Dictionary <string, object> GenerateConfigMissionOptions(MissionLocation location, Character character, List <int> missionsDone, Dictionary <int, DateTime> periodicMissions, List <Mission> solvableMissions)
{
var missionAgent = location.Agent;
var missionFilter = new MissionFilter(character, periodicMissions, missionsDone, this, location, _missionDataCache);
var standing = _standingHandler.GetStanding(missionAgent.OwnerAlliance.Eid, character.Eid);
//if the agent has random missions then we skip the levels from 0 ... 9
//otherwise we include all config levels
//var topLevel = solvableMissions.Count > 0 ? -1 : 9;
var topLevel = 9;
var counter = 0;
var availabilityDict = new Dictionary <string, object>();
foreach (var missionCategory in Enum.GetValues(typeof(MissionCategory)).Cast <MissionCategory>())
{
for (var missionLevel = -1; missionLevel <= topLevel; missionLevel++)
{
var missionsWithCategoryAndLevel = missionFilter.GetConfigMissionsByCategoryAndLevel(missionCategory, missionLevel).ToArray();
var totalCount = missionsWithCategoryAndLevel.Count(m => !m.isTriggered && m.listable);
var standingBlocked = standing < missionLevel;
var availableCount = missionsWithCategoryAndLevel.Count(m => missionFilter.IsConfigMissionAvailable(m, _standingHandler));
var oneEntry = new Dictionary <string, object>()
{
{ k.missionCategory, (int)missionCategory },
{ k.missionLevel, missionLevel },
{ "totalCount", totalCount },
{ "availableCount", availableCount },
{ k.oke, (availableCount > 0 ? 1 : 0) },
{ "standingBlocked", standingBlocked },
};
availabilityDict.Add("c" + counter++, oneEntry);
}
}
return(availabilityDict);
}
private void DrawOneCategory(IRequest request, MissionLocation missionLocation, MissionCategory category)
{
const string query = "SELECT * FROM dbo.missiontargetslog WHERE zoneid=@zoneId and locationeid=@locationEid and missioncategory=@category";
var entries = Db.Query().CommandText(query)
.SetParameter("@zoneId", _zone.Id)
.SetParameter("@category", (int)category)
.SetParameter("@locationEid", missionLocation.LocationEid)
.Execute()
.Select(MissionTargetSuccessLogEntry.FromRecord).ToArray();
if (entries.Length == 0)
{
Logger.Info("no entry at " + missionLocation + " in category: " + category);
return;
}
var bitmap = _zone.CreatePassableBitmap(_passableColor, _islandColor);
DrawEntriesOnBitmap(entries, bitmap);
var ft = _zone.GetUnit(missionLocation.LocationEid);
var littleText = "locationID:" + missionLocation.id;
if (ft != null)
{
littleText += " " + ft.Name;
}
var category1 = category;
bitmap.WithGraphics(gx => gx.DrawString(category1.ToString(), new Font("Tahoma", 15), new SolidBrush(Color.White), new PointF(20, 40)));
bitmap.WithGraphics(gx => gx.DrawString(littleText, new Font("Tahoma", 15), new SolidBrush(Color.White), new PointF(20, 60)));
var idString = $"{missionLocation.id:0000}";
var fname = "_" + category1 + "_LOC" + idString + "_";
SendBitmapFinished(request, fname);
_saveBitmapHelper.SaveBitmap(_zone, bitmap, fname);
}
private void GenerateMission(MissionLocation missionLocation)
{
GameObject newMission = Instantiate(missionPrefab, new Vector3(0, 0, 0), Quaternion.identity);
newMission.transform.SetParent(missionPanel.transform);
newMission.transform.localPosition = new Vector3(0, 0, 0);
newMission.transform.localScale = new Vector3(1, 1, 1);
if (missionLocation == MissionLocation.Beach)
{
newMission.transform.Find("Location").GetComponent <Image>().sprite = beach;
newMission.transform.Find("Text").GetComponent <Text>().text = "Head to the beach and survive.";
isBeach = true;
}
else
{
newMission.transform.Find("Location").GetComponent <Image>().sprite = temple;
newMission.transform.Find("Text").GetComponent <Text>().text = "Travel to the forest temple and find the Intel.";
isTemple = true;
}
}
private void CollectRandomMissionsByLocation(MissionLocation location, Dictionary <string, object> result, ref int counter)
{
for (var i = 0; i <= location.maxMissionLevel; i++)
{
foreach (var category in Enum.GetValues(typeof(MissionCategory)).Cast <MissionCategory>())
{
var categoryCount = location.Agent.MyRandomMissions.Count(m => m.missionCategory == category);
if (categoryCount > 0)
{
var myDict = new Dictionary <string, object>
{
{ k.missionCategory, (int)category },
{ k.count, categoryCount },
{ k.missionLevel, i },
{ k.location, location.id },
};
result.Add("r" + counter++, myDict);
}
}
}
}
public void GetOptionsByRequest(Character character, MissionLocation location)
{
var result = new Dictionary <string, object>()
{
{ k.locationID, location.id }
};
List <int> missionsDone;
Dictionary <int, DateTime> periodicMissions;
GetFinishedAndLastMissions(character, out missionsDone, out periodicMissions).ThrowIfError();
var solvableMissions = location.GetSolvableRandomMissionsAtLocation();
var configMissionsAvailabilityDict = GenerateConfigMissionOptions(location, character, missionsDone, periodicMissions, solvableMissions);
result.Add(k.options, configMissionsAvailabilityDict);
var randomMissionAvailabilityDict = GenerateRandomMissionOptions(location, character, missionsDone, periodicMissions, solvableMissions);
result.Add("randomMissions", randomMissionAvailabilityDict);
Message.Builder.WithData(result).ToCharacter(character).SetCommand(Commands.MissionGetOptions).Send();
}
// an admin starts a mission
public Dictionary <string, object> AdminMissionStartByRequest(Character character, bool spreadInGang, int missionId, MissionLocation location, int level)
{
Mission mission;
_missionDataCache.GetMissionById(missionId, out mission).ThrowIfFalse(ErrorCodes.ItemNotFound);
int missionLevel;
if (mission.behaviourType == MissionBehaviourType.Random)
{
missionLevel = level; //submitted from gui
}
else
{
//use the mission's level
missionLevel = mission.MissionLevel;
}
MissionInProgress missionInProgress;
var result = TriggeredMissionStart(character, spreadInGang, missionId, location, missionLevel, out missionInProgress);
if (result)
{
Transaction.Current.OnCommited(() => GetOptionsByRequest(character, location));
Transaction.Current.OnCommited(() => SendRunningMissionList(character));
}
else
{
throw new PerpetuumException(ErrorCodes.UnableToResolveMission);
}
return(new Dictionary <string, object>
{
{ k.mission, missionInProgress.ToDictionary() },
});
}
// the system triggers a mission
public bool TriggeredMissionStart(Character character, bool spreadInGang, int missionId, MissionLocation location, int level, out MissionInProgress missionInProgress)
{
Logger.Info("trying to trigger missionId: " + missionId + " characterId:" + character.Id);
Mission mission;
_missionDataCache.GetMissionById(missionId, out mission).ThrowIfFalse(ErrorCodes.ItemNotFound);
var resolved = MissionAdministrator.StartMission(character, spreadInGang, mission, location, level, out missionInProgress);
return(resolved);
}
public bool StartMission(Character character, bool spreadInGang, Mission mission, MissionLocation location, int level, out Dictionary <string, object> info)
{
//add the new mission in progress, set things in motion
MissionInProgress missionInProgress;
var resolved = MissionAdministrator.StartMission(character, spreadInGang, mission, location, level, out missionInProgress);
if (!resolved)
{
info = new Dictionary <string, object>();
return(false);
}
Transaction.Current.OnCommited(() => GetOptionsByRequest(character, missionInProgress.myLocation));
info = new Dictionary <string, object>
{
{ k.mission, missionInProgress.ToDictionary() },
};
return(true);
}
public MissionStandingChangeCalculator(MissionInProgress missionInProgress, MissionLocation missionLocation)
{
_missionLocation = missionLocation;
_missionInProgress = missionInProgress;
}
public static double GetDistance(MissionLocation fromLocation, MissionLocation toLocation)
{
return(Math.Sqrt(Math.Pow(toLocation.Position.X - fromLocation.Position.X, 2) +
Math.Pow(toLocation.Position.Y - fromLocation.Position.Y, 2)));
}
/// <summary>
/// Selects a template and starts it... Random mission start
/// </summary>
/// <param name="character"></param>
/// <param name="spreadInGang"></param>
/// <param name="location"></param>
/// <param name="level"></param>
/// <param name="category"></param>
/// <returns></returns>
public Dictionary <string, object> SelectAndStartRandomMission(Character character, bool spreadInGang, MissionLocation location, int level, MissionCategory category)
{
if (location.Zone == null)
{
Logger.Error("zone config was not found for zoneId:" + location.zoneId);
throw new PerpetuumException(ErrorCodes.ZoneNotFound);
}
var missionAgent = location.Agent;
GetFinishedAndLastMissions(character, out List <int> missionsDone, out Dictionary <int, DateTime> periodicMissions).ThrowIfError();
var missionFilter = new MissionFilter(character, periodicMissions, missionsDone, this, location, _missionDataCache);
missionFilter.IsMissionRunningWithThisCategoryAndLevel(category, level, missionAgent).ThrowIfTrue(ErrorCodes.MissionRunningWithCategoryAndLevel);
MissionHelper.GetStandingData(character, missionAgent.OwnerAlliance.Eid, out double standing, out int playerLevel);
//at this location this is the maximum level
playerLevel = playerLevel.Clamp(0, location.maxMissionLevel);
//not higher pls
level = level.Clamp(0, playerLevel);
var solvableMissions = location.GetSolvableRandomMissionsAtLocation();
var rndMissionsHere = solvableMissions
.Where(m =>
m.missionCategory == category &&
missionFilter.IsRandomMissionAvailable(m)
).ToList();
if (rndMissionsHere.Count == 0)
{
character.CreateErrorMessage(Commands.MissionStart, ErrorCodes.NoMissionAvailableWithConditions)
.SetExtraInfo(d => d[k.message] = "no mission was found")
.Send();
return(null);
}
var mission = rndMissionsHere.RandomElement();
mission.ThrowIfNull(ErrorCodes.WTFErrorMedicalAttentionSuggested);
var resolveInfo = _missionDataCache.GetAllResolveInfos.FirstOrDefault(ri => ri.missionId == mission.id && ri.locationId == location.id);
resolveInfo.ThrowIfNull(ErrorCodes.ConsistencyError);
var attempts = resolveInfo.attempts;
Dictionary <string, object> info = new Dictionary <string, object>();
var resolved = false;
while (attempts-- > 0 && !resolved)
{
resolved = StartMission(character, spreadInGang, mission, location, level, out info);
if (!resolved)
{
Logger.Warning("mission resolve attempts left " + attempts + " " + mission);
}
}
resolved.ThrowIfFalse(ErrorCodes.WTFErrorMedicalAttentionSuggested);
return(info);
}
public bool TryCreateMission(Character character, bool spreadInGang, Mission mission, MissionLocation location, int level, out MissionInProgress missionInProgress, bool isTestMode = false)
{
if (location.ZoneConfig == ZoneConfiguration.None)
{
Logger.Error("zone config was not found for zoneId:" + location.ZoneConfig.Id);
missionInProgress = null;
return(false);
}
missionInProgress = _missionInProgressFactory(mission);
missionInProgress.missionGuid = Guid.NewGuid();
missionInProgress.character = character;
missionInProgress.started = DateTime.Now;
missionInProgress.expire = DateTime.Now.AddMinutes(mission.durationMinutes);
missionInProgress.spreadInGang = spreadInGang;
missionInProgress.bonusMultiplier = GetBonusMultiplierForMissionStart(character, mission, location, level);
missionInProgress.myLocation = location;
missionInProgress.MissionLevel = level;
missionInProgress.isTestMode = isTestMode;
if (mission.behaviourType == MissionBehaviourType.Config)
{
//get from cached data
missionInProgress.SetIssuerCorporationAndAllianceByConfigMission();
}
else
{
//lookup based on location
missionInProgress.SetIssuerCorporationAndAllianceByLocation();
}
missionInProgress.SetRewardDivider();
//add targets in progress
var success = missionInProgress.CreateAndSolveTargets(mission);
return(success);
}
public bool StartMission(Character character, bool spreadInGang, Mission mission, MissionLocation location, int level, out MissionInProgress missionInProgress)
{
Logger.Info("Attempting to start mission. " + mission + " lvl:" + level + " location:" + location + " spreading:" + spreadInGang + " characterID:" + character.Id);
if (!TryCreateMission(character, spreadInGang, mission, location, level, out missionInProgress))
{
if (mission.behaviourType == MissionBehaviourType.Config)
{
throw new PerpetuumException(ErrorCodes.WTFErrorMedicalAttentionSuggested);
}
//random missiont failed to resolve
Logger.Warning("random mission failed to resolve. " + mission + " characterID:" + character.Id);
return(false);
}
AdministrateNewMission(missionInProgress);
return(true);
}
private Dictionary <DeliveryHelper, MissionTargetInProgress> GenerateDeliveryHelpers(List <MissionTargetInProgress> targetsInProgress, MissionLocation location, Character delivererCharacter)
{
var deliveryHelpers = new Dictionary <DeliveryHelper, MissionTargetInProgress>(targetsInProgress.Count);
foreach (var targetInProgress in targetsInProgress)
{
var dh = targetInProgress.CreateDeliveryHelper(
location.id,
targetInProgress.myMissionInProgress.character,
targetInProgress.myMissionInProgress.MissionId,
targetInProgress.MissionTargetId,
delivererCharacter,
targetInProgress.myMissionInProgress.missionGuid
);
deliveryHelpers.Add(dh, targetInProgress);
}
return(deliveryHelpers);
}
public override bool ResolveLocation(MissionInProgress missionInProgress)
{
//if the mission structure is not set AND anyLocation is true
if (!ValidMissionStructureEidSet && !deliverAtAnyLocation)
{
//pick a location => fieldTerminal or dockingBase
var possibleLocations = missionDataCache.GetAllLocations
.Where(l =>
l.ZoneConfig.Id == missionInProgress.myLocation.ZoneConfig.Id &&
missionInProgress.SearchOrigin.IsInRangeOf2D(l.MyPosition, TargetPositionRange) &&
l.LocationEid != missionInProgress.myLocation.LocationEid).ToArray();
if (possibleLocations.Length == 0)
{
Log("no possible delivery location was found for " + this + " " + missionInProgress);
return(false);
}
Log("possible delivery locations: " + possibleLocations.Length);
possibleLocations = possibleLocations.Except(missionInProgress.SelectedLocations).ToArray();
Log("except choosen: " + possibleLocations.Length);
var minimumDistance = double.MaxValue;
MissionLocation closestLocation = null;
foreach (var missionLocation in possibleLocations)
{
var distance = missionLocation.MyPosition.TotalDistance2D(missionInProgress.myLocation.MyPosition);
if (distance < minimumDistance)
{
closestLocation = missionLocation;
minimumDistance = distance;
}
}
//complier shutup
if (closestLocation == null)
{
return(false);
}
Log("the closest location is " + closestLocation);
//this is going to be saved to sql
missionStructureEid = closestLocation.LocationEid;
//other data to work with
targetPositionX = (int)closestLocation.X;
targetPositionY = (int)closestLocation.Y;
targetPositionZone = closestLocation.ZoneConfig.Id;
//comfy init
SetTargetPosition_RandomTarget();
//pass the found position on
missionInProgress.SearchOrigin = targetPosition;
//and mark the choosen location used
missionInProgress.AddToSelectedLocations(closestLocation);
}
return(base.ResolveLocation(missionInProgress));
}
public void TestOne(MissionLocation location, Mission mission, Character testCharacter, int missionLevel, int maxAttempts = 100, bool writeResult = true)
{
var rewardCollector = 0.0;
var wasException = false;
var structureHashList = new List <long>();
//Logger.Info(" location " + location.id);
int successCount = 0;
for (int attempt = 0; attempt < maxAttempts; attempt++)
{
MissionInProgress missionInProgress = null;
bool success = false;
try
{
success =
_missionProcessor.MissionAdministrator.TryCreateMission(testCharacter, false, mission, location, missionLevel, out missionInProgress, true);
}
catch (Exception ex)
{
//this mission has some content/config problem
Logger.Error("exception occured in mission resolve: " + mission);
Logger.Exception(ex);
wasException = true;
break;
}
if (success)
{
var sHash = missionInProgress.GenerateStructureHash();
if (sHash > 0)
{
structureHashList.Add(sHash);
}
successCount++;
missionInProgress.GenerateSuccessInfoForTest(_terminalsOnZones);
double rewardSum;
double distanceReward;
double difficultyReward;
double rewardByTargets;
double riskCompensation;
double zoneFactor;
missionInProgress.GetFinalReward(out rewardSum, out distanceReward, out difficultyReward, out rewardByTargets, out riskCompensation, out zoneFactor);
rewardCollector += rewardSum;
if (writeResult)
{
missionInProgress.WriteSuccessLogAllTargets();
}
}
}
if (!wasException)
{
var rewardAverage = 0;
if (successCount > 0)
{
rewardAverage = (int)(rewardCollector / (double)successCount);
}
else
{
Logger.Error("100% failure: " + location + " " + mission);
}
var uniqueHash = structureHashList.Distinct().Count();
Logger.Info("success:" + successCount + " unique:" + uniqueHash);
Logger.Info("paid reward " + rewardAverage);
if (writeResult)
{
//make it blocking, on purpose
MissionResolveInfo.InsertToDb(mission, location, maxAttempts, successCount, uniqueHash, rewardAverage);
}
}
else
{
Logger.Error("--------------------------");
Logger.Error("--------------------------");
Logger.Error("exception:" + location + " " + mission);
Logger.Error("--------------------------");
Logger.Error("--------------------------");
}
}
public bool GetLocationById(int id, out MissionLocation location)
{
return(_missionLocations.TryGetValue(id, out location));
}
/// <summary>
/// Starts a mission by client request
/// </summary>
/// <param name="character"></param>
/// <param name="category"></param>
/// <param name="level"></param>
/// <param name="spreadInGang"></param>
/// <param name="location"></param>
/// <returns></returns>
public Dictionary <string, object> MissionStartForRequest(Character character, MissionCategory category, int level, MissionLocation location)
{
var gang = character.GetGang();
//fix spreading:
//if in gang = always spreading
//else = not spreading
var spreadInGang = gang != null;
var agent = location.Agent;
var safeToResolve = location.GetSolvableRandomMissionsAtLocation();
if (level >= 0 && safeToResolve.Count > 0 && category != MissionCategory.Special)
{
return(SelectAndStartRandomMission(character, spreadInGang, location, level, category));
}
//old missions
return(SelectAndStartConfigMission(character, agent, category, level, spreadInGang, location));
}
private double GetBonusMultiplierForMissionStart(Character character, Mission mission, MissionLocation location, int level)
{
var result = 1.0;
MissionBonusCollector collector;
if (_missionBonuses.TryGetValue(character.Id, out collector))
{
MissionBonus bonus;
if (collector.GetBonusWithConditions(mission.missionCategory, level, location.Agent, out bonus))
{
result = bonus.BonusMultiplier;
return(result);
}
}
//on level 0 there is no bonus collector allocated
var extBonus = character.GetExtensionBonusByName(ExtensionNames.MISSION_BONUS_LEVEL_MOD) + 1;
result *= extBonus;
return(result);
}
/// <summary>
/// This is the actual function that starts a mission, OLD SCHOOL
/// </summary>
/// <param name="character"></param>
/// <param name="agent"></param>
/// <param name="category"></param>
/// <param name="level"></param>
/// <param name="spreadInGang"></param>
/// <param name="location"></param>
/// <returns></returns>
public Dictionary <string, object> SelectAndStartConfigMission(Character character, MissionAgent agent, MissionCategory category, int level, bool spreadInGang, MissionLocation location)
{
List <int> missionsDone;
Dictionary <int, DateTime> periodicMissions;
GetFinishedAndLastMissions(character, out missionsDone, out periodicMissions).ThrowIfError();
var missionFilter = new MissionFilter(character, periodicMissions, missionsDone, this, location, _missionDataCache);
missionFilter.IsMissionRunningWithThisCategoryAndLevel(category, level, agent).ThrowIfTrue(ErrorCodes.MissionRunningWithCategoryAndLevel);
var missions =
missionFilter.GetConfigMissionsByCategoryAndLevel(category, level).Where(m => missionFilter.IsConfigMissionAvailable(m, _standingHandler)).ToArray();
missions.Any().ThrowIfFalse(ErrorCodes.NoMissionAvailableWithConditions);
var mission = missions.RandomElement();
Dictionary <string, object> info;
var resolved = StartMission(character, spreadInGang, mission, location, level, out info);
if (!resolved)
{
Logger.Error("WTF? in config mission start " + location + " " + mission);
}
return(info);
}
public void Berecne()
{
var MengeNode = this.MengeNode;
if (null == MengeNode)
{
return;
}
/*
* 2013.11.21 Bsp:
* <td><font color=#00FF7F>0,8</font> <a href=showinfo:1530//60003985>Oipo II - Moon 19 - Ishukone Watch Logistic Support</a> <font color=#E3170D></font></td>
*
* 2014.07.17 Bsp (Security Level Dezimaaltrenzaice "."):
* <td width=200><font color=#00FFBF>0.9</font> <a href=showinfo:5//30004970//1.54581996781e+12//-2.7761830639e+11//-2.2459826125e+12//3009708//0//dungeon>Renyn</a> <font color=#E3170D></font></td>
*
* **/
foreach (var Node in MengeNode)
{
if (null == SecurityLevelHtmlNode)
{
if (string.Equals(Node.Name, "font", StringComparison.InvariantCultureIgnoreCase))
{
var SecurityLevelMatch = TempAuswertGbs.Extension.SctandardNumberFormatRegex.Match(Node.InnerText ?? "");
if (SecurityLevelMatch.Success)
{
SecurityLevelHtmlNode = Node;
SecurityLevelString = SecurityLevelMatch.Value;
}
}
}
if (null == LocationLinkHtmlNode)
{
if (string.Equals(Node.Name, "a", StringComparison.InvariantCultureIgnoreCase))
{
var Href = Node.GetAttributeValue("href", (string)null);
if (Regex.Match(Href ?? "", "showinfo", RegexOptions.IgnoreCase).Success)
{
LocationLinkHtmlNode = Node;
LocationName = Node.InnerText;
}
}
}
}
if (null == SecurityLevelString || null == LocationName)
{
return;
}
if (null != LocationName)
{
var Location = TempAuswertGbs.Extension.VonStringMissionLocationNameExtraktLocationInfo(LocationName);
LocationNameTailSystem = (null == Location) ? null : Location.SolarSystemName;
}
LocationSecurityLevelMili = (int?)TempAuswertGbs.Extension.SctandardNumberFormatZaalBetraagMili(SecurityLevelString);
var Ergeebnis = new MissionLocation(LocationName, LocationSecurityLevelMili, LocationNameTailSystem);
this.Ergeebnis = Ergeebnis;
}
private void DeliverMissionByTargetList(List <MissionTargetInProgress> interestingTargets, Character character, MissionLocation location)
{
var isDocked = character.IsDocked;
var deliveryState = DeliverResult.nothingHappened;
var result = new Dictionary <string, object>();
if (interestingTargets.Count == 0)
{
//no targets were found among running targets / squad running targets
#if DEBUG
Logger.Info("no targets to deliver in this round. ");
#endif
result.Add(k.deliveryState, (int)deliveryState);
Message.Builder.SetCommand(Commands.MissionDeliver)
.WithData(result)
.ToCharacter(character)
.Send();
return;
}
Container robotInventory = null;
var activeRobot = character.GetActiveRobot();
if (activeRobot != null)
{
robotInventory = activeRobot.GetContainer();
}
var publicContainer = location.GetContainer;
if (publicContainer == null)
{
Logger.Error("WTF no public container on location " + location + " characterId:" + character + " isDocked:" + isDocked);
throw new PerpetuumException(ErrorCodes.ContainerNotFound);
}
var itemsAffected = 0;
var deliveryHelpers = GenerateDeliveryHelpers(interestingTargets, location, character);
var itemsFromRobot = 0;
var itemsFromPublicContainer = 0;
if (isDocked)
{
//in docking base
//robot inventory full tree
if (robotInventory != null)
{
LookUpContainerForMissionDeliverItems(character, robotInventory, ref itemsAffected, deliveryHelpers, true);
}
itemsFromRobot = itemsAffected;
//first level
LookUpContainerForMissionDeliverItems(character, publicContainer, ref itemsAffected, deliveryHelpers, false);
itemsFromPublicContainer = itemsAffected - itemsFromRobot;
}
else
{
// at field terminal
//full tree
if (robotInventory != null)
{
LookUpContainerForMissionDeliverItems(character, robotInventory, ref itemsAffected, deliveryHelpers, true);
}
itemsFromRobot = itemsAffected;
//full tree
LookUpContainerForMissionDeliverItems(character, publicContainer, ref itemsAffected, deliveryHelpers, true);
itemsFromPublicContainer = itemsAffected - itemsFromRobot;
}
if (itemsAffected == 0)
{
#if DEBUG
Logger.Info("no items were found in containers for characterId:" + character);
#endif
//deliveryState = DeliverResult.noDeliverableItemsFound;
//no items were found in containers
//result.Add(k.deliveryState, (int)deliveryState);
Message.Builder.SetCommand(Commands.MissionDeliver)
.WithError(ErrorCodes.MissionNoItemsFoundToDeliver)
.ToCharacter(character)
.Send();
return;
}
//these objects to progressed
var changedDeliveryHelpers = deliveryHelpers.Keys.Where(dh => dh.wasChange).ToList();
//collect information about the affected but not finished targets for the player who delivered
var anyProgressItems = new Dictionary <string, object>();
var completedItems = new Dictionary <string, object>();
var itemsWithNoProgress = new Dictionary <string, object>();
var counter = 0;
//process delivery helpers
foreach (var deliveryHelper in deliveryHelpers.Keys)
{
//fully completed targets
if (deliveryHelper.IsCompleted)
{
completedItems.Add("c" + counter++, deliveryHelper.CompletedInfo);
continue;
}
//it progressed, but not finished
if (deliveryHelper.wasChange && deliveryHelper.IsQuantityMissing)
{
anyProgressItems.Add("i" + counter++, deliveryHelper.MissingInfo);
}
//unaffected
if (!deliveryHelper.wasChange)
{
itemsWithNoProgress.Add("u" + counter++, deliveryHelper.MissingInfo);
}
}
//completed info
if (completedItems.Count > 0)
{
result.Add("completedItems", completedItems);
}
//any progress
if (anyProgressItems.Count > 0)
{
result.Add("anyProgress", anyProgressItems);
}
//no progress
if (itemsWithNoProgress.Count > 0)
{
result.Add("noProgress", itemsWithNoProgress);
}
//if any target got completed we send a completed
if (completedItems.Count > 0)
{
deliveryState = DeliverResult.completed;
}
else
{
//no completed targets, was any progression?
if (anyProgressItems.Count > 0)
{
//some targets progressed
deliveryState = DeliverResult.partiallyDelivered;
}
}
//info mission engine
Transaction.Current.OnCommited(() =>
{
foreach (var changedDeliveryHelper in changedDeliveryHelpers)
{
changedDeliveryHelper.EnqueueProgressInfo();
}
if (!isDocked)
{
//container refresh on zone
character.ReloadContainerOnZoneAsync();
}
result.Add(k.items, publicContainer.ToDictionary());
result.Add(k.deliveryState, (int)deliveryState);
result.Add("nofItemsInRobotInventory", itemsFromRobot);
result.Add("nofItemsInPublicContainer", itemsFromPublicContainer);
Logger.Info("Mission delivery result. characterID:" + character.Id + " nofItemsInRobotInventory:" + itemsFromRobot + " nofItemsInPublicContainer:" + itemsFromPublicContainer + " completed targets:" + completedItems.Count + " wasProgress:" + anyProgressItems.Count + " unaffected:" + itemsWithNoProgress.Count + " out of targets:" + interestingTargets.Count + " total affected items:" + itemsAffected + " " + location);
Message.Builder.SetCommand(Commands.MissionDeliver)
.WithData(result)
.ToCharacter(character)
.Send();
});
}
public static bool CheckDistanceBetweenLocations(MissionLocation location1, MissionLocation location2, float range)
{
return(Vector3.Distance(location1.Position, location2.Position) > range);
}
