public void Dispose()
{
if ((mOpportunities != null) &&
(mSim.OpportunityHistory != null))
{
mSim.OpportunityHistory.mCurrentOpportunities = mOpportunities;
mSim.NeedsOpportunityImport = (true);
if (mSim.CreatedSim != null)
{
if (mSim.CreatedSim.mOpportunityManager == null)
{
mSim.CreatedSim.mOpportunityManager = new OpportunityManager(mSim.CreatedSim);
mSim.CreatedSim.mOpportunityManager.SetupLocationBasedOpportunities();
}
try{
// [NRaas:]Due to an odd bit of coding at the bottom of AcceptOpportunityFromTravel(),
// the expiration time for non-expirying opportunities is checked
foreach (OpportunityHistory.OpportunityExportInfo info in mSim.OpportunityHistory.GetCurrentOpportunities())
{
if (info.ExpirationTime < SimClock.CurrentTime())
{
Opportunity opp = OpportunityManager.GetStaticOpportunity(info.Guid);
if (opp != null)
{
bool requiresTimeout = (false);
switch (opp.Timeout)
{
case Opportunity.OpportunitySharedData.TimeoutCondition.SimDays:
case Opportunity.OpportunitySharedData.TimeoutCondition.SimHours:
case Opportunity.OpportunitySharedData.TimeoutCondition.SimTime:
case Opportunity.OpportunitySharedData.TimeoutCondition.Gig:
case Opportunity.OpportunitySharedData.TimeoutCondition.AfterschoolRecitalOrAudition:
requiresTimeout = (true);
break;
}
if (!requiresTimeout)
{
info.ExpirationTime = SimClock.Add(SimClock.CurrentTime(), TimeUnit.Hours, 1);
}
}
}
}
mSim.CreatedSim.OpportunityManager.TravelFixup();
}catch (Exception exception) {
// Get stack trace for the exception. with source file information
var st = new StackTrace(exception, true);
// Get the top stack frame
var frame = st.GetFrame(0);
// Get the line number from the stack frame
var line = frame.GetFileLineNumber();
Alive.WriteLog(exception.Message + "\n\n" +
exception.StackTrace + "\n\n" +
exception.Source + "\n\n" +
line);
}finally{
}
mSim.NeedsOpportunityImport = (false);
}
}
}
public void Dispose()
{
if ((mOpportunities != null) && (mSim.OpportunityHistory != null))
{
mSim.OpportunityHistory.mCurrentOpportunities = mOpportunities;
mSim.NeedsOpportunityImport = true;
if (mSim.CreatedSim != null)
{
if (mSim.CreatedSim.mOpportunityManager == null)
{
mSim.CreatedSim.mOpportunityManager = new OpportunityManager(mSim.CreatedSim);
mSim.CreatedSim.mOpportunityManager.SetupLocationBasedOpportunities();
}
try
{
// Due to an odd bit of coding at the bottom of AcceptOpportunityFromTravel(),
// the expiration time for non-expirying opportunities is checked
foreach (OpportunityHistory.OpportunityExportInfo info in mSim.OpportunityHistory.GetCurrentOpportunities())
{
if (info.ExpirationTime < SimClock.CurrentTime())
{
Opportunity opp = OpportunityManager.GetStaticOpportunity(info.Guid);
if (opp != null)
{
bool requiresTimeout = false;
switch (opp.Timeout)
{
case Opportunity.OpportunitySharedData.TimeoutCondition.SimDays:
case Opportunity.OpportunitySharedData.TimeoutCondition.SimHours:
case Opportunity.OpportunitySharedData.TimeoutCondition.SimTime:
case Opportunity.OpportunitySharedData.TimeoutCondition.Gig:
case Opportunity.OpportunitySharedData.TimeoutCondition.AfterschoolRecitalOrAudition:
requiresTimeout = true;
break;
}
if (!requiresTimeout)
{
info.ExpirationTime = SimClock.Add(SimClock.CurrentTime(), TimeUnit.Hours, 1);
}
}
}
}
mSim.CreatedSim.OpportunityManager.TravelFixup();
}
catch (Exception e)
{
Common.Exception(mSim, e);
}
mSim.NeedsOpportunityImport = false;
}
}
}
public static bool Perform(SimDescription me, OpportunityNames guid)
{
Opportunity opportunity = null;
GenericManager <OpportunityNames, Opportunity, Opportunity> .sDictionary.TryGetValue((ulong)guid, out opportunity);
Repeatability origRepeatability = Repeatability.Undefined;
if (opportunity != null)
{
origRepeatability = opportunity.RepeatLevel;
opportunity.mSharedData.mRepeatLevel = Repeatability.Always;
}
try
{
me.Household.mCompletedHouseholdOpportunities.Remove((ulong)guid);
if (opportunity.IsLocationBased)
{
List <Lot> alreadyChosenLots = new List <Lot>();
foreach (ulong lotId in OpportunityManager.sLocationBasedOpportunities.Values)
{
Lot lot = LotManager.GetLot(lotId);
if (lot == null)
{
continue;
}
alreadyChosenLots.Add(lot);
}
Lot lotTarget = OpportunityManager.GetLotTarget(opportunity, alreadyChosenLots);
if (lotTarget != null)
{
lotTarget.AddLocationBasedOpportunity(opportunity.EventDay, opportunity.EventStartTime, opportunity.EventEndTime, opportunity.Guid);
alreadyChosenLots.Add(lotTarget);
}
}
return(me.CreatedSim.OpportunityManager.AddOpportunityNow(guid, true, false));
}
finally
{
if (opportunity != null)
{
opportunity.mSharedData.mRepeatLevel = origRepeatability;
}
}
}
public override void OnPreLoad()
{
Overwatch.Log(GetTitlePrefix());
Opportunity opportunity = OpportunityManager.GetStaticOpportunity(OpportunityNames.EP7_FortuneTellerCareer_HelpInvestigation_Police);
if (opportunity != null)
{
if ((opportunity.SharedData.mRequirementList == null) || (opportunity.SharedData.mRequirementList.Count == 0))
{
opportunity.SharedData.mRequirementList = new System.Collections.ArrayList();
// FortuneTeller career requirement
Opportunity.OpportunitySharedData.RequirementInfo info = new Opportunity.OpportunitySharedData.RequirementInfo();
info.mType = RequirementType.Career;
info.mGuid = (ulong)OccupationNames.FortuneTeller;
info.mMinLevel = 1;
info.mMaxLevel = 10;
opportunity.SharedData.mRequirementList.Add(info);
// Police Station requirement
info = new Opportunity.OpportunitySharedData.RequirementInfo();
info.mType = RequirementType.WorldHasRabbitHoleType;
info.mGuid = (ulong)RabbitHoleType.PoliceStation;
opportunity.SharedData.mRequirementList.Add(info);
}
}
foreach (OpportunityNames opp in new OpportunityNames[] { OpportunityNames.EP9_Academics_StudyAtHome, OpportunityNames.EP9_Academics_StudyAtLibrary, OpportunityNames.EP9_Academics_StudyAtQuad, OpportunityNames.EP9_Academics_StudyAtStudentUnion })
{
opportunity = OpportunityManager.GetStaticOpportunity(opp);
if (opportunity != null)
{
if ((opportunity.SharedData.mRequirementList == null) || (opportunity.SharedData.mRequirementList.Count == 0))
{
opportunity.SharedData.mRequirementList = new System.Collections.ArrayList();
// University Student career requirement
Opportunity.OpportunitySharedData.RequirementInfo info = new Opportunity.OpportunitySharedData.RequirementInfo();
info.mType = RequirementType.Career;
info.mGuid = (ulong)OccupationNames.AcademicCareer;
info.mMinLevel = 1;
info.mMaxLevel = 1;
opportunity.SharedData.mRequirementList.Add(info);
}
}
}
}
private static bool CheckAllRequirements(Sim s, Opportunity op, OpportunityNames lastOpName, ref string msg)
{
Opportunity.OpportunitySharedData sharedData = op.SharedData;
WorldName mTargetWorldRequired = sharedData.mTargetWorldRequired;
WorldName currentWorld = GameUtils.GetCurrentWorld();
if (mTargetWorldRequired == WorldName.SunsetValley)
{
mTargetWorldRequired = s.SimDescription.HomeWorld;
}
if ((mTargetWorldRequired == currentWorld) || (mTargetWorldRequired == WorldName.Undefined))
{
foreach (Opportunity.OpportunitySharedData.RequirementInfo info in sharedData.mRequirementList)
{
if (info.mType == RequirementType.OpportunityComplete)
{
OpportunityNames mGuid = (OpportunityNames)info.mGuid;
if (lastOpName == mGuid)
{
continue;
}
}
if (!op.CheckRequirement(info, s, sharedData))
{
msg += Common.NewLine + " Failure: " + info.mType;
return(false);
}
}
}
OpportunityNames mCompletionTriggerOpportunity = sharedData.mCompletionTriggerOpportunity;
if (mCompletionTriggerOpportunity != OpportunityNames.Undefined)
{
Opportunity staticOpportunity = OpportunityManager.GetStaticOpportunity(mCompletionTriggerOpportunity);
if ((staticOpportunity != null) && !op.CheckAllRequirements(s, staticOpportunity, sharedData.mGuid))
{
msg += Common.NewLine + " Failure: B";
return(false);
}
}
return(true);
}
public void Execute(IServiceProvider serviceProvider)
{
var context = serviceProvider.GetContext();
var targetOpp = context.target();
if (!IsValidEvent(targetOpp))
{
return;
}
var postImage = context.postimage();
var crmSvc = serviceProvider.CreateOrganizationService(context.UserId);
var opportunityManager = new OpportunityManager(postImage, crmSvc);
var contractManager = new ContractManager(crmSvc);
var contractId = contractManager.CreateContract(postImage);
opportunityManager.SetQualifiedContract(postImage, contractId);
var opportunityProducts = opportunityManager.RetrieveProducts();
contractManager.CreateProducts(opportunityProducts, contractId);
}
public override void RemoveAllIncompleteListeners()
{
base.RemoveAllIncompleteListeners();
if ((IsTargetDeleted()) && (!mKilled))
{
SimDescription sim = mSuspendedSim;
if (TargetObject is Sim)
{
sim = (TargetObject as Sim).SimDescription;
}
if (TargetDead(sim))
{
OpportunityNames names;
OnCompletion(out names);
if (names != OpportunityNames.Undefined)
{
OpportunityManager.GetStaticOpportunity(names);
OpportunityManager.OpportunityPropagateInfo item = null;
OpportunityManager.OpportunityPropagateInfo info2 = null;
item = new OpportunityManager.OpportunityPropagateInfo(SourceObject, SourceData, SourceType, CustomSource, OriginalSource);
info2 = new OpportunityManager.OpportunityPropagateInfo(TargetObject, TargetData, TargetType, CustomTarget, OriginalTarget);
List <OpportunityNames> list8 = new List <OpportunityNames>(ParentOpportunities);
list8.Add(Guid);
Opportunity opportunity3;
if (this.Actor.OpportunityManager.AddOpportunityNow(names, item, info2, list8, !TriggerQuietly, out opportunity3))
{
opportunity3.WorldStartedIn = WorldStartedIn;
}
}
}
}
}
public DreamStore(Sim sim, bool initialStore, bool simpleRetain)
{
mInitialStore = initialStore;
mSim = sim.SimDescription;
mDnPExportData = null;
bool storeDnP = false;
if ((sim.mDreamsAndPromisesManager != null) &&
(sim.DreamsAndPromisesManager.mPromiseNodes != null))
{
foreach (ActiveDreamNode node in sim.DreamsAndPromisesManager.mPromiseNodes)
{
if (node != null)
{
storeDnP = true;
break;
}
}
}
if (storeDnP)
{
OnLoadFixup(sim, false);
if (simpleRetain)
{
mDnpManager = sim.DreamsAndPromisesManager;
sim.mDreamsAndPromisesManager = null;
}
else
{
try
{
mDnPExportData = new DnPExportData(mSim);
sim.NullDnPManager();
}
catch (Exception e)
{
Common.Exception(mSim, e);
}
}
}
if (sim.HasOpportunity())
{
foreach (Opportunity opp in sim.OpportunityManager.List)
{
if (mSim.OpportunityHistory.GetCurrentOpportunity(opp.OpportunityCategory) == null)
{
mSim.OpportunityHistory.AddCurrentOpportunity(opp.OpportunityCategory, opp.Guid, null, opp.TargetObject as Sim, opp.ParentOpportunities, opp.TargetInteractionNumberItemsRequiredList(), opp.Name, opp.Description, opp.DeadlineString);
}
}
Corrections.CleanupOpportunities(mSim, false, null);
if (simpleRetain)
{
mOpportunityManager = sim.OpportunityManager;
}
else
{
mOppStore = new OpportunityStore(sim.SimDescription, true);
}
sim.mOpportunityManager = null;
}
else
{
mSim.NeedsOpportunityImport = false;
}
}
public DreamStore(Sim sim, bool initialStore, bool simpleRetain)
{
mInitialStore = initialStore;
mSim = sim.SimDescription;
mDnPExportData = null;
bool storeDnP = (false);
if ((sim.mDreamsAndPromisesManager != null) &&
(sim.DreamsAndPromisesManager.mPromiseNodes != null))
{
foreach (ActiveDreamNode node in sim.DreamsAndPromisesManager.mPromiseNodes)
{
if (node != null)
{
storeDnP = (true);
break;
}
}
}
if (storeDnP)
{
OnLoadFixup(sim, false);
if (simpleRetain)
{
mDnpManager = sim.DreamsAndPromisesManager;
sim.mDreamsAndPromisesManager = null;
}
else
{
try{
mDnPExportData = new DnPExportData(mSim);
sim.NullDnPManager();
}catch (Exception exception) {
// Get stack trace for the exception. with source file information
var st = new StackTrace(exception, true);
// Get the top stack frame
var frame = st.GetFrame(0);
// Get the line number from the stack frame
var line = frame.GetFileLineNumber();
Alive.WriteLog(exception.Message + "\n\n" +
exception.StackTrace + "\n\n" +
exception.Source + "\n\n" +
line);
}finally{
}
}
}
if (sim.HasOpportunity())
{
foreach (Opportunity opp in sim.OpportunityManager.List)
{
if (mSim.OpportunityHistory.GetCurrentOpportunity(opp.OpportunityCategory) == null)
{
mSim.OpportunityHistory.AddCurrentOpportunity(opp.OpportunityCategory,
opp.Guid, null,
opp.TargetObject as Sim,
opp.ParentOpportunities,
opp.TargetInteractionNumberItemsRequiredList(),
opp.Name,
opp.Description,
opp.DeadlineString);
}
}
Alive.ResetClearSimTask.
CleanupOpportunities(mSim, false);
if (simpleRetain)
{
mOpportunityManager = sim.OpportunityManager;
}
else
{
mOppStore = new OpportunityStore(sim.SimDescription, true);
}
sim.mOpportunityManager = null;
}
else
{
mSim.NeedsOpportunityImport = false;
}
}
public override bool Run()
{
try
{
if (!Actor.Inventory.Contains(Target))
{
if (!Actor.RouteToObjectRadiusAndCheckInUse(Target, 0.7f))
{
return(false);
}
StandardEntry();
BeginCommodityUpdates();
Actor.PlaySoloAnimation("a2o_object_genericSwipe_x", true);
if (!Actor.Inventory.TryToAdd(Target))
{
EndCommodityUpdates(false);
StandardExit();
return(false);
}
}
else
{
StandardEntry();
BeginCommodityUpdates();
}
SocialJigTwoPerson person = GlobalFunctions.CreateObjectOutOfWorld(SocialJig.SocialJigMedatorNames.SocialJigTwoPerson.ToString()) as SocialJigTwoPerson;
person.RegisterParticipants(Actor, null);
Sim createdSim = null;
try
{
World.FindGoodLocationParams fglParams = new World.FindGoodLocationParams(Actor.Position);
fglParams.BooleanConstraints |= FindGoodLocationBooleans.Routable;
if (GlobalFunctions.PlaceAtGoodLocation(person, fglParams, true))
{
Route r = Actor.CreateRoute();
r.PlanToSlot(person, person.GetSlotForActor(Actor, true));
r.DoRouteFail = true;
if (Actor.DoRoute(r))
{
bool paramValue = false;
mSummonGenieBroadcast = new ReactionBroadcaster(Actor, kSummonGenieBroadcastParams, SummonGenieBroadcastCallback);
Sims3.Gameplay.Gameflow.SetGameSpeed(Sims3.Gameplay.Gameflow.GameSpeed.Normal, Sims3.Gameplay.Gameflow.SetGameSpeedContext.Gameplay);
if (Target.mGenieDescription == null)
{
Target.mGenieDescription = OccultGenie.CreateGenie(Actor, Target);
createdSim = Target.mGenieDescription.CreatedSim;
EventTracker.SendEvent(EventTypeId.kCleanLamp, Actor, Target);
paramValue = true;
}
else
{
createdSim = Target.mGenieDescription.Instantiate(Vector3.OutOfWorld, false);
OccultGenie occultType = null;
DateAndTime previousDateAndTime = SimClock.CurrentTime();
do
{
SpeedTrap.Sleep(0xa);
occultType = createdSim.OccultManager.GetOccultType(OccultTypes.None | OccultTypes.Genie) as OccultGenie;
}while ((occultType == null) && (SimClock.ElapsedTime(TimeUnit.Minutes, previousDateAndTime) < 120f));
if (occultType != null)
{
occultType.SetGenieLampRelations(Actor, createdSim, Target);
}
else
{
createdSim.Destroy();
createdSim = null;
}
}
if (createdSim != null)
{
createdSim.FadeOut(false, false, 0f);
createdSim.GreetSimOnLot(Actor.LotCurrent);
createdSim.AddToWorld();
Slot slotForActor = person.GetSlotForActor(createdSim, false);
createdSim.SetPosition(person.GetSlotPosition(slotForActor));
createdSim.SetForward(person.GetForwardOfSlot(slotForActor));
IGameObject actor = GlobalFunctions.CreateObject("GenieLamp", ProductVersion.EP6, Vector3.OutOfWorld, 0x0, Vector3.UnitZ, null, null);
if (!actor.IsActorUsingMe(Actor))
{
actor.AddToUseList(Actor);
}
EnterStateMachine("GenieLampSummon", "Enter", "x");
SetActor("lamp", actor);
SetParameter("isFirstTime", paramValue);
AnimateSim("Exit");
actor.Destroy();
createdSim.FadeIn();
VisualEffect effect = VisualEffect.Create("ep6GenieAppearSmoke_main");
effect.SetPosAndOrient(createdSim.Position, Vector3.UnitX, Vector3.UnitZ);
effect.SubmitOneShotEffect(VisualEffect.TransitionType.SoftTransition);
OpportunityManager opportunityManager = Actor.OpportunityManager;
if ((opportunityManager != null) && opportunityManager.HasOpportunity(OpportunityNames.EP6_ReleaseGenie_SummonGenie))
{
OccultGenie genie2 = createdSim.OccultManager.GetOccultType(OccultTypes.Genie) as OccultGenie;
if (genie2 == null)
{
createdSim.Destroy();
createdSim = null;
}
else
{
OccultGenieEx.OnFreedFromLamp(genie2, Actor, createdSim, true);
if (opportunityManager.GetLastOpportunity(OpportunityCategory.Special) == OpportunityNames.EP6_ReleaseGenie_SummonGenie)
{
opportunityManager.ClearLastOpportunity(OpportunityCategory.Special);
}
EventTracker.SendEvent(EventTypeId.kGrantedWishToFreeGenie, Actor, Target);
if (Target.InInventory)
{
Actor.Inventory.RemoveByForce(Target);
if (Target.IsOnHandTool)
{
Target.RemoveFromWorld();
}
}
else
{
Target.RemoveFromWorld();
}
EnterStateMachine("FreeTheGenie", "Enter", "x");
SetActor("x", createdSim);
AnimateSim("Exit");
}
}
else
{
Target.mGenieSocializingEvent = EventTracker.AddListener(EventTypeId.kSocialInteraction, OnSocialization);
Target.CheckGenieReturnToLamp = createdSim.AddAlarmRepeating(1f, TimeUnit.Minutes, Target.CheckGenieReturnToLampCallback, "Genie Check to return to lamp", AlarmType.AlwaysPersisted);
Target.mTimeSinceLastSocialWithGenie = SimClock.CurrentTime();
}
}
}
}
}
finally
{
person.Destroy();
}
EndCommodityUpdates(true);
StandardExit(createdSim == null, createdSim == null);
return(true);
}
catch (ResetException)
{
throw;
}
catch (Exception e)
{
Common.Exception(Actor, Target, e);
return(false);
}
}
public static bool CleanupOpportunities(SimDescription sim, bool clean, Logger log)
{
if (sim.OpportunityHistory == null)
{
return(false);
}
if (sim.OpportunityHistory.mCurrentOpportunities == null)
{
return(false);
}
OpportunityManager manager = null;
if (sim.CreatedSim != null)
{
manager = sim.CreatedSim.OpportunityManager;
}
for (int i = 0; i < sim.OpportunityHistory.mCurrentOpportunities.Length; i++)
{
OpportunityHistory.OpportunityExportInfo info = sim.OpportunityHistory.mCurrentOpportunities[i];
if (info == null)
{
if (manager != null)
{
info = new OpportunityHistory.OpportunityExportInfo();
sim.OpportunityHistory.mCurrentOpportunities[i] = info;
if (log != null)
{
log(" OpportunityExportInfo Created " + sim.FullName);
}
}
}
else if (clean)
{
if (manager == null)
{
sim.OpportunityHistory.mCurrentOpportunities[i] = null;
if (log != null)
{
log(" OpportunityExportInfo Removed " + sim.FullName);
}
}
}
if (info == null)
{
continue;
}
if (info.ListenerStates == null)
{
info.ListenerStates = new EventListenerExportInfo[3];
if (log != null)
{
log(" ListenerState Array Initialized " + sim.FullName);
}
}
for (int index = 0; index < 3; index++)
{
if (info.ListenerStates[index] == null)
{
info.ListenerStates[index] = new EventListenerExportInfo();
if (log != null)
{
log(" ListenerState Element Initialized " + sim.FullName);
}
}
}
}
return(true);
}
protected static List <Opportunity> GetAllOpportunities(Sim sim, bool singleCategory, Dictionary <OpportunityNames, Opportunity> opportunityList)
{
//Common.StringBuilder msg = new Common.StringBuilder("GetAllOpportunities");
List <Opportunity> allOpportunities = new List <Opportunity>();
if (!GameStates.IsOnVacation)
{
CareerManager manager = sim.CareerManager;
if (manager != null)
{
for (int i = 0; i < 2; i++)
{
Sims3.Gameplay.Careers.Career career = manager.Occupation as Sims3.Gameplay.Careers.Career;
if (i == 1)
{
career = manager.School;
}
if (career == null)
{
continue;
}
foreach (Sims3.Gameplay.Careers.Career.EventDaily daily in career.CareerEventList)
{
Sims3.Gameplay.Careers.Career.EventOpportunity oppEvent = daily as Sims3.Gameplay.Careers.Career.EventOpportunity;
if (oppEvent == null)
{
continue;
}
if (opportunityList.ContainsKey(oppEvent.mOpportunity))
{
continue;
}
Opportunity opportunity = OpportunityManager.GetStaticOpportunity(oppEvent.mOpportunity);
if (opportunity == null)
{
continue;
}
opportunityList.Add(opportunity.Guid, opportunity);
}
}
}
}
foreach (Opportunity opportunity in opportunityList.Values)
{
//msg += Common.NewLine + "A: " + opportunity.Guid;
Repeatability origRepeatability = opportunity.RepeatLevel;
OpportunityNames origTriggerOpp = opportunity.SharedData.mCompletionTriggerOpportunity;
WorldName targetWorldRequired = opportunity.SharedData.mTargetWorldRequired;
try
{
if (!singleCategory)
{
opportunity.mSharedData.mRepeatLevel = Repeatability.Always;
opportunity.mSharedData.mCompletionTriggerOpportunity = OpportunityNames.Undefined;
}
if (opportunity.TargetWorldRequired == WorldName.SunsetValley)
{
if ((singleCategory) && (Common.IsOnTrueVacation()))
{
if (sim.SimDescription.HomeWorld != GameUtils.GetCurrentWorld())
{
continue;
}
}
else
{
opportunity.SharedData.mTargetWorldRequired = WorldName.Undefined;
}
}
else if (opportunity.TargetWorldRequired != WorldName.Undefined)
{
if (opportunity.TargetWorldRequired != GameUtils.GetCurrentWorld())
{
continue;
}
}
if (GameStates.IsOnVacation)
{
bool career = false;
foreach (Opportunity.OpportunitySharedData.RequirementInfo info in opportunity.SharedData.mRequirementList)
{
if (info.mType == RequirementType.Career)
{
career = true;
break;
}
}
if (career)
{
continue;
}
}
//if (IsAvailable(opportunity, sim, ref msg))
if (opportunity.IsAvailable(sim))
{
allOpportunities.Add(opportunity);
}
}
catch (Exception e)
{
Common.DebugException(opportunity.Guid + Common.NewLine + opportunity.Name, e);
}
finally
{
opportunity.mSharedData.mRepeatLevel = origRepeatability;
opportunity.mSharedData.mCompletionTriggerOpportunity = origTriggerOpp;
opportunity.SharedData.mTargetWorldRequired = targetWorldRequired;
}
}
List <Opportunity> allPotentials = new List <Opportunity>();
foreach (Opportunity opportunity in allOpportunities)
{
string name = null;
//msg += Common.NewLine + "B: " + opportunity.Guid;
try
{
if (sim.OpportunityManager.HasOpportunity(opportunity.OpportunityCategory))
{
continue;
}
Opportunity toAdd = opportunity.Clone();
toAdd.Actor = sim;
// EA has coding to spawn the Time Traveler in SetupTargets(), don't do it in that case
if ((toAdd.SharedData.mTargetType != OpportunityTargetTypes.Sim) || (toAdd.SharedData.mTargetData != "TimeTraveler"))
{
if (!sim.OpportunityManager.SetupTargets(toAdd))
{
continue;
}
}
toAdd.SetLocalizationIndex();
name = toAdd.Name;
allPotentials.Add(toAdd);
}
catch (Exception e)
{
Common.DebugException(opportunity.Guid + Common.NewLine + name, e);
}
}
//Common.DebugWriteLog(msg);
return(allPotentials);
}
