/// <summary>
/// </summary>
/// <param name="type"></param>
/// <param name="date">DateTime date is a date, no time</param>
/// <returns></returns>
public int GetRoomOccupancyByDate(ROOM_TYPE type, DateTime date)
{
RoomOccupancy roomOccupancy =
_context.RoomOccupancies.FirstOrDefault(ro => ro.Date == date && ro.RoomType == type);
return(roomOccupancy?.Occupancy ?? 0);
}
public int GetMaxRoomOccupanciesByRoomTypeAfterDate(ROOM_TYPE type, DateTime date)
{
IEnumerable <RoomOccupancy> occupancies =
_context.RoomOccupancies.Where(ro => ro.RoomType == type && ro.Date.CompareTo(date) >= 0);
return(occupancies.Select(occupancy => occupancy.Occupancy).Concat(new[] { 0 }).Max());
}
public void UpdateRoomOccupancy(ROOM_TYPE type, DateTime date, int quantity)
{
// check if record exists
RoomOccupancy roomOccupancy =
_context.RoomOccupancies.FirstOrDefault(ro => ro.Date == date && ro.RoomType == type);
if (roomOccupancy != null)
{
// update the existing RoomOccupancy record
roomOccupancy.Occupancy += quantity;
UpdateRoomOccupancy(roomOccupancy);
}
else
{
RoomType roomType = GetRoomType(type);
// create new and add it into RoomOccupancy
roomOccupancy = new RoomOccupancy
{
Id = Guid.NewGuid(),
Date = date,
Occupancy = quantity,
RoomType = type
};
_context.RoomOccupancies.Add(roomOccupancy);
}
}
/// <summary>
/// Get current room availibility
/// </summary>
/// <param name="type"></param>
/// <param name="date"></param>
/// <returns>current available rooms</returns>
private int GetCurrentRoomAvailability(ROOM_TYPE type, DateTime date)
{
RoomType room = _roomRepository.GetRoomType(type);
return(_roomRepository.GetRoomTotalAmount(room.Type) -
_roomRepository.GetRoomOccupancyByDate(room.Type, date));
}
public TileData()
{
player = -1;
connected = false;
interior = false;
roomType = ROOM_TYPE.EMPTY;
}
public double GetRoomOccupancyRate(ROOM_TYPE type, DateTime date)
{
var totalQuantity = _roomRepository.GetRoomTotalAmount(type);
var totalOccupation = _roomRepository.GetRoomOccupancyByDate(type, date);
return(totalOccupation * 1.0 / totalQuantity);
}
/// <summary>
/// Get price of a specific room type at date give.
/// Price on specific day = base price * (1 + occupation rate), ceiling if has decimals.
/// </summary>
/// <param name="baseRate">base price of the room type</param>
/// <param name="type">Room type</param>
/// <param name="date">Date for DateTime</param>
/// <returns>room price</returns>
private int GetRoomPrice(ROOM_TYPE type, int baseRate, DateTime date)
{
// compute price multipler
var rate = 1.0 + GetRoomOccupancyRate(type, date);
return((int)Math.Ceiling(baseRate * rate));
}
public int GetRealOccupancyByTypeDate(ROOM_TYPE type, DateTime date)
{
date = date.Date;
return(_context.Reservations.Count(rsv => rsv.EndDate >= date &&
rsv.CheckInDate != null &&
rsv.CheckOutDate == null));
}
public void SetRoomPreference(Guid profileId, ROOM_TYPE roomType)
{
Profile profile = _profileRepository.GetProfile(profileId);
profile.PreferredRoomType = roomType;
_profileRepository.UpdateProfile(profile);
}
public static string Type2String(ROOM_TYPE type)
{
if (ROOM_TYPE.MAP_EDITOR > type || (int)type >= typeStringKey.Length)
{
return(string.Empty);
}
return(StringMgr.Instance.Get(typeStringKey[(int)type]));
}
/// <summary>
/// Update description of the room type
/// </summary>
/// <param name="type">Room type of ROOM_TYPE</param>
/// <param name="description">Description string</param>
/// <returns>true if succeeded</returns>
public void UpdateRoomDescription(ROOM_TYPE type, string description)
{
RoomType room = _roomRepository.GetRoomType(type);
room.Description = description;
_roomRepository.UpdateRoom(room);
_roomRepository.Save();
}
public async Task <int> GetAveragePriceAsync(ROOM_TYPE type, DateTime checkIn, DateTime checkOut)
{
var priceList = await GetRoomPriceListAsync(type, checkIn, checkOut);
var total = priceList.Sum();
return(total / (checkOut - checkIn).Days);
}
//-----------------------------------------------------------------
// Use this for Class Initialize
public Mapinfo()
{
Pos = Vector2.zero;
Connect = new Bridge();
MapType = new MAP_TYPE();
RoomType = new ROOM_TYPE();
prevCount = 0;
FX = GameManager.Instance.SoundManager;
}
// TODO
public string GetRoomTypeName(ROOM_TYPE type)
{
var idx = (int)type;
if (idx < 0 || idx >= NameString.ROOM_TYPE_NAME.Count())
{
return("Invalid Room Type");
}
return(NameString.ROOM_TYPE_NAME[idx]);
}
/// <summary>
/// Create a new Reservation.
/// </summary>
/// <param name="username">The username used to make this reservation</param>
/// <param name="type">ROOM_TYPE</param>
/// <param name="start">check-in date</param>
/// <param name="end">check-out date</param>
/// <param name="guests">list of guests attending</param>
/// <param name="prices">list of prices for each day of the reservation</param>
/// <returns>the Id of the created reservation</returns>
public Guid MakeReservation(string username, ROOM_TYPE type, DateTime start, DateTime end,
List <Guest> guests, List <int> prices)
{
var dailyPriceList = new List <DailyPrice>();
Guid rsvId = Guid.NewGuid();
DateTime curDate = start;
foreach (var price in prices)
{
dailyPriceList.Add(new DailyPrice
{
Id = Guid.NewGuid(),
Date = curDate,
BillingPrice = price
});
curDate = curDate.AddDays(1);
}
var reservation = new Reservation
{
Id = rsvId,
StartDate = start,
EndDate = end,
Guests = guests,
IsPaid = true,
IsCancelled = false,
DailyPrices = dailyPriceList,
RoomType = type
};
if (username != null)
{
_reservationRepository.InsertReservationWithAspnetUser(reservation, username);
_reservationRepository.Save();
}
else
{
_reservationRepository.InsertReservation(reservation);
_reservationRepository.Save();
}
// update room occupancy
DateTime checkDate = start.Date;
while (checkDate.Date.CompareTo(reservation.EndDate.Date) < 0)
{
_roomRepository.UpdateRoomOccupancy(reservation.RoomType, checkDate, 1);
checkDate = checkDate.AddDays(1);
}
_roomRepository.Save();
return(rsvId);
}
private List <GuestViewModel> GetEmptyGuestModelList(ROOM_TYPE type)
{
var guests = new List <GuestViewModel>();
var guestMaxCount = type == ROOM_TYPE.DoubleBedRoom || type == ROOM_TYPE.Suite ? 4 : 2;
for (var i = 0; i < guestMaxCount; i++)
{
guests.Add(new GuestViewModel {
Id = Guid.NewGuid(), Order = i
});
}
return(guests);
}
/// <summary>
/// Return true if the roomType is available for roomAmount rooms during [CheckIn, endDateTime).
/// </summary>
/// <param name="type"></param>
/// <param name="startDateTime"></param>
/// <param name="endDateTime"></param>
/// <param name="roomAmount"></param>
/// <returns></returns>
private bool IsRoomAvailableForNRoom(ROOM_TYPE type, DateTime startDateTime, DateTime endDateTime,
int roomAmount)
{
DateTime checkDate = startDateTime.Date;
while (checkDate.CompareTo(endDateTime.Date) < 0)
{
if (GetCurrentRoomAvailability(type, checkDate) < roomAmount)
{
return(false);
}
checkDate = checkDate.AddDays(1);
}
return(true);
}
/// <summary>
/// Sets the selected room of the controller
/// </summary>
public void SetSelectedRoom()
{
ROOM_TYPE rt = (ROOM_TYPE)RoomInfo.customProperties [RoomLevelHelper.CUSTOM_ROOM_PROPERTY_ROOM_TYPE];
if (rt == ROOM_TYPE.COOP)
{
CoopLobbyController.CLC.SetSelectedRoom(RoomInfo);
}
else
{
PvPLobbyManager.SINGLETON.SetSelectedRoom(RoomInfo);
}
//toggle-like look
_btn.image.color = _btn.colors.pressedColor;
UIRL.DeselectAllRooms();
}
/// <summary>
/// Update room inventory quantity. Will first validate the new quantity
/// by chekcing the minimum occupancy of the specific room type: if the
/// new quantity value is invalid, it will throw ArgumentOutOfRangeException
/// </summary>
/// <param name="type">room type</param>
/// <param name="quantity">new value of inventory quantity</param>
public void UpdateRoomInventory(ROOM_TYPE type, int quantity)
{
RoomType room = _roomRepository.GetRoomType(type);
var currentQuantity = _roomRepository.GetRoomTotalAmount(type);
if (quantity < currentQuantity)
{
var maxOccupancy =
_roomRepository.GetMaxRoomOccupanciesByRoomTypeAfterDate(type, DateTimeHandler.GetCurrentDate());
if (maxOccupancy > quantity)
{
throw new ArgumentOutOfRangeException(
"new room inventory cannot be smaller than the occupied room amount");
}
}
room.Inventory = quantity;
_roomRepository.UpdateRoom(room);
_roomRepository.Save();
}
public async Task <List <int> > GetRoomPriceListAsync(ROOM_TYPE type, DateTime startDateTime, DateTime endDateTime)
{
if (startDateTime == null || endDateTime == null)
{
throw new ArgumentException("null check-in date or check-out date");
}
if (startDateTime >= endDateTime)
{
throw new ArgumentException("check-in date later then check-out date");
}
var priceList = new List <int>();
DateTime checkDate = startDateTime.Date;
int baseRate = _roomRepository.GetRoomType(type).BaseRate;
while (checkDate.CompareTo(endDateTime.Date) < 0)
{
priceList.Add(GetRoomPrice(type, baseRate, checkDate));
checkDate = checkDate.AddDays(1);
}
return(priceList);
}
public Room(Room src)
{
locked = src.Locked;
no = src.No;
title = src.Title;
type = src.Type;
status = src.Status;
curPlayer = src.CurPlayer;
maxPlayer = src.MaxPlayer;
map = src.map;
curMapAlias = src.curMapAlias;
goal = src.goal;
timelimit = src.timelimit;
weaponOption = src.weaponOption;
ping = src.ping;
score1 = src.score1;
score2 = src.score2;
CountryFilter = src.CountryFilter;
isBreakInto = src.isBreakInto;
isDropItem = src.isDropItem;
isWanted = src.isWanted;
squad = src.squad;
squadCounter = src.squadCounter;
}
public Room(bool isLocked, int roomNo, string roomTitle, ROOM_TYPE roomType, ROOM_STATUS roomStatus, int cur, int max, int mapId, string alias, int roomGoal, int roomTimelimit, int RoomWeaponOption, int RoomPing, int RoomScore1, int RoomScore2, int countryFilter, bool breakInto, bool wanted, bool dropItem, int _squad, int _squadCounter)
{
locked = isLocked;
no = roomNo;
title = roomTitle;
type = roomType;
status = roomStatus;
curPlayer = cur;
maxPlayer = max;
map = mapId;
curMapAlias = alias;
goal = roomGoal;
timelimit = roomTimelimit;
weaponOption = RoomWeaponOption;
ping = RoomPing;
score1 = RoomScore1;
score2 = RoomScore2;
CountryFilter = countryFilter;
isBreakInto = breakInto;
isWanted = wanted;
isDropItem = dropItem;
squad = _squad;
squadCounter = _squadCounter;
}
static List <Vector2> GenerateRoomVertices(Vector2 p, ROOM_TYPE type)
{
List <Vector2> verts = new List <Vector2>();
float roomScale = 1;
float noiseScale = 0.05f;
int nVertices = 40;
float degPadd = (360f / nVertices);
float deg = 125;
float rx = Random.Range(1f, 1.5f);
float ry = Random.Range(1f, 1.5f);
for (int i = 0; i < nVertices; i++, deg += degPadd)
{
float x = Mathf.Cos(deg * Mathf.Deg2Rad);
float y = Mathf.Sin(deg * Mathf.Deg2Rad);
Vector2 roomPoint = new Vector2(x * rx, y * ry);
float noiseModifier = PerlinNoise2D.GenerateNoise(x + p.x, y + p.y, .05f, 2);
noiseModifier = (noiseModifier - .5f) * 2 * noiseScale;
verts.Add(p + roomPoint * roomScale + (roomPoint * noiseModifier));
}
return(verts);
}
public void SetTileState(int x, int y, ROOM_TYPE state)
{
tiles[x, y].data.roomType = state;
}
// obsolete. duplicated with UpdateRoomInventory()
///// <summary>
///// Set room inventory
///// </summary>
///// <param name="type">Room type of ROOM_TYPE</param>
///// <param name="amount">Room amount</param>
///// <returns>true if succeeded</returns>
//void SetRoomInventory(ROOM_TYPE type, int amount)
//{
//}
/// <summary>
/// Get room inventory
/// </summary>
/// <param name="type">Room type of ROOM_TYPE</param>
/// <returns>number of rooms</returns>
public int GetRoomInventory(ROOM_TYPE type)
{
return(_roomRepository.GetRoomType(type).Inventory);
}
/// <summary>
/// Get description of the room type
/// </summary>
/// <param name="type">Room type of ROOM_TYPE</param>
/// <returns>description string</returns>
public string GetRoomDescription(ROOM_TYPE type)
{
return(_roomRepository.GetRoomType(type).Description);
}
/// <summary>
/// Return true if the RoomType is available during [startDateTime, endDateTime).
/// </summary>
/// <param name="type">RoomType instance</param>
/// <param name="startDateTime">check-in date</param>
/// <param name="endDateTime">check-out date</param>
/// <returns></returns>
public bool IsAvailable(ROOM_TYPE type, DateTime startDateTime, DateTime endDateTime)
{
return(IsRoomAvailableForNRoom(type, startDateTime, endDateTime, 1));
}
public int GetAveragePrice(ROOM_TYPE type, DateTime checkIn, DateTime checkOut)
{
var total = GetRoomPriceList(type, checkIn, checkOut).Sum();
return(total / (checkOut - checkIn).Days);
}
/// <summary>
/// Get room ameneties for the room type
/// </summary>
/// <param name="type">Room type of ROOM_TYPE</param>
/// <returns>Ameneties string</returns>
public string GetRoomAmeneties(ROOM_TYPE type)
{
return(_roomRepository.GetRoomType(type).Ameneties);
}
/// <summary>
/// Get room picture urls
/// </summary>
/// <param name="type">Room type of ROOM_TYPE</param>
/// <returns>url list</returns>
public string GetRoomPictureUrls(ROOM_TYPE type)
{
//TODO return a url or a list?
return(_roomRepository.GetRoomType(type).ImageUrl);
}
