void ParseMissionSpriteArray(MissionSet set, List <Sprite> missionSprites)
{
while (missionSprites.Count > 0)
{
Sprite currentSprite = missionSprites[0];
missionSprites.RemoveAt(0);
string currentSide;
string currentSpriteName = SplitSideFromName(currentSprite.name, out currentSide);
int i = 0;
for (i = 0; i < missionSprites.Count; i++)
{
string missionSide;
string missionSpriteName = SplitSideFromName(missionSprites[i].name, out missionSide);
if (missionSpriteName == currentSpriteName && currentSide != missionSide)
{
break;
}
}
if (i < missionSprites.Count)
{
AddMission(set, currentSpriteName, currentSide == "Front" ? currentSprite : missionSprites[i], currentSide == "Back" ? missionSprites[i] : currentSprite);
missionSprites.RemoveAt(i);
}
}
}
private void AddIcon(int houseIndex, MissionSet set, short regionID, string[] unitDescriptions)
{
if (regionID <= 0 || houseIndex < 0 || houseIndex > _iconSprite.Length)
{
return;
}
if (ParentForm is GameForm f)
{
// regionIDs are one-based
int regIndex = regionID - 1;
SpriteBox sp = new SpriteBox();
// Add first
_missionBoxes.Add(sp);
spTerritories.Controls.Add(sp);
sp.BaseImage = _iconSprite[houseIndex];
sp.Click += (o, e) => { AudioEngine.Click(); f.Push(new MissionBriefingScreen(set, unitDescriptions), TransitionStyle.FADE_BLACK); };
float2 iconLoc = _centers[regIndex];
float2 sz = spTerritories.Size.ToFloat2() / _territoryBitmapSize.ToFloat2() * _iconSprite[houseIndex].Size.ToFloat2() * ICON_SCALE;
float2 loc = spTerritories.Size.ToFloat2() * iconLoc / _territoryBitmapSize.ToFloat2() - sz / 2;
sp.Location = loc.ToPoint();
sp.Size = sz.ToSize();
}
}
private async Task <List <MissionSetAzure> > GenerateMissionDependentLinks(MissionSet missionSet, MissionSetAzure missionSetAzure)
{
if (missionSet.Missions == null)
{
return(new List <MissionSetAzure>());
}
var orderedMissionIds =
missionSet.Missions.OrderBy(m => m.Order)
.Where(t => !string.IsNullOrEmpty(t.Mission?.Id))
.Select(m => m.Mission.Id)
.Distinct()
.ToList();
var query = new QueryOptions <Mission>
{
Expand = new List <string> {
"PersonQualities"
},
};
var missions =
(await MissionRepository.GetMissions(query)).Where(m => orderedMissionIds.Contains(m.Id)).ToList();
var validOrderedMissionIds = orderedMissionIds.Where(o => missions.Any(m => m.Id == o));
byte order = 0;
var missionLinks =
validOrderedMissionIds.Select(t => MissionSetAzure.CreateMissionLink(missionSet.Id, t, order++));
var personQualitiesLinks = GeneratePersonQualitiesLinks(missionSet, missions);
var allLinks = missionLinks.Concat(personQualitiesLinks);
FillAgesForMissionSet(missions, missionSetAzure);
await RefreshBackReferencesForMissions(missions, missionSet.Id);
return(allLinks.ToList());
}
/// <summary>
/// Updates the MissionSet.
/// </summary>
/// <param name="missionSet">
/// The MissionSet.
/// </param>
/// <returns>
/// Task{OperationResult}.
/// </returns>
public async Task <OperationResult> UpdateMissionSet(MissionSet missionSet)
{
var relatedEntities =
await
_azureManager.GetEntitiesAsync(new TableQuery <MissionSetAzure>().Where(missionSet.Id.GetFilterById()));
var missionSetAzure = relatedEntities.FirstOrDefault(m => m.IsMissionSetEntity);
if (missionSetAzure == null)
{
return(new OperationResult(OperationResultStatus.Error, "Can't find MissionSet for update"));
}
var updatedMissionSet = missionSet.ToAzureModel();
updatedMissionSet.CopyToTableEntity(missionSetAzure);
var entitiesToDelete = relatedEntities.Where(m => !m.IsMissionSetEntity).ToList();
await ClearBackReferenceForMissionsExcludedFromMissionSet(entitiesToDelete, missionSet);
var entitiesToAdd = await GenerateMissionDependentLinks(missionSet, missionSetAzure);
var entitiesToUpdate = AzureTableExtensions.FilterUpdatableLinks(entitiesToAdd, entitiesToDelete);
entitiesToUpdate.Add(missionSetAzure);
return(await _azureManager.UpdateEntityBatchAsync(entitiesToUpdate, entitiesToAdd, entitiesToDelete));
}
/// <summary>
/// Adds the MissionSet.
/// </summary>
/// <param name="missionSet">
/// The MissionSet.
/// </param>
/// <returns>
/// Task{AddResult}.
/// </returns>
public async Task <IdResult> AddMissionSet(MissionSet missionSet)
{
missionSet.Id = Guid.NewGuid().ToString();
await Task.Factory.StartNew(() => _allMissionsSets.Add(missionSet));
return(new IdResult(missionSet.Id));
}
/// <summary>
/// To the azure model.
/// </summary>
/// <param name="missionSet">The mission set.</param>
/// <returns>MissionSetAzure.</returns>
public static MissionSetAzure ToAzureModel(this MissionSet missionSet)
{
var azureModel = new MissionSetAzure();
missionSet.CopyTo(azureModel);
azureModel.AgeFrom = missionSet.AgeFrom;
azureModel.AgeTo = missionSet.AgeTo;
return(azureModel);
}
public MissionBriefingScreen(MissionSet mission, string[] unitDescriptions = null)
{
InitializeComponent();
Dock = DockStyle.Fill;
spBriefing.TextCacheUpdated += UpdateControls;
_mission = mission;
_unitDesc = unitDescriptions;
_imgSize = spImage.Size;
SetKeyAction(Keys.Escape, () => { if (spBack.Enabled)
{
SpBack_Click(null, null);
}
}, "Return to previous menu");
SetKeyAction(Keys.Left, () => { if (spPrevItem.Enabled)
{
SpPrevItem_Click(null, null);
}
}, "Previous item");
SetKeyAction(Keys.Right, () => { if (spNextItem.Enabled)
{
SpNextItem_Click(null, null);
}
}, "Next item");
SetKeyAction(Keys.Up, () => { if (spPrevPage.Enabled)
{
SpPrevPage_Click(null, null);
}
}, "Previous page");
SetKeyAction(Keys.Down, () => { if (spNextPage.Enabled)
{
SpNextPage_Click(null, null);
}
}, "Next page");
SetKeyAction(Keys.Enter, () => { if (spStart.Enabled)
{
SpStart_Click(null, null);
}
}, "Begin the mission");
SetKeyAction(Keys.D1, () => { if (spEasy.Enabled)
{
SpEasy_Click(null, null);
}
}, "Set Easy Difficulty");
SetKeyAction(Keys.D2, () => { if (spNormal.Enabled)
{
SpNormal_Click(null, null);
}
}, "Set Normal Difficulty");
SetKeyAction(Keys.D3, () => { if (spHard.Enabled)
{
SpHard_Click(null, null);
}
}, "Set Hard Difficulty");
}
private async Task ClearBackReferenceForMissionsExcludedFromMissionSet(
List <MissionSetAzure> linksToBeDeleted,
MissionSet missionSet)
{
var currentMissions = linksToBeDeleted.Where(l => l.IsMissionLink).Select(l => l.MissionId);
var includedMissions =
(missionSet.Missions ?? new List <MissionWithOrder>()).Select(m => m.Mission.Id);
var missionsToClearBackReference = currentMissions.Where(m => !includedMissions.Contains(m)).ToList();
await ClearBackReference(missionsToClearBackReference);
}
private void SetMission(MissionSet mission, string[] unitDescriptions = null)
{
_mission = mission;
_unitDesc = unitDescriptions;
spTitle.Text = _mission.Info.Name;
_briefingItems = GetBriefings();
UpdateDifficulty(_mission.Difficulty);
UpdateItem();
}
/// <summary>
/// Updates the MissionSet.
/// </summary>
/// <param name="missionSet">
/// The MissionSet.
/// </param>
/// <returns>
/// Task{OperationResult}.
/// </returns>
public async Task <OperationResult> UpdateMissionSet(MissionSet missionSet)
{
var existingMission = await Task.FromResult(_allMissionsSets.FirstOrDefault(ms => ms.Id == missionSet.Id));
if (existingMission == null)
{
return(OperationResult.NotFound);
}
missionSet.CopyTo(existingMission);
return(new OperationResult(OperationResultStatus.Success));
}
public void LaunchGame(MissionSet missionSet)
{
if (!Handle(_mount.MountFiles(missionSet.Source)))
{
return;
}
if (!Handle(_mount.WriteSpawnFile(missionSet)))
{
return;
}
_gameProcess = _mount.RunSpawn(GAME_LOG_OUT, GAME_LOG_ERR);
}
public Vision2Client(Vision2Options options, Vision2Token token)
{
System.Net.ServicePointManager.SecurityProtocol = System.Net.SecurityProtocolType.Tls12 | System.Net.SecurityProtocolType.Tls11;
_missionSet = new MissionSet(token, options.ApiUrl);
_fundSet = new FundSet(token, options.ApiUrl);
_individualSet = new IndividualSet(token, options.ApiUrl);
_volunteerParticipantSet = new VolunteerParticipantSet(token, options.ApiUrl);
_volunteerOpportunitySet = new VolunteerOpportunitySet(token, options.ApiUrl);
_volunteerRoleSet = new VolunteerRoleSet(token, options.ApiUrl);
_paymentSet = new PaymentSet(token, options.ApiUrl);
_designationSet = new DesignationSet(token, options.ApiUrl);
}
/// <summary>
/// Froms the azure model.
/// </summary>
/// <param name="azureModel">The azure model.</param>
/// <returns>MissionSet.</returns>
public static MissionSet FromAzureModel(this MissionSetAzure azureModel)
{
if (azureModel == null)
{
return(null);
}
var domainModel = new MissionSet();
azureModel.CopyTo(domainModel);
domainModel.AgeFrom = (byte?)azureModel.AgeFrom;
domainModel.AgeTo = (byte?)azureModel.AgeTo;
return(domainModel);
}
public CampaignStageInfo GetStage(MissionSet set)
{
for (int i = 0; i < Stages.Length; i++)
{
for (int m = 0; m < Stages[i].Missions.Length; m++)
{
if (Stages[i].Missions[m].MissionID == set.Identifier.ID)
{
return(Stages[i]);
}
}
}
return(default);
void AddMission(MissionSet set, string name, Sprite front, Sprite back)
{
Assert.IsNotNull(front);
Assert.IsNotNull(back);
List <Card> setCards;
if (!missions.TryGetValue(set, out setCards))
{
setCards = new List <Card>();
missions.Add(set, setCards);
}
setCards.Add(new Card(name, front, back));
}
internal static MissionSetUI ConvertToUi(this MissionSet missionSetDomain)
{
if (missionSetDomain == null)
{
return(null);
}
return(new MissionSetUI
{
Id = missionSetDomain.Id,
Name = missionSetDomain.Name,
Missions =
missionSetDomain.Missions?.OrderBy(m => m.Order)
.Select(p => p.Mission.Id).ToList(),
});
}
/// <summary>
/// Adds the MissionSet.
/// </summary>
/// <param name="missionSet">
/// The MissionSet.
/// </param>
/// <returns>
/// Task{AddResult}.
/// </returns>
public async Task <IdResult> AddMissionSet(MissionSet missionSet)
{
missionSet.Id = Guid.NewGuid().ToString("N");
var azureModel = missionSet.ToAzureModel();
var missionLinks = await GenerateMissionDependentLinks(missionSet, azureModel);
var batch = new List <MissionSetAzure> {
azureModel
};
if (missionLinks.Any())
{
batch.AddRange(missionLinks);
}
return(await _azureManager.AddEntityBatchAsync(batch));
}
private IEnumerable <MissionSetAzure> GeneratePersonQualitiesLinks(
MissionSet missionSet,
IEnumerable <Mission> missions)
{
var allPersonQualitiesGrouped =
missions.Where(m => m.PersonQualities != null)
.SelectMany(m => m.PersonQualities)
.GroupBy(p => p.PersonQualityId);
var personQualitiesLinks =
allPersonQualitiesGrouped.Select(
g =>
MissionSetAzure.CreateLinkToPersonQuality(
missionSet.Id,
g.Key,
g.Sum(p => p.Score)));
return(personQualitiesLinks);
}
public MountResult WriteSpawnFile(MissionSet mission)
{
SpawnerFile spfile = new SpawnerFile
{
Scenario = RESERVED_MISSION_NAME,
MySideID = (int)mission.Info.House,
MissionNumber = mission.Info.MissionNumber,
DifficultyLevel = (int)mission.Difficulty,
Seed = new Random().Next(2147483647)
};
try
{
spfile.WriteToFile(SpawnerPath);
}
catch (Exception ex)
{
return(new MountResult(MountErrorType.SPAWNER_WRITE_ERROR, Resource.Strings.MountError_SPAWNER_WRITE_ERROR, ex));
}
return(new MountResult(MountErrorType.SUCCESS));
}
internal MissionSet ConvertToDomain()
{
var missionSet = new MissionSet
{
// Common
Id = Id,
Name = Name,
};
if (Missions != null)
{
var order = (byte)0;
var missionsWithScores =
Missions.Distinct().Select(m => new MissionWithOrder {
Mission = new Mission(m), Order = order++
}).ToList();
missionSet.Missions = missionsWithScores;
}
return(missionSet);
}
/// <summary>
/// Adds the new MissionSet.
/// </summary>
/// <param name="misionSet">The mision.</param>
/// <returns>Task{AddResult}.</returns>
public Task <IdResult> AddNewMissionSet(MissionSet misionSet)
{
return(_missionSetRepository.AddMissionSet(misionSet));
}
/// <summary>
/// Updates the MissionSet.
/// </summary>
/// <param name="mision">The mision.</param>
/// <returns>Task{OperationResult}.</returns>
public Task <OperationResult> UpdateMissionSet(MissionSet mision)
{
return(_missionSetRepository.UpdateMissionSet(mision));
}
public void SetSelectedMissionSet(MissionSet selectedMissionSet) => this.selectedMissionSet = selectedMissionSet;
public List <string> GetMissionNames(MissionSet set)
{
return(missions[set].Select(mission => mission.Name).ToList());
}
public Card GetMissionCard(MissionSet set, string name)
{
return(missions[set].FirstOrDefault(card => card.Name == name));
}
void Awake()
{
mission = GameObject.Find("MissionGuide").GetComponent <MissionLocationFlagController>();
elemission = GameObject.Find("spfloorPlane").GetComponent <MissionSet>();
}
public MountResult ImportMissions <T>(string directoryPath, out Registry <T, MissionSet[]> sortedMissions, Func <MissionSet, T> filter)
{
sortedMissions = new Registry <T, MissionSet[]>();
Registry <T, List <MissionSet> > temp = new Registry <T, List <MissionSet> >();
if (directoryPath == null || !Directory.Exists(directoryPath) || File.Exists(directoryPath))
{
return(new MountResult(MountErrorType.INVALID_DIRECTORY, Resource.Strings.MountError_INVALID_DIRECTORY.F(directoryPath)));
}
List <string> errorList = new List <string>();
foreach (string p in Directory.GetFiles(directoryPath, "*" + RULESFILE_EXT, SearchOption.AllDirectories))
{
try
{
string dir = Path.GetDirectoryName(p);
string name = Path.GetFileNameWithoutExtension(p);
string sMap = MAPFILE_FORMAT.F(dir, name);
string sMis = MISFILE_FORMAT.F(dir, name);
string sMod = MODFILE_FORMAT.F(dir, name);
// Ignore the set if either the map or the mis file does not exist
if (!File.Exists(sMap) || !File.Exists(sMis))
{
continue;
}
// The mod file is optional, exclude it if not present
if (!File.Exists(sMod))
{
sMod = null;
}
MissionSourceInfo srcInfo = new MissionSourceInfo(sMap, sMis, p, sMod);
// load rules file into memory (if some error occurs, ignore this set)
MapRulesFile rulf = new MapRulesFile();
try
{
rulf.ReadFromFile(p);
MissionInfo misInfo = rulf.RetrieveInfo();
MissionSet set = new MissionSet(misInfo, srcInfo);
T t = filter(set);
if (t != null)
{
if (temp.Contains(t))
{
temp[t].Add(set);
}
else
{
temp.Add(t, new List <MissionSet> {
set
});
}
}
}
catch
{
errorList.Add(p);
continue;
}
}
catch
{
errorList.Add(p);
continue;
}
}
foreach (T t in temp.GetKeys())
{
sortedMissions.Put(t, temp[t].ToArray());
}
if (errorList.Count > 0)
{
return(new MountResult(MountErrorType.PARTIAL_ERROR, Resource.Strings.MountError_PARTIAL_ERROR.F(errorList.Count)));
}
return(new MountResult(MountErrorType.SUCCESS));
}
