public void OnChange_Filter(bool isOn)
{
if (!isOn)
{
return;
}
// Find active filter
for (int i = 0; i < m_ToggleFilters.Length; ++i)
{
if (m_ToggleFilters[i].isOn)
{
m_MissionFilter = (MissionFilter)i;
}
}
switch (m_MissionFilter)
{
case MissionFilter.Library: m_StatusBar.SetMessage("These are missions you have downloaded or installed."); break;
case MissionFilter.Standard: m_StatusBar.SetMessage("These are missions that were built with the OP2 mission editor."); break;
case MissionFilter.Custom: m_StatusBar.SetMessage("These are missions that were compiled from custom source code."); break;
case MissionFilter.YourContent: m_StatusBar.SetMessage("These are missions you created."); break;
}
RefreshFilter();
}
/// <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);
}
MissionLibraryItemViewModel(MissionLibraryViewModel library, T model, bool doGrouping = false,
MissionLibraryGroupViewModel group = null)
: base(library, model, @group: group, doGrouping: doGrouping)
{
var groups = doGrouping
? new[] { PropertyGroupDescription }
: null;
Filter = new MissionFilter();
SetupFilterChanged();
UiHelper.TryOnUiThread(() => {
Items.EnableCollectionSynchronization(ItemsLock);
_itemsView =
Items.CreateCollectionView(
new[] {
new SortDescription("IsFavorite", ListSortDirection.Descending),
new SortDescription("FullName", ListSortDirection.Ascending)
},
groups, null, Filter.Handler, true);
_childrenView =
Children.CreateCollectionView(
new[] {
new SortDescription("Model.IsFavorite", ListSortDirection.Descending),
new SortDescription("Model.Name", ListSortDirection.Ascending)
}, null,
null, null, true);
});
Sort = new SortViewModel(ItemsView, Columns, null, RequiredColumns);
SetupGrouping();
}
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);
}
/// <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 PopulateMissions(MissionFilter missionFilter)
{
ClearMissions();
List <MissionData> missions;
// Show local content even if it is no longer provided by the database
if (missionFilter == MissionFilter.Library)
{
missions = new List <MissionData>(CacheDetails.missions);
// Create database lookup table
Dictionary <uint, MissionData> lookupTable = new Dictionary <uint, MissionData>();
foreach (MissionData mission in m_Missions)
{
lookupTable[mission.missionID] = mission;
}
// Replace local mission data with the database data
for (int i = 0; i < missions.Count; ++i)
{
MissionData dbMissionData;
if (!lookupTable.TryGetValue(missions[i].missionID, out dbMissionData))
{
continue;
}
missions[i] = dbMissionData;
}
}
else
{
// Use the database data
missions = new List <MissionData>(m_Missions);
}
foreach (MissionData mission in missions)
{
// Determine is mission is a standard mission
bool hasDLL = mission.fileNames.FirstOrDefault((filename) => filename.IndexOf(".dll", System.StringComparison.OrdinalIgnoreCase) >= 0) != null;
bool hasOPM = mission.fileNames.FirstOrDefault((filename) => filename.IndexOf(".opm", System.StringComparison.OrdinalIgnoreCase) >= 0) != null;
bool isStandardMission = !hasDLL && hasOPM;
//bool isInstalled = File.Exists(CachePath.GetMissionInstalledMetaFilePath(mission.missionID));
bool isDownloaded = File.Exists(CachePath.GetMissionDetailsFilePath(mission.missionID));
bool isYourContent = AppController.localUser.isLoggedIn && AppController.localUser.userID == mission.authorID;
if (missionFilter == MissionFilter.Standard && !isStandardMission)
{
continue;
}
if (missionFilter == MissionFilter.Custom && isStandardMission)
{
continue;
}
if (missionFilter == MissionFilter.Library && !isDownloaded)
{
continue;
}
if (missionFilter == MissionFilter.YourContent && !isYourContent)
{
continue;
}
// Create mission item
GameObject goItem = Instantiate(m_MissionListItemPrefab);
goItem.GetComponent <MissionListItem>().onUpdatedMissionCB += Refresh;
goItem.GetComponent <MissionListItem>().Initialize(mission);
goItem.GetComponent <MissionListItem>().hasAuthorPermissions = AppController.localUser.isLoggedIn && AppController.localUser.userID == mission.authorID;
goItem.GetComponent <MissionListItem>().hasAdminPermissions = AppController.localUser.isLoggedIn && AppController.localUser.isAdmin;
goItem.transform.SetParent(m_MissionContainer);
}
if (missionFilter == MissionFilter.YourContent && AppController.localUser.isLoggedIn)
{
// Create blank mission item
GameObject goItem = Instantiate(m_MissionListItemPrefab);
goItem.GetComponent <MissionListItem>().onUpdatedMissionCB += Refresh;
goItem.GetComponent <MissionListItem>().canEdit = true;
goItem.GetComponent <MissionListItem>().hasAdminPermissions = AppController.localUser.isLoggedIn && AppController.localUser.isAdmin;
goItem.transform.SetParent(m_MissionContainer);
}
OnValueChanged_SearchFilter();
}
/// <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);
}
