public void FindBySQLAssociatedObject()
{
ISession s = OpenSession();
Category c = new Category();
c.Name = "NAME";
Assignable assn = new Assignable();
assn.Id = "i.d.";
assn.Categories = new List <Category> {
c
};
c.Assignable = assn;
s.Save(assn);
s.Flush();
s.Close();
s = OpenSession();
IList list = s.CreateSQLQuery("select {category.*} from Category {category}")
.AddEntity("category", typeof(Category)).List();
Assert.AreEqual(1, list.Count, "Count differs");
s.Delete("from Assignable");
s.Delete("from Category");
s.Flush();
s.Close();
}
public Assignables[] GetAssignees(Room room)
{
if (room == null)
{
return(new Assignables[0]);
}
RoomType roomType = room.roomType;
if (roomType.primary_constraint == null)
{
return(new Assignables[0]);
}
List <Assignables> list = new List <Assignables>();
foreach (KPrefabID building in room.buildings)
{
if (!((UnityEngine.Object)building == (UnityEngine.Object)null) && roomType.primary_constraint.building_criteria(building))
{
Assignable component = building.GetComponent <Assignable>();
if (component.assignee != null)
{
foreach (Ownables owner in component.assignee.GetOwners())
{
if (!list.Contains(owner))
{
list.Add(owner);
}
}
}
}
}
return(list.ToArray());
}
public override void Assign(IAssignableIdentity new_assignee)
{
if (new_assignee != assignee)
{
if (base.slot != null && new_assignee is MinionIdentity)
{
new_assignee = (new_assignee as MinionIdentity).assignableProxy.Get();
}
if (base.slot != null && new_assignee is StoredMinionIdentity)
{
new_assignee = (new_assignee as StoredMinionIdentity).assignableProxy.Get();
}
if (new_assignee is MinionAssignablesProxy)
{
Ownables soleOwner = new_assignee.GetSoleOwner();
Ownables component = soleOwner.GetComponent <Ownables>();
AssignableSlotInstance slot = component.GetSlot(base.slot);
if (slot != null)
{
Assignable assignable = slot.assignable;
if ((Object)assignable != (Object)null)
{
assignable.Unassign();
}
}
}
base.Assign(new_assignee);
}
}
public void UpdateBed()
{
Ownables soleOwner = base.sm.masterTarget.Get(base.smi).GetComponent <MinionIdentity>().GetSoleOwner();
Assignable assignable = null;
Assignable assignable2 = soleOwner.GetAssignable(Db.Get().AssignableSlots.MedicalBed);
if ((Object)assignable2 != (Object)null && assignable2.CanAutoAssignTo(base.sm.masterTarget.Get(base.smi).GetComponent <MinionIdentity>().assignableProxy.Get()))
{
assignable = assignable2;
}
else
{
assignable = soleOwner.GetAssignable(Db.Get().AssignableSlots.Bed);
if ((Object)assignable == (Object)null)
{
assignable = soleOwner.AutoAssignSlot(Db.Get().AssignableSlots.Bed);
if ((Object)assignable != (Object)null)
{
AssignableReachabilitySensor sensor = GetComponent <Sensors>().GetSensor <AssignableReachabilitySensor>();
sensor.Update();
}
}
}
base.smi.sm.bed.Set(assignable, base.smi);
}
public AssignStatement(Assignable to, Expression from)
{
To = to;
From = from;
To.Parent = this;
From.Parent = this;
}
private void SetWorkerDestination(Worker w, Assignable a)
{
if (w.SetDestination(a))
{
SelectionManager.GetInstance().Deselect(w.GetComponent <Selectable>());
}
}
private static bool ShouldTransfer(Assignable assignable, Equipment equipment)
{
var resume = equipment?.GetTargetGameObject()?.GetComponent <MinionResume>();
var durability = assignable?.GetComponent <Durability>();
return(durability != null && durability.IsTrueWornOut(resume));
}
public AssignStatement(Assignable to, Expression from)
{
To = to;
From = from;
To.Parent = this;
From.Parent = this;
}
public void FindAvailableMedicalBed(Navigator navigator)
{
Clinic clinic = null;
AssignableSlot clinic2 = Db.Get().AssignableSlots.Clinic;
Ownables soleOwner = gameObject.GetComponent <MinionIdentity>().GetSoleOwner();
AssignableSlotInstance slot = soleOwner.GetSlot(clinic2);
if ((UnityEngine.Object)slot.assignable == (UnityEngine.Object)null)
{
Assignable assignable = soleOwner.AutoAssignSlot(clinic2);
if ((UnityEngine.Object)assignable != (UnityEngine.Object)null)
{
clinic = assignable.GetComponent <Clinic>();
}
}
else
{
clinic = slot.assignable.GetComponent <Clinic>();
}
if ((UnityEngine.Object)clinic != (UnityEngine.Object)null && navigator.CanReach(clinic))
{
base.smi.sm.clinic.Set(clinic.gameObject, base.smi);
base.smi.GoTo(base.smi.sm.incapacitation_root.rescue.waitingForPickup);
}
}
public void OnLoadDependencies(object savedData)
{
var data = (Dictionary <string, object>)savedData;
var houseIndex = (int?)data["house"];
House = houseIndex.HasValue ? SaveManager.GetInstance().FindLoadedInstanceBySaveIndex(houseIndex.Value).GetComponent <Housing>() : null;
assignedLocation = (int)data["assignedLocation"] == -1 ? null : SaveManager.GetInstance().FindLoadedInstanceBySaveIndex((int)data["assignedLocation"]).GetComponent <Assignable>();
}
private static void TryTransfer(Assignable assignable, SuitLocker.ReturnSuitWorkable workable, Equipment equipment)
{
var storage = workable?.GetComponent <Storage>();
if (ShouldTransfer(assignable, equipment))
{
Transfer(assignable, storage);
}
}
public void SetDestination(Vector3 destination)
{
if (assignedLocation != null)
{
assignedLocation.RemoveWorker(this);
assignedLocation = null;
}
SetWalkerDestination(destination);
}
public void Assign(Assignable assignable)
{
if (!((Object)this.assignable == (Object)assignable))
{
Unassign(false);
this.assignable = assignable;
assignables.Trigger(-1585839766, this);
}
}
/// <summary>
/// Determines if an expression of the source type can be assigned to a parameter or other input of the target type.
/// </summary>
/// <param name="sourceType">The source type.</param>
/// <param name="targetType">The target type.</param>
/// <param name="allowedCasts">Indicates what type of cast may be permitted.</param>
/// <param name="priority">The priority.</param>
/// <returns></returns>
internal static Assignable IsAssignable(ExprType sourceType, ExprType targetType, CastType allowedCasts, out int priority)
{
priority = 0;
// Target requires a literal
if (targetType.Constant && !sourceType.Constant)
{
return(Assignable.No);
}
Assignable result = Assignable.Yes;
// IsList mismatch
if (sourceType.IsList && targetType.DisallowList)
{
return(Assignable.No);
}
// Entity type
if (sourceType.EntityTypeId != targetType.EntityTypeId)
{
result = Assignable.RequiresCast;
}
// Exact match of type
if (sourceType.Type == targetType.Type)
{
return(result);
}
if (sourceType.Type == DataType.None)
{
return(Assignable.RequiresCast);
}
// Check cast
result = Assignable.No;
priority = int.MaxValue;
foreach (var cast in LanguageManager.Instance.Casts)
{
if (cast.FromType != sourceType.Type || cast.ToType != targetType.Type)
{
continue;
}
// Check if we can do this cast
// (Implicit casts can implicitly be used as explicit casts)
if (cast.CastType == CastType.Implicit && allowedCasts == CastType.Implicit || allowedCasts == CastType.Explicit)
{
priority = Math.Min(priority, cast.Priority);
result = Assignable.RequiresCast;
}
}
return(result);
}
public override void ClearTarget()
{
if (targetAssignableSubscriptionHandle != -1 && (UnityEngine.Object)targetAssignable != (UnityEngine.Object)null)
{
targetAssignable.Unsubscribe(targetAssignableSubscriptionHandle);
targetAssignableSubscriptionHandle = -1;
}
targetAssignable = null;
Components.LiveMinionIdentities.OnAdd -= OnMinionIdentitiesChanged;
Components.LiveMinionIdentities.OnRemove -= OnMinionIdentitiesChanged;
base.ClearTarget();
}
public void FindBySQLMultipleObject()
{
ISession s = OpenSession();
Category c = new Category();
c.Name = "NAME";
Assignable assn = new Assignable();
assn.Id = "i.d.";
IList l = new ArrayList();
l.Add(c);
assn.Categories = l;
c.Assignable = assn;
s.Save(assn);
s.Flush();
c = new Category();
c.Name = "NAME2";
assn = new Assignable();
assn.Id = "i.d.2";
l = new ArrayList();
l.Add(c);
assn.Categories = l;
c.Assignable = assn;
s.Save(assn);
s.Flush();
assn = new Assignable();
assn.Id = "i.d.3";
s.Save(assn);
s.Flush();
s.Close();
s = OpenSession();
if (!(Dialect is MySQLDialect))
{
IList list =
s.CreateSQLQuery("select {category.*}, {assignable.*} from Category {category}, \"assign able\" {assignable}")
.AddEntity("category", typeof(Category))
.AddEntity("assignable", typeof(Assignable))
.List();
Assert.AreEqual(6, list.Count, "Count differs"); // cross-product of 2 categories x 3 assignables;
Assert.IsTrue(list[0] is object[]);
}
s.Delete("from Assignable");
s.Delete("from Category");
s.Flush();
s.Close();
}
public void CreateAssignableThrowsError()
{
var client = new TargetProcessClient
{
ApiSiteInfo = new ApiSiteInfo(TargetProcessRoutes.Route.Assignables)
};
var assignable = new Assignable
{
//EntityState = new EntityState { Name = "Some Entity state"}
};
var data = client.CreateData <Assignable>(assignable);
}
public async Task FindBySQLMultipleObjectAsync()
{
ISession s = OpenSession();
Category c = new Category();
c.Name = "NAME";
Assignable assn = new Assignable();
assn.Id = "i.d.";
assn.Categories = new List <Category> {
c
};
c.Assignable = assn;
await(s.SaveAsync(assn));
await(s.FlushAsync());
c = new Category();
c.Name = "NAME2";
assn = new Assignable();
assn.Id = "i.d.2";
assn.Categories = new List <Category> {
c
};
c.Assignable = assn;
await(s.SaveAsync(assn));
await(s.FlushAsync());
assn = new Assignable();
assn.Id = "i.d.3";
await(s.SaveAsync(assn));
await(s.FlushAsync());
s.Close();
s = OpenSession();
if (!(Dialect is MySQLDialect))
{
IList list =
await(s.CreateSQLQuery("select {category.*}, {assignable.*} from Category {category}, \"assign able\" {assignable}")
.AddEntity("category", typeof(Category))
.AddEntity("assignable", typeof(Assignable))
.ListAsync());
Assert.AreEqual(6, list.Count, "Count differs"); // cross-product of 2 categories x 3 assignables;
Assert.IsTrue(list[0] is object[]);
}
await(s.DeleteAsync("from Assignable"));
await(s.DeleteAsync("from Category"));
await(s.FlushAsync());
s.Close();
}
public void RemoveSuitIfNecessary()
{
Equipment equipment = base.sm.recoverer.Get <Equipment>(base.smi);
if (!((UnityEngine.Object)equipment == (UnityEngine.Object)null))
{
Assignable assignable = equipment.GetAssignable(Db.Get().AssignableSlots.Suit);
if (!((UnityEngine.Object)assignable == (UnityEngine.Object)null))
{
assignable.Unassign();
}
}
}
public virtual void Unassign(bool trigger_event = true)
{
if (!unassigning && IsAssigned())
{
unassigning = true;
assignable.Unassign();
if (trigger_event)
{
assignables.Trigger(-1585839766, this);
}
assignable = null;
unassigning = false;
}
}
public bool SetDestination(Assignable assignment)
{
if (assignment == null || assignment.AddWorker(this))
{
if (assignedLocation != null && assignedLocation != assignment)
{
assignedLocation.RemoveWorker(this);
}
assignedLocation = assignment;
SetWalkerDestination(assignment == null ? null : (Vector3?)assignment.GetSpotForWorker(this).position);
return(true);
}
return(false);
}
public void UpdateMessStation()
{
Ownables soleOwner = base.sm.eater.Get(base.smi).GetComponent <MinionIdentity>().GetSoleOwner();
List <Assignable> preferredAssignables = Game.Instance.assignmentManager.GetPreferredAssignables(soleOwner, Db.Get().AssignableSlots.MessStation);
if (preferredAssignables.Count == 0)
{
soleOwner.AutoAssignSlot(Db.Get().AssignableSlots.MessStation);
preferredAssignables = Game.Instance.assignmentManager.GetPreferredAssignables(soleOwner, Db.Get().AssignableSlots.MessStation);
}
Assignable value = (preferredAssignables.Count <= 0) ? null : preferredAssignables[0];
base.smi.sm.messstation.Set(value, base.smi);
}
public async Task QueuedBagAddsAsync()
{
ISession s = OpenSession();
Assignable a = new Assignable();
a.Id = "foo";
a.Categories = new List <Category>();
Category c = new Category();
c.Assignable = a;
a.Categories.Add(c);
await(s.SaveAsync(a));
await(s.FlushAsync());
s.Close();
await(Sfi.EvictCollectionAsync("NHibernate.DomainModel.Assignable.Categories"));
s = OpenSession();
a = (Assignable)await(s.GetAsync(typeof(Assignable), "foo"));
c = new Category();
c.Assignable = a;
a.Categories.Add(c);
Assert.IsFalse(NHibernateUtil.IsInitialized(a.Categories));
Assert.AreEqual(2, a.Categories.Count);
await(s.FlushAsync());
s.Close();
await(Sfi.EvictCollectionAsync("NHibernate.DomainModel.Assignable.Categories"));
s = OpenSession();
a = (Assignable)await(s.GetAsync(typeof(Assignable), "foo"));
c = new Category();
c.Assignable = a;
a.Categories.Add(c);
Assert.IsFalse(NHibernateUtil.IsInitialized(a.Categories));
await(s.FlushAsync());
Assert.IsFalse(NHibernateUtil.IsInitialized(a.Categories));
Assert.AreEqual(3, a.Categories.Count);
s.Close();
await(Sfi.EvictCollectionAsync("NHibernate.DomainModel.Assignable.Categories"));
s = OpenSession();
a = (Assignable)await(s.GetAsync(typeof(Assignable), "foo"));
Assert.AreEqual(3, a.Categories.Count);
await(s.DeleteAsync(a));
await(s.FlushAsync());
s.Close();
}
public void QueuedBagAdds()
{
ISession s = OpenSession();
Assignable a = new Assignable();
a.Id = "foo";
a.Categories = new ArrayList();
Category c = new Category();
c.Assignable = a;
a.Categories.Add(c);
s.Save(a);
s.Flush();
s.Close();
sessions.EvictCollection("NHibernate.DomainModel.Assignable.Categories");
s = OpenSession();
a = (Assignable)s.Get(typeof(Assignable), "foo");
c = new Category();
c.Assignable = a;
a.Categories.Add(c);
Assert.IsFalse(NHibernateUtil.IsInitialized(a.Categories));
Assert.AreEqual(2, a.Categories.Count);
s.Flush();
s.Close();
sessions.EvictCollection("NHibernate.DomainModel.Assignable.Categories");
s = OpenSession();
a = (Assignable)s.Get(typeof(Assignable), "foo");
c = new Category();
c.Assignable = a;
a.Categories.Add(c);
Assert.IsFalse(NHibernateUtil.IsInitialized(a.Categories));
s.Flush();
Assert.IsFalse(NHibernateUtil.IsInitialized(a.Categories));
Assert.AreEqual(3, a.Categories.Count);
s.Close();
sessions.EvictCollection("NHibernate.DomainModel.Assignable.Categories");
s = OpenSession();
a = (Assignable)s.Get(typeof(Assignable), "foo");
Assert.AreEqual(3, a.Categories.Count);
s.Delete(a);
s.Flush();
s.Close();
}
public void CreateAssignableThrowsError()
{
var client = CommonMethods.GetClientByRoute(TargetProcessRoutes.Route.Assignables);
var assignable = new Assignable();
var data = client.CreateData <Assignable>(assignable);
Assert.NotNull(data);
Assert.True(data.HttpResponse.IsError);
Assert.Equal(data.HttpResponse.Exception.GetType(), typeof(SniperExceptions.RequiredPropertyException));
var exception = (SniperExceptions.RequiredPropertyException)data.HttpResponse.Exception;
Assert.Equal(exception.RequiredDataResponse.Message, CrudMessages.CreateProhibited);
}
/// <summary>
/// Init class method.
/// </summary>
private void Init()
{
if (_assignable == null)
{
switch (slotType) // TODO: Add get assignable for weapons.
{
case Slot.Type.item:
_assignable = GetComponent <Assignable>();
break;
default:
break;
}
}
}
private void UnassignKPrefabIDs(Room room, List <KPrefabID> list)
{
foreach (KPrefabID item in list)
{
if (!((UnityEngine.Object)item == (UnityEngine.Object)null))
{
item.Trigger(144050788, null);
Assignable component = item.GetComponent <Assignable>();
if ((UnityEngine.Object)component != (UnityEngine.Object)null && component.assignee == room)
{
component.Unassign();
}
}
}
}
private static void Transfer(Assignable assignable, Storage lockerStorage)
{
if (assignable != null && lockerStorage != null)
{
var suitStorage = assignable.GetComponent <Storage>();
var suitTank = assignable.GetComponent <SuitTank>();
if (suitStorage != null && suitTank != null)
{
suitStorage.Transfer(lockerStorage, suitTank.elementTag, suitTank.capacity, false, true);
}
var jetSuitTank = assignable.GetComponent <JetSuitTank>();
if (jetSuitTank != null && lockerStorage.HasTag(JetSuitLockerConfig.ID))
{
lockerStorage.AddLiquid(SimHashes.Petroleum, jetSuitTank.amount, assignable.GetComponent <PrimaryElement>().Temperature, byte.MaxValue, 0, false, true);
jetSuitTank.amount = 0f;
}
}
}
public void NamedSQLQuery()
{
if (Dialect is MySQLDialect)
{
return;
}
ISession s = OpenSession();
Category c = new Category();
c.Name = "NAME";
Assignable assn = new Assignable();
assn.Id = "i.d.";
IList l = new ArrayList();
l.Add(c);
assn.Categories = l;
c.Assignable = assn;
s.Save(assn);
s.Flush();
s.Close();
s = OpenSession();
IQuery q = s.GetNamedQuery("namedsql");
Assert.IsNotNull(q, "should have found 'namedsql'");
IList list = q.List();
Assert.IsNotNull(list, "executing query returns list");
object[] values = list[0] as object[];
Assert.IsNotNull(values[0], "index 0 should not be null");
Assert.IsNotNull(values[1], "index 1 should not be null");
Assert.AreEqual(typeof(Category), values[0].GetType(), "should be a Category");
Assert.AreEqual(typeof(Assignable), values[1].GetType(), "should be Assignable");
s.Delete("from Category");
s.Delete("from Assignable");
s.Flush();
s.Close();
}
protected override void OnSpawn()
{
base.OnSpawn();
storage = GetComponent <Storage>();
assignable = GetComponent <Assignable>();
assignable.AddAssignPrecondition(CanAssignTo);
base.smi.StartSM();
int cell = Grid.PosToCell(base.gameObject);
partitionerEntry = GameScenePartitioner.Instance.Add("CommandModule.gantryChanged", base.gameObject, cell, GameScenePartitioner.Instance.validNavCellChangedLayer, OnGantryChanged);
OnGantryChanged(null);
RocketModule component = GetComponent <RocketModule>();
reachable = (ConditionDestinationReachable)component.AddLaunchCondition(new ConditionDestinationReachable(this));
hasAstronaut = (ConditionHasAstronaut)component.AddLaunchCondition(new ConditionHasAstronaut(this));
hasSuit = (ConditionHasAtmoSuit)component.AddLaunchCondition(new ConditionHasAtmoSuit(this));
cargoEmpty = (CargoBayIsEmpty)component.AddLaunchCondition(new CargoBayIsEmpty(this));
destHasResources = (ConditionHasMinimumMass)component.AddLaunchCondition(new ConditionHasMinimumMass(this));
flightPathIsClear = (ConditionFlightPathIsClear)component.AddFlightCondition(new ConditionFlightPathIsClear(base.gameObject, 1));
}
private void AssignBuildingsToRoom(Room room)
{
Debug.Assert(room != null);
RoomType roomType = room.roomType;
if (roomType != Db.Get().RoomTypes.Neutral)
{
foreach (KPrefabID building in room.buildings)
{
if (!((UnityEngine.Object)building == (UnityEngine.Object)null) && !building.HasTag(GameTags.NotRoomAssignable))
{
Assignable component = building.GetComponent <Assignable>();
if ((UnityEngine.Object)component != (UnityEngine.Object)null && (roomType.primary_constraint == null || !roomType.primary_constraint.building_criteria(building.GetComponent <KPrefabID>())))
{
component.Assign(room);
}
}
}
}
}
