/// <summary>
/// Returns true if a teacher has booked 3 rooms or more.
/// </summary>
public bool ThreeRoomsBookingLimit()
{
var query = (from b in BookingCatalogSingleton.Instance.Bookings
where b.User_Id == LoginHandler.CurrentUserId &&
b.Date.Date == RoomReference.Date.Date &&
b.Time_end >= RoomReference.TimeStart && b.Time_start <= RoomReference.TimeEnd
group b by b.User_Id into RoomGroup
select new
{
LimitKey = RoomGroup.Key,
Count = RoomGroup.Count()
}).ToList();
foreach (var item in query)
{
if (item.Count >= 3)
{
return(false);
}
}
return(true);
}
private float GetTemperatureChangeAmount(RoomGroup room, float averageTemperature)
{
if (!room.UsesOutdoorTemperature)
{
float roomSize = (float)room.CellCount;
float temperature = room.Temperature;
float temperatureDifferenceTimesRate = (averageTemperature - temperature) * temperatureEqualizeRate;
float temperatureChange = temperatureDifferenceTimesRate / roomSize;
float resultingTemperature = temperature + temperatureChange;
if (temperatureDifferenceTimesRate > 0f && resultingTemperature > averageTemperature)
{
resultingTemperature = averageTemperature;
}
else if (temperatureDifferenceTimesRate < 0f && resultingTemperature < averageTemperature)
{
resultingTemperature = averageTemperature;
}
return(Mathf.Abs((resultingTemperature - temperature) * roomSize / temperatureDifferenceTimesRate));
}
return(0.0f);
}
public override void DrawGhost(ThingDef def, IntVec3 center, Rot4 rot, Color ghostCol)
{
Map currentMap = Find.CurrentMap;
IntVec3 intVec = center + IntVec3.South.RotatedBy(rot);
IntVec3 intVec2 = center + IntVec3.North.RotatedBy(rot);
List <IntVec3> list = new List <IntVec3>
{
intVec
};
GenDraw.DrawFieldEdges(list, Color.magenta);
list = new List <IntVec3>
{
intVec2
};
GenDraw.DrawFieldEdges(list, Color.white);
RoomGroup roomGroup = intVec2.GetRoomGroup(currentMap);
RoomGroup roomGroup2 = intVec.GetRoomGroup(currentMap);
if (roomGroup != null && roomGroup2 != null)
{
if (roomGroup == roomGroup2 && !roomGroup.UsesOutdoorTemperature)
{
GenDraw.DrawFieldEdges(roomGroup.Cells.ToList(), new Color(1f, 0.7f, 0f, 0.5f));
}
else
{
if (!roomGroup.UsesOutdoorTemperature)
{
GenDraw.DrawFieldEdges(roomGroup.Cells.ToList(), Color.white);
}
if (!roomGroup2.UsesOutdoorTemperature)
{
GenDraw.DrawFieldEdges(roomGroup2.Cells.ToList(), Color.magenta);
}
}
}
}
static bool Prefix(ref MapTemperature __instance)
{
float modValue = Find.TickManager.TicksGame % 120;
if (modValue < 7 && modValue >= 7 + RefcellRespeedConfig.currentTimeMultiplier && !DebugSettings.fastEcology)
{
return(false);
}
__instance.fastProcessedRoomGroups.Clear();
List <Room> allRooms = __instance.map.regionGrid.allRooms;
for (int index = 0; index < allRooms.Count; ++index)
{
RoomGroup group = allRooms[index].Group;
if (!__instance.fastProcessedRoomGroups.Contains(group))
{
group.TempTracker.EqualizeTemperature();
__instance.fastProcessedRoomGroups.Add(group);
}
}
__instance.fastProcessedRoomGroups.Clear();
return(false);
}
//joins two groups together with a coridoor
private void JoinGroups(RoomGroup groupA, RoomGroup groupB)
{
Room[] closestRooms = new Room[2];
float closestDistance = float.MaxValue;
for (int i = 1; i < groupA.getCount(); i++)
{
for (int j = 0; j < groupB.getCount(); j++)
{
float euclideanDistance = EuclideanDist(groupA.GetRoom(i), groupB.GetRoom(j));
if (euclideanDistance < closestDistance)
{
closestRooms [0] = groupA.GetRoom(i);
closestRooms [1] = groupB.GetRoom(j);
closestDistance = euclideanDistance;
}
}
}
if (!SpawnCoridoor(closestRooms[0], closestRooms[1], true, true))
{
spawnFailed = true;
}
}
/// <summary>
/// A method making sure a teacher has no more than three booking on a inputted timeinterval
/// </summary>
/// <returns>Returns true if a teacher can book another room, and false if he has more than three booking</returns>
public bool ThreeRoomsBookingLimit()
{
var query = (from b in AllBookingsViewCatalogSingleton.Instance.AllBookings
where b.User_Id == LoginHandler.CurrentUserId &&
b.Date.Date == TCPREF.BookingIsSelected.Date.Date &&
b.BookingEnd >= TCPREF.InputTimeStart && b.BookingStart <= TCPREF.InputTimeEnd
group b by b.User_Id
into RoomGroup
select new
{
LimitKey = RoomGroup.Key,
Count = RoomGroup.Count()
}).ToList();
//var query = (from b in BookingCatalogSingleton.Instance.Bookings
// where b.User_Id == LoginHandler.CurrentUserId &&
// b.Date.Date == TCPREF.BookingIsSelected.Date.Date
// && b.Time_end >= TCPREF.InputTimeStart && b.Time_start <= TCPREF.InputTimeEnd
// group b by b.User_Id
// into RoomGroup
// select new
// {
// LimitKey = RoomGroup.Key,
// Count = RoomGroup.Count()
// }).ToList();
foreach (var item in query)
{
if (item.Count >= 3)
{
return(false);
}
}
return(true);
}
public override void DrawGhost(ThingDef def, IntVec3 center, Rot4 rot)
{
Map visibleMap = Find.VisibleMap;
IntVec3 intVec = center + IntVec3.South.RotatedBy(rot);
IntVec3 intVec2 = center + IntVec3.North.RotatedBy(rot);
GenDraw.DrawFieldEdges(new List <IntVec3>
{
intVec
}, Color.white);
GenDraw.DrawFieldEdges(new List <IntVec3>
{
intVec2
}, Color.white);
RoomGroup roomGroup = intVec2.GetRoomGroup(visibleMap);
RoomGroup roomGroup2 = intVec.GetRoomGroup(visibleMap);
if (roomGroup != null && roomGroup2 != null)
{
if (roomGroup == roomGroup2 && !roomGroup.UsesOutdoorTemperature)
{
GenDraw.DrawFieldEdges(roomGroup.Cells.ToList <IntVec3>(), Color.white);
}
else
{
if (!roomGroup.UsesOutdoorTemperature)
{
GenDraw.DrawFieldEdges(roomGroup.Cells.ToList <IntVec3>(), Color.white);
}
if (!roomGroup2.UsesOutdoorTemperature)
{
GenDraw.DrawFieldEdges(roomGroup2.Cells.ToList <IntVec3>(), Color.white);
}
}
}
}
public T GetEntity <T>(int[] ids) where T : ModelEntity
{
DSClient client = new DSClient(Models.Const.ApplicationId);
int userId;
string token;
if (GetToken(out userId, out token))
{
var t = typeof(T);
if (t == typeof(Application))
{
Application app = client.GetApplication(userId, token, ids[0]);
return(app as T);
}
else if (t == typeof(Role))
{
Role role = client.GetRole(userId, token, ids[0]);
return(role as T);
}
else if (t == typeof(Image))
{
Image image = client.GetImage(userId, token, ids[0]);
return(image as T);
}
else if (t == typeof(Command))
{
Command cmd = client.GetCommand(userId, token, ids[0]);
return(cmd as T);
}
else if (t == typeof(RoleCommand))
{
RoleCommand rc = client.GetRoleCommand(userId, token, ids[0]);
return(rc as T);
}
else if (t == typeof(RoleCommandView))
{
RoleCommandView rc = client.GetRoleCommandView(userId, token, ids[0]);
return(rc as T);
}
else if (t == typeof(User))
{
User user = client.GetUser(userId, token, ids[0]);
return(user as T);
}
else if (t == typeof(UserApplicationInfo))
{
UserApplicationInfo info = client.GetUserInfo(userId, token, ids[0], ids[1]);
return(info as T);
}
else if (t == typeof(RoomGroup))
{
RoomGroup roomGroup = client.GetRoomGroup(userId, token, ids[0]);
return(roomGroup as T);
}
else if (t == typeof(Room))
{
Room room = client.GetRoom(userId, token, ids[0]);
return(room as T);
}
else if (t == typeof(RoomRole))
{
RoomRole rRole = client.GetRoomRole(userId, token, ids[0], ids[1], ids[2]);
return(rRole as T);
}
else if (t == typeof(GiftGroup))
{
GiftGroup giftGroup = client.GetGiftGroup(userId, token, ids[0]);
return(giftGroup as T);
}
else if (t == typeof(Gift))
{
Gift gift = client.GetGift(userId, token, ids[0]);
return(gift as T);
}
else if (t == typeof(BlockType))
{
BlockType b = client.GetBlockType(userId, token, ids[0]);
return(b as T);
}
else if (t == typeof(BlockList))
{
BlockList b = client.GetBlockList(userId, token, ids[0]);
return(b as T);
}
else if (t == typeof(RoomRole))
{
RoomRole rr = client.GetRoomRole(userId, token, ids[0], ids[1], ids[2]);
return(rr as T);
}
else if (t == typeof(RoomConfig))
{
RoomConfig c = client.GetRoomConfig(userId, token, ids[0]);
return(c as T);
}
}
return(null);
}
public void UniqueID()
{
var roomGroup = new RoomGroup();
Assert.NotNull(roomGroup.UniqueID);
}
void Start()
{
roomGroup = new RoomGroup(roomCount);
roomGroup.Set();
DrawMapGroup();
}
static bool Prefix(RegionAndRoomUpdater __instance)
{
Map map = __instance.map;
if (!copyFrom.TryGetValue(map.uniqueID, out RegionGrid oldRegions))
{
return(true);
}
__instance.initialized = true;
map.temperatureCache.ResetTemperatureCache();
oldRegions.map = map; // for access to cellIndices in the iterator
foreach (Region r in oldRegions.AllRegions_NoRebuild_InvalidAllowed)
{
r.cachedAreaOverlaps = null;
r.cachedDangers.Clear();
r.mark = 0;
r.reachedIndex = 0;
r.closedIndex = new uint[RegionTraverser.NumWorkers];
r.cachedCellCount = -1;
r.mapIndex = (sbyte)map.Index;
if (r.door != null)
{
r.door = map.ThingReplacement(r.door);
}
foreach (List <Thing> things in r.listerThings.listsByGroup.Concat(r.ListerThings.listsByDef.Values))
{
if (things != null)
{
for (int j = 0; j < things.Count; j++)
{
if (things[j] != null)
{
things[j] = map.ThingReplacement(things[j]);
}
}
}
}
Room rm = r.Room;
if (rm == null)
{
continue;
}
rm.mapIndex = (sbyte)map.Index;
rm.cachedCellCount = -1;
rm.cachedOpenRoofCount = -1;
rm.statsAndRoleDirty = true;
rm.stats = new DefMap <RoomStatDef, float>();
rm.role = null;
rm.uniqueNeighbors.Clear();
rm.uniqueContainedThings.Clear();
RoomGroup rg = rm.groupInt;
rg.tempTracker.cycleIndex = 0;
}
for (int i = 0; i < oldRegions.regionGrid.Length; i++)
{
map.regionGrid.regionGrid[i] = oldRegions.regionGrid[i];
}
copyFrom.Remove(map.uniqueID);
return(false);
}
public static void DoCellSteadyEffects(SteadyEnvironmentEffects __instance, IntVec3 c)
{
Map map2 = map(__instance);
Room room = c.GetRoom(map2, RegionType.Set_All);
bool roofed = map2.roofGrid.Roofed(c);
RoomGroup roomGroup = null;
if (room != null)
{
roomGroup = room.Group;
}
bool roomUsesOutdoorTemperature = room != null && roomGroup != null && room.UsesOutdoorTemperature;
if ((room == null) | roomUsesOutdoorTemperature)
{
if (outdoorMeltAmount(__instance) > 0.0)
{
map2.snowGrid.AddDepth(c, -outdoorMeltAmount(__instance));
}
if (!roofed && snowRate(__instance) > 1.0 / 1000.0)
{
AddFallenSnowAt(__instance, c, 23f / 500f * map2.weatherManager.SnowRate);
}
}
if (room != null)
{
bool protectedByEdifice = ProtectedByEdifice(c, map2);
TerrainDef terrain = c.GetTerrain(map2);
List <Thing> thingList = c.GetThingList(map2);
for (int index = 0; index < thingList.Count; ++index)
{
Thing t = thingList[index];
if (t is Filth filth)
{
if (!roofed && t.def.filth.rainWashes && Rand.Chance(rainRate(__instance)))
{
filth.ThinFilth();
}
if (filth.DisappearAfterTicks != 0 && filth.TicksSinceThickened > filth.DisappearAfterTicks)
{
filth.Destroy(DestroyMode.Vanish);
}
}
else
{
TryDoDeteriorate(__instance, t, roofed, roomUsesOutdoorTemperature, protectedByEdifice, terrain);
}
}
if (!roomUsesOutdoorTemperature && roomGroup != null)
{
float temperature = roomGroup.Temperature;
if (temperature > 0.0)
{
float num1 = MeltAmountAt(temperature);
if (num1 > 0.0)
{
map2.snowGrid.AddDepth(c, -num1);
}
if (room.RegionType.Passable() && temperature > (double)AutoIgnitionTemperatureRange.min)
{
double num2 = Rand.Value;
if (num2 < AutoIgnitionTemperatureRange.InverseLerpThroughRange(temperature) * 0.699999988079071 && Rand.Chance(FireUtility.ChanceToStartFireIn(c, map2)))
{
FireUtility.TryStartFireIn(c, map2, 0.1f);
}
if (num2 < 0.330000013113022)
{
MoteMaker.ThrowHeatGlow(c, map2, 2.3f);
}
}
}
}
}
map2.gameConditionManager.DoSteadyEffects(c, map2);
}
private void Start()
{
roomGroup = GameObject.Find("MapBuilder").GetComponent <MapSet>().roomGroup;
pointPos = new Vector2(0, 0);
}
private static void FloodAndSetRoomGroups2(RegionAndRoomUpdater __instance, Room start, RoomGroup roomGroup)
{
Stack <Room> tmpRoomStack = new Stack <Room>();
//tmpRoomStack.Clear();
tmpRoomStack.Push(start);
HashSet <Room> tmpVisitedRooms = new HashSet <Room>();
//tmpVisitedRooms.Clear();
tmpVisitedRooms.Add(start);
while (tmpRoomStack.Count != 0)
{
Room room = tmpRoomStack.Pop();
room.Group = roomGroup;
foreach (Room neighbor in room.Neighbors)
{
if (!tmpVisitedRooms.Contains(neighbor) && ShouldBeInTheSameRoomGroup(room, neighbor))
{
tmpRoomStack.Push(neighbor);
tmpVisitedRooms.Add(neighbor);
}
}
}
tmpVisitedRooms.Clear();
tmpRoomStack.Clear();
}
public static bool FloodAndSetRoomGroups(RegionAndRoomUpdater __instance, Room start, RoomGroup roomGroup)
{
//this.tmpRoomStack.Clear();
Stack <Room> tmpRoomStack = new Stack <Room>();
tmpRoomStack.Push(start);
//this.tmpVisitedRooms.Clear();
HashSet <Room> tmpVisitedRooms = new HashSet <Room>();
tmpVisitedRooms.Add(start);
while (tmpRoomStack.Count != 0)
{
Room a = tmpRoomStack.Pop();
a.Group = roomGroup;
foreach (Room neighbor in a.Neighbors)
{
if (!tmpVisitedRooms.Contains(neighbor) && ShouldBeInTheSameRoomGroup(a, neighbor))
{
tmpRoomStack.Push(neighbor);
tmpVisitedRooms.Add(neighbor);
}
}
}
//this.tmpVisitedRooms.Clear();
//this.tmpRoomStack.Clear();
return(false);
}
public static bool EqualizeTemperaturesThroughBuilding(Building b, float rate, bool twoWay)
{
int num = 0;
float num2 = 0f;
if (twoWay)
{
for (int i = 0; i < 2; i++)
{
IntVec3 intVec = (i == 0) ? (b.Position + b.Rotation.FacingCell) : (b.Position - b.Rotation.FacingCell);
if (intVec.InBounds(b.Map))
{
RoomGroup roomGroup = intVec.GetRoomGroup(b.Map);
if (roomGroup != null)
{
num2 += roomGroup.Temperature;
beqRoomGroups[num] = roomGroup;
num++;
}
}
}
}
else
{
for (int j = 0; j < 4; j++)
{
IntVec3 intVec2 = b.Position + GenAdj.CardinalDirections[j];
if (intVec2.InBounds(b.Map))
{
RoomGroup roomGroup2 = intVec2.GetRoomGroup(b.Map);
if (roomGroup2 != null)
{
num2 += roomGroup2.Temperature;
beqRoomGroups[num] = roomGroup2;
num++;
}
}
}
}
if (num == 0)
{
return(false);
}
float num3 = num2 / (float)num;
RoomGroup roomGroup3 = b.GetRoomGroup();
if (roomGroup3 != null)
{
roomGroup3.Temperature = num3;
}
if (num == 1)
{
return(false);
}
float num4 = 1f;
for (int k = 0; k < num; k++)
{
RoomGroup roomGroupK = beqRoomGroups[k];
if (null != roomGroupK)
{
if (!roomGroupK.UsesOutdoorTemperature)
{
float temperature = roomGroupK.Temperature;
float num5 = (num3 - temperature) * rate;
float num6 = num5 / (float)roomGroupK.CellCount;
float num7 = roomGroupK.Temperature + num6;
if (num5 > 0f && num7 > num3)
{
num7 = num3;
}
else if (num5 < 0f && num7 < num3)
{
num7 = num3;
}
float num8 = Mathf.Abs((num7 - temperature) * (float)roomGroupK.CellCount / num5);
if (num8 < num4)
{
num4 = num8;
}
}
}
}
for (int l = 0; l < num; l++)
{
RoomGroup roomGroupL = beqRoomGroups[l];
if (null != roomGroupL && !roomGroupL.UsesOutdoorTemperature)
{
float temperature2 = roomGroupL.Temperature;
float num9 = (num3 - temperature2) * rate * num4 / (float)roomGroupL.CellCount;
roomGroupL.Temperature += num9;
beqRoomGroups[l] = roomGroupL;
}
}
for (int m = 0; m < beqRoomGroups.Length; m++)
{
beqRoomGroups[m] = null;
}
return(false);
}
public void SpawnRoom(Transform exitDoor)
{
// Roll for group type
GameObject newRoom = null;
// Spawn regular rooms until we've reached our max count
if (currentRooms < minRooms)
{
//newRoom = Instantiate(Resources.Load("DungeonRooms/Room" + Random.Range(0, roomCount)), exitDoor.position, exitDoor.rotation) as GameObject;
// Choose a random roomPrefab from a random group
GameObject roomPrefab = RoomGroup.ChooseRandomGroup(RoomGroups).ChooseRandomRoom().roomPrefab;
newRoom = Instantiate(roomPrefab, exitDoor.position, exitDoor.rotation);
RoomController newController = newRoom.GetComponent <RoomController>();
if (!newController)
{
Debug.Log(newRoom.name + " is missing a room controller!");
return;
}
newController.dungeonController = this;
newController.enterDoor = exitDoor;
newRoom.transform.SetParent(dungeonRoot.transform);
}
else if (!bossSpawned)
{
//newRoom = Instantiate(Resources.Load("BossRooms/Room" + Random.Range(0, bossRoomCount)), exitDoor.position, exitDoor.rotation) as GameObject;
newRoom = Instantiate(BossRoomProperties.roomPrefab, exitDoor.position, exitDoor.rotation);
RoomController newController = newRoom.GetComponent <RoomController>();
newController.dungeonController = this;
newController.enterDoor = exitDoor;
roomList.Add(newController);
newRoom.transform.SetParent(dungeonRoot.transform);
bossSpawned = true;
}
else if (bossSpawned && finishedSpawningDungeon && !finalizedDungeon)
{
finalizedDungeon = true;
GameObject plug = null;
// If all the rooms connect properly, the nav mesh will build all connecting surfaces
roomList[0].GetComponent <NavMeshSurface>().BuildNavMesh();
for (int x = 0; x < roomList.Count; x++)
{
if (!roomList[x])
{
continue;
}
// If this is the first room, fooooooget about it
if (x > 0)
{
roomList[x].SpawnEnemies();
}
// If we're in the last 4th of the dungeons, spawn a key
if (!dungeonKeySpawned && ((float)(x) / roomList.Count) >= 0.75f)
{
dungeonKeySpawned = true;
// If we're in the last room and we haven't spawned a key yet, do so
GameObject key = Instantiate(DungeonKey);
int randomNode = Random.Range(0, roomList[x].itemPlacementNodes.Length);
key.transform.position = roomList[x].itemPlacementNodes[randomNode].transform.position;
key.transform.SetParent(roomList[x].transform);
}
}
// No longer needed. The first room will always be connected to the hub!
// Add a plug to our first room's entrance
/*plug = Instantiate(RoomPlug);
* plug.transform.SetParent(roomList[0].GetComponent<RoomController>().enterDoor);
* plug.transform.localPosition = Vector3.zero;
* plug.transform.localRotation = Quaternion.identity;
* plug.transform.SetParent(roomList[0].GetComponentInParent<RoomController>().gameObject.transform);*/
// Add plugs to all the exits
foreach (Transform exit in exitsLeft)
{
plug = Instantiate(RoomPlug);
plug.transform.SetParent(exit);
plug.transform.localPosition = Vector3.zero;
plug.transform.localRotation = Quaternion.identity;
plug.transform.SetParent(exit.GetComponentInParent <RoomController>().gameObject.transform);
}
}
else
{
exitsLeft.Add(exitDoor);
}
}
public RoomGroupViewModel(RoomGroup rg)
: base(rg)
{
name.SetValue(rg.Name);
ParentRoomGroupId = rg.ParentGroup_Id.HasValue ? rg.ParentGroup_Id.Value : -1;
}
public static void Initialize(EFDomainDbContext cntxt)
{
if (!cntxt.BedTypes.Any())
{
var bt = BedType.Create("TWN", "2 Twin Beds");
cntxt.BedTypes.AddAsync(bt);
bt = BedType.Create("DBL", "1 King Bed");
cntxt.BedTypes.AddAsync(bt);
bt = BedType.Create("HTW", "Hollywood Twin");
cntxt.BedTypes.AddAsync(bt);
bt = BedType.Create("FAM", "1 Double & 1 Twin");
cntxt.BedTypes.AddAsync(bt);
cntxt.SaveChangesAsync();
}
if (!cntxt.RoomFacilities.Any())
{
var f = RoomFacility.Create("TV", "TV");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("COT", "Baby Cot");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("HCH", "Baby High Chair");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("TRO", "Trolley");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("MAT", "Nursing Mat");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("BRC", "Baby Resting Chair");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("BBS", "Dumbo Baby Sitter");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("CCC", "Children's crockery & cutlery");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("BBT", "Baby Bathtub");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("NSM", "Non-slippery bath mat");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("STB", "Stool in the Bathroom");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("PLP", "Plastic Potty");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("SDL", "Safety drawer locks");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("BOI", "Boiler");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("INT", "Internet Connection");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("HAR", "Hair Dryer");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("BAB", "Bathrobes");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("SLP", "Slippers ");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("SAP", "Sun-beds and Parasol ");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("IRO", "Iron & Iron Board");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("BWS", "Bathtub with Shower & WC");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("SHW", "Shower Booth");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("SAF", "Safe Deposit Box");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("CAB", "Cable TV");
f = RoomFacility.Create("TEL", "Telephone");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("AIR", "Air Condition");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("WOR", "Working Desk");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("PAT", "Patch Cable");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("MIC", "Microwave Oven");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("FRD", "Refrigerator");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("MNB", "Mini Bar");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("SWC", "Shower & WC");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("HCW", "Hot &Cold Water");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("SOF", "Sofa Bed");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("RAI", "Rain-man Shower & WC");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("TOA", "Toaster");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("SUN", "5 Position(Sun Chairs)");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("WEL", "Welcome Package");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("DUX", "Dux Matress");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("CBA", "Children's Bathrobes");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("COS", "Cosmetic Mirror");
cntxt.RoomFacilities.AddAsync(f);
f = RoomFacility.Create("BTH", "Bathtub and WC");
cntxt.RoomFacilities.AddAsync(f);
cntxt.SaveChangesAsync();
}
if (!cntxt.RoomExposures.Any())
{
var re = RoomExposure.Create("GAV", "Garden View");
cntxt.RoomExposures.AddAsync(re);
re = RoomExposure.Create("POV", "Pool View");
cntxt.RoomExposures.AddAsync(re);
re = RoomExposure.Create("SFV", "Sea Facing View");
cntxt.RoomExposures.AddAsync(re);
re = RoomExposure.Create("SSV", "Side Sea View");
cntxt.RoomExposures.AddAsync(re);
re = RoomExposure.Create("PGV", "Pool and Garden View");
cntxt.RoomExposures.AddAsync(re);
re = RoomExposure.Create("BKV", "Back View");
cntxt.RoomExposures.AddAsync(re);
cntxt.SaveChangesAsync();
}
if (!cntxt.RoomGroups.Any())
{
var rg = RoomGroup.Create("STU", "Studio Type");
cntxt.RoomGroups.AddAsync(rg);
rg = RoomGroup.Create("HBT", "Studio Happy Baby Type");
cntxt.RoomGroups.AddAsync(rg);
rg = RoomGroup.Create("ROY", "Royal Studio Type");
cntxt.RoomGroups.AddAsync(rg);
rg = RoomGroup.Create("ROP", "Royal Studio Pool Access Type");
cntxt.RoomGroups.AddAsync(rg);
rg = RoomGroup.Create("FAM", "Family Suite Type");
cntxt.RoomGroups.AddAsync(rg);
rg = RoomGroup.Create("ROF", "Royal Family Suite Type");
cntxt.RoomGroups.AddAsync(rg);
rg = RoomGroup.Create("DLX", "Deluxe Room No Balcony Type");
cntxt.RoomGroups.AddAsync(rg);
cntxt.SaveChangesAsync();
}
if (!cntxt.RoomTypes.Any())
{
var stu = cntxt.RoomGroups.Where(c => c.Code == "STU").FirstOrDefault();
var hbt = cntxt.RoomGroups.Where(c => c.Code == "HBT").FirstOrDefault();
var roy = cntxt.RoomGroups.Where(c => c.Code == "ROY").FirstOrDefault();
var rop = cntxt.RoomGroups.Where(c => c.Code == "ROP").FirstOrDefault();
var fam = cntxt.RoomGroups.Where(c => c.Code == "FAM").FirstOrDefault();
var rof = cntxt.RoomGroups.Where(c => c.Code == "ROF").FirstOrDefault();
var dlx = cntxt.RoomGroups.Where(c => c.Code == "DLX").FirstOrDefault();
var rt = RoomType.Create("12GAT", "Studio Garden View Terrace", stu, 4);
cntxt.RoomTypes.AddAsync(rt);
rt = RoomType.Create("12GAB", "Studio Garden View Balcony", stu, 4);
cntxt.RoomTypes.AddAsync(rt);
rt = RoomType.Create("12POT", "Studio Pool View Terrace", stu, 4);
cntxt.RoomTypes.AddAsync(rt);
rt = RoomType.Create("12POB", "Studio Pool View Balcony", stu, 4);
cntxt.RoomTypes.AddAsync(rt);
rt = RoomType.Create("12HBT", "Studio Happy Baby", hbt, 4);
cntxt.RoomTypes.AddAsync(rt);
rt = RoomType.Create("12RPA", "Royal Studio Pool Access", rop, 4);
cntxt.RoomTypes.AddAsync(rt);
rt = RoomType.Create("12ROT", "Royal Studio Terrace", roy, 4);
cntxt.RoomTypes.AddAsync(rt);
rt = RoomType.Create("12ROB", "Royal Studio Balcony", roy, 4);
cntxt.RoomTypes.AddAsync(rt);
rt = RoomType.Create("22POT", "Family Suite Pool View Terrace", fam, 6);
cntxt.RoomTypes.AddAsync(rt);
rt = RoomType.Create("22POB", "Family Suite Pool View Balcony", fam, 6);
cntxt.RoomTypes.AddAsync(rt);
rt = RoomType.Create("22RPA", "Royal Family Suite Pool Access", fam, 6);
cntxt.RoomTypes.AddAsync(rt);
rt = RoomType.Create("22GAB", "Family Suite Garden Balcony", fam, 6);
cntxt.RoomTypes.AddAsync(rt);
rt = RoomType.Create("22ROB", "Royal Family Suite Balcony", rof, 6);
cntxt.RoomTypes.AddAsync(rt);
rt = RoomType.Create("DLX", "Deluxe Room No Balcony", dlx, 4);
cntxt.RoomTypes.AddAsync(rt);
rt = RoomType.Create("22GAT", "Family Suite Garden Terrace", fam, 6);
cntxt.RoomTypes.AddAsync(rt);
cntxt.SaveChangesAsync();
}
if (!cntxt.RoomLocations.Any())
{
var rl = RoomLocation.Create("s", "south");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("n", "north");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B11", "Building 1 1st floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B12", "Building 1 2nd floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B13", "Building 1 3rd floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B14", "Building 1 4th floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B21", "Building 2 1st floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B22", "Building 2 2nd floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B23", "Building 2 3rd floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B24", "Building 2 4th floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B31", "Building 3 1st floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B32", "Building 3 2nd floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B33", "Building 3 3rd floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B41", "Building 4 1st floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B42", "Building 4 2nd floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B43", "Building 4 3rd floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B44", "Building 4 4th floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B51", "Building 5 1st floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B52", "Building 5 2nd floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B53", "Building 5 3rd floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B54", "Building 5 4th floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B61", "Building 6 1st floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B62", "Building 6 2nd floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B63", "Building 6 3rd floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B71", "Building 7 1st floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B72", "Building 7 2nd floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B73", "Building 7 3rd floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B74", "Building 7 4th floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B81", "Building 8 1st floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B82", "Building 8 2nd floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("B83", "Building 8 3rd floor");
cntxt.RoomLocations.AddAsync(rl);
rl = RoomLocation.Create("BL", "Lobby Building");
cntxt.RoomLocations.AddAsync(rl);
cntxt.SaveChangesAsync();
}
if (!cntxt.RoomInfos.Any())
{
var rt = cntxt.RoomTypes.Where(r => r.Code == "DLX").FirstOrDefault();
var bt = cntxt.BedTypes.Where(B => B.Code == "DBL").FirstOrDefault();
var rl = cntxt.RoomLocations.Where(r => r.Code == "BL").FirstOrDefault();
var re = cntxt.RoomExposures.Where(e => e.Code == "POV").FirstOrDefault();
var bkv = cntxt.RoomExposures.Where(e => e.Code == "BKV").FirstOrDefault();
var gab = cntxt.RoomTypes.Where(r => r.Code == "22GAB").FirstOrDefault();
var fam = cntxt.BedTypes.Where(B => B.Code == "FAM").FirstOrDefault();
var b13 = cntxt.RoomLocations.Where(r => r.Code == "B13").FirstOrDefault();
var gv = cntxt.RoomExposures.Where(e => e.Code == "GV").FirstOrDefault();
var rf1 = RoomInfo.Create("1211", rt, bt, rl, re);
cntxt.RoomInfos.AddAsync(rf1);
var rf2 = RoomInfo.Create("1212", rt, bt, rl, bkv);
cntxt.RoomInfos.AddAsync(rf2);
var rf3 = RoomInfo.Create("1301", gab, fam, b13, gv);
cntxt.RoomInfos.AddAsync(rf3);
cntxt.SaveChangesAsync();
var facilities1 = cntxt.RoomFacilities.OrderBy(x => Guid.NewGuid()).Take(5).ToList();
var facilities2 = cntxt.RoomFacilities.OrderBy(x => Guid.NewGuid()).Take(5).ToList();
var facilities3 = cntxt.RoomFacilities.OrderBy(x => Guid.NewGuid()).Take(5).ToList();
rf1.AddRoomRoomFacility(facilities1);
rf2.AddRoomRoomFacility(facilities2);
rf3.AddRoomRoomFacility(facilities3);
cntxt.SaveChangesAsync();
}
}
public static bool DangerFor(Region __instance, ref Danger __result, Pawn p)
{
if (Current.ProgramState == ProgramState.Playing)
{
if (cachedDangersForFrame(__instance) != Time.frameCount)
{
lock (cachedDangers(__instance))
{
cachedDangers(__instance).Clear();
}
cachedDangersForFrame(__instance) = Time.frameCount;
}
else
{
lock (cachedDangers(__instance)) {
for (int index = 0; index < cachedDangers(__instance).Count; ++index)
{
if (cachedDangers(__instance)[index].Key == p)
{
__result = cachedDangers(__instance)[index].Value;
return(false);
}
}
}
}
}
Danger danger = Danger.Unspecified;
Room room = __instance.Room;
RoomGroup group = null;
if (room != null)
{
group = room.Group;
}
if (room != null && group != null)
{
float temperature = group.Temperature;
FloatRange floatRange;
if (Current.ProgramState == ProgramState.Playing)
{
if (cachedSafeTemperatureRangesForFrame != Time.frameCount)
{
lock (cachedSafeTemperatureRanges)
{
cachedSafeTemperatureRanges.Clear();
}
cachedSafeTemperatureRangesForFrame = Time.frameCount;
}
lock (cachedSafeTemperatureRanges)
{
if (!cachedSafeTemperatureRanges.TryGetValue(p, out floatRange))
{
floatRange = p.SafeTemperatureRange();
cachedSafeTemperatureRanges.Add(p, floatRange);
}
}
}
else
{
floatRange = p.SafeTemperatureRange();
}
danger = !floatRange.Includes(temperature) ? (!floatRange.ExpandedBy(80f).Includes(temperature) ? Danger.Deadly : Danger.Some) : Danger.None;
if (Current.ProgramState == ProgramState.Playing)
{
lock (cachedDangers(__instance))
{
cachedDangers(__instance).Add(new KeyValuePair <Pawn, Danger>(p, danger));
}
}
}
__result = danger;
return(false);
}
public static bool FloodAndSetRoomGroups(RegionAndRoomUpdater __instance, Room start, RoomGroup roomGroup)
{
if (tmpRoomStack == null)
{
tmpRoomStack = new Stack <Room>();
}
else
{
tmpRoomStack.Clear();
}
tmpRoomStack.Push(start);
if (tmpVisitedRooms == null)
{
tmpVisitedRooms = new HashSet <Room>();
}
else
{
tmpVisitedRooms.Clear();
}
tmpVisitedRooms.Add(start);
while (tmpRoomStack.Count != 0)
{
Room room = tmpRoomStack.Pop();
room.Group = roomGroup;
foreach (Room neighbor in room.Neighbors)
{
if (!tmpVisitedRooms.Contains(neighbor) && funcShouldBeInTheSameRoomGroup(__instance, room, neighbor))
{
tmpRoomStack.Push(neighbor);
tmpVisitedRooms.Add(neighbor);
}
}
}
return(false);
}
//calculates euclidean distance between two groups
private float EuclideanDist(RoomGroup groupA, RoomGroup groupB)
{
return(Mathf.Sqrt(Mathf.Pow((groupB.getCentre()[0] - groupA.getCentre()[0]), 2) + Mathf.Pow((groupB.getCentre()[1] - groupA.getCentre()[1]), 2)));
}
