public Task(Guid taskID, PlaceInfo place, Product product, decimal qty, PlaceAction action)
{
TaskID = taskID;
Place = place;
Product = product;
Qty = qty;
Action = action;
}
public void Run_ShouldNotSetPositionOrDirection_IfDirectionNone()
{
var action = new PlaceAction(_robot, _mapProviderMock.Object, new BidimensionalPoint(2, 1), Direction.None);
action.Run();
Assert.Null(_robot.Position);
Assert.Equal(Direction.None, _robot.Direction);
}
public void Run_ShouldNotSetPositionOrDirection_IfPositionNotValid()
{
_mapProviderMock.Setup(mapProvider => mapProvider.IsPositionAvailable(It.IsAny <IPosition>())).Returns(false);
var action = new PlaceAction(_robot, _mapProviderMock.Object, new BidimensionalPoint(2, 1), Direction.North);
action.Run();
Assert.Null(_robot.Position);
Assert.Equal(Direction.None, _robot.Direction);
}
public void Place(int index)
{
var action = new PlaceAction()
{
SessionID = GameManager.instance.currentSession,
Index = index,
};
ProcessAction(action);
}
public void Run_ShouldSetPositionAndDirection()
{
_mapProviderMock.Setup(mapProvider => mapProvider.IsPositionAvailable(It.IsAny <IPosition>())).Returns(true);
var action = new PlaceAction(_robot, _mapProviderMock.Object, new BidimensionalPoint(2, 1), Direction.North);
action.Run();
Assert.Equal(Direction.North, _robot.Direction);;
Assert.Equal(2, _robot.Position.Latitude);
Assert.Equal(1, _robot.Position.Longitude);
}
public void Run_ShouldkeepPreviousPositionOrDirection_IfNotValid()
{
var position = new BidimensionalPoint(1, 3);
_robot.Position = position;
_robot.Direction = Direction.East;
_mapProviderMock.Setup(mapProvider => mapProvider.IsPositionAvailable(It.IsAny <IPosition>())).Returns(false);
var action = new PlaceAction(_robot, _mapProviderMock.Object, new BidimensionalPoint(2, 1), Direction.West);
action.Run();
Assert.Equal(position, _robot.Position);
Assert.Equal(Direction.East, _robot.Direction);
}
public static PlaceResult PlaceFromGameBin(EditTownModel ths, UIBinInfo info, ulong lotId, PlaceAction action)
{
PlaceResult contentFailure = PlaceResult.ContentFailure;
Lot lot = LotManager.GetLot(lotId);
if (lot == null)
{
return PlaceResult.InvalidLot;
}
else if (lot.Household != null)
{
return PlaceResult.HouseholdPresent;
}
ths.GetInWorldHouseholdBinInfoList();
contentFailure = PlaceResult.ContentFailure;
if (info.HouseholdId != ulong.MaxValue)
{
BinCommon.KickSimsOffLot(lot, true);
if (info.LotId != ulong.MaxValue)
{
contentFailure = BinCommonEx.PlaceHouseholdAndContentsFromGameBin(info.ContentId, lot, action, Mover.GetLotCost);
}
else
{
contentFailure = BinCommonEx.PlaceHouseholdFromGameBin(info.ContentId, lot, action, Mover.GetLotCost);
}
if (contentFailure != PlaceResult.Success)
{
return contentFailure;
}
ths.mGameBin.Remove(info);
if (ths.GameBinChanged != null)
{
ths.GameBinChanged(ths, null);
}
info = BinCommon.CreateInWorldBinInfo(lot.Household, lot);
if (info != null)
{
ths.mInWorldHouseholdBin.Add(info);
}
}
return contentFailure;
}
public void placingPhase()
{
PlaceAction act = PlaceAction.Place;
while (referee.inPlacing(xPlayer, oPlayer) || act == PlaceAction.Shoot)
{
gameBoard.Display($@"X stones:{xPlayer.stones} O stones:{oPlayer.stones}");
if (act == PlaceAction.Place)
{
switch (gameBoard.Place(currPlayer, referee))
{
case PlaceResult.Invalid: break;
case PlaceResult.Done:
if (currPlayer == xPlayer)
{
currPlayer = oPlayer;
}
else
{
currPlayer = xPlayer;
}
break;
case PlaceResult.MillMade: act = PlaceAction.Shoot; break;
}
}
else
{
if (gameBoard.Shoot(currPlayer, referee) == ShootResult.Done)
{
act = PlaceAction.Place;
if (currPlayer == xPlayer)
{
currPlayer = oPlayer;
}
else
{
currPlayer = xPlayer;
}
}
}
}
}
protected virtual void ProcessPlaceAction(PlaceAction action, List <StackResponseContainerInfo> stackResponses)
{
byte count = action.Count;
Item sourceItem;
Item destItem;
StackRequestSlotInfo source = action.Source;
StackRequestSlotInfo destination = action.Destination;
sourceItem = GetContainerItem(source.ContainerId, source.Slot);
if (sourceItem.Count == count || sourceItem.Count - count <= 0)
{
destItem = sourceItem;
sourceItem = new ItemAir();
sourceItem.UniqueId = 0;
SetContainerItem(source.ContainerId, source.Slot, sourceItem);
}
else
{
destItem = (Item)sourceItem.Clone();
sourceItem.Count -= count;
destItem.Count = count;
destItem.UniqueId = Environment.TickCount & Int32.MaxValue;
}
Item existingItem = GetContainerItem(destination.ContainerId, destination.Slot);
if (existingItem.UniqueId > 0) // is empty/air is what this means
{
existingItem.Count += count;
destItem = existingItem;
}
else
{
SetContainerItem(destination.ContainerId, destination.Slot, destItem);
}
if (destination.ContainerId == 21 || destination.ContainerId == 22)
{
if (!(GetContainerItem(21, 14) is ItemAir) && !(GetContainerItem(22, 15) is ItemAir))
{
Enchantment.SendEnchantments(_player, GetContainerItem(21, 14));
}
else
{
Enchantment.SendEmptyEnchantments(_player);
}
}
stackResponses.Add(new StackResponseContainerInfo
{
ContainerId = source.ContainerId,
Slots = new List <StackResponseSlotInfo>
{
new StackResponseSlotInfo()
{
Count = sourceItem.Count,
Slot = source.Slot,
HotbarSlot = source.Slot,
StackNetworkId = sourceItem.UniqueId
}
}
});
stackResponses.Add(new StackResponseContainerInfo
{
ContainerId = destination.ContainerId,
Slots = new List <StackResponseSlotInfo>
{
new StackResponseSlotInfo()
{
Count = destItem.Count,
Slot = destination.Slot,
HotbarSlot = destination.Slot,
StackNetworkId = destItem.UniqueId
}
}
});
}
public static PlaceResult PlaceFromGameBin(EditTownModel ths, UIBinInfo info, ulong lotId, PlaceAction action)
{
PlaceResult contentFailure = PlaceResult.ContentFailure;
Lot lot = LotManager.GetLot(lotId);
if (lot == null)
{
return(PlaceResult.InvalidLot);
}
else if (lot.Household != null)
{
return(PlaceResult.HouseholdPresent);
}
ths.GetInWorldHouseholdBinInfoList();
contentFailure = PlaceResult.ContentFailure;
if (info.HouseholdId != ulong.MaxValue)
{
BinCommon.KickSimsOffLot(lot, true);
if (info.LotId != ulong.MaxValue)
{
contentFailure = BinCommonEx.PlaceHouseholdAndContentsFromGameBin(info.ContentId, lot, action, Mover.GetLotCost);
}
else
{
contentFailure = BinCommonEx.PlaceHouseholdFromGameBin(info.ContentId, lot, action, Mover.GetLotCost);
}
if (contentFailure != PlaceResult.Success)
{
return(contentFailure);
}
ths.mGameBin.Remove(info);
if (ths.GameBinChanged != null)
{
ths.GameBinChanged(ths, null);
}
info = BinCommon.CreateInWorldBinInfo(lot.Household, lot);
if (info != null)
{
ths.mInWorldHouseholdBin.Add(info);
}
}
return(contentFailure);
}
public static PlaceResult PlaceFromExportBin(EditTownModel ths, UIBinInfo info, ulong lotId, PlaceAction action, bool showConfirmDialog)
{
try
{
PlaceResult contentFailure = PlaceResult.ContentFailure;
Lot lot = LotManager.GetLot(lotId);
if (lot == null)
{
return(PlaceResult.InvalidLot);
}
ExportBinContents exportBinItem = ths.FindExportBinContents(info.ContentId);
if (exportBinItem != null)
{
ths.GetInWorldHouseholdBinInfoList();
ths.GetInWorldLotBinInfoList();
Sim newActiveSim = null;
if (lot.Household != null)
{
return(BinCommonEx.MergeHouseholdFromExportBin(exportBinItem, lot, showConfirmDialog, Mover.Settings.mAllowGreaterThanEight));
}
BinCommon.KickSimsOffLot(lot, true);
ProgressDialog.Show(Localization.LocalizeString("Ui/Caption/Global:Processing", new object[0x0]));
try
{
try
{
contentFailure = BinCommonEx.PlaceFromExportBin(exportBinItem, lot, action, true, Mover.GetLotCost, ref newActiveSim);
ExportBinContentsEx.Flush(exportBinItem);
UIBinInfo item = BinCommon.CreateInWorldBinInfo(lot.Household, lot);
if (item != null)
{
if (info.HouseholdId != ulong.MaxValue)
{
ths.mInWorldHouseholdBin.Add(item);
}
else
{
ths.mInWorldLotBin.Add(item);
}
}
}
finally
{
ProgressDialog.Close();
}
}
catch (ExecutionEngineException)
{ }
}
return(contentFailure);
}
catch (Exception e)
{
Common.Exception("PlaceFromExportBin", e);
return(PlaceResult.ContentFailure);
}
}
public static PlaceResult PlaceFromExportBin(ExportBinContents exportBinItem, Lot lot, PlaceAction action, bool buyFurnished, GetLotCost onLotCost, ref Sim newActiveSim)
{
if (exportBinItem == null)
{
return(PlaceResult.ContentFailure);
}
bool flag = exportBinItem.IsLoaded();
if (!flag)
{
ExportBinContentsEx.Import(exportBinItem, false);
}
PlaceResult result = PlaceFromExportBin(exportBinItem.Household, exportBinItem, lot, action, buyFurnished, onLotCost, ref newActiveSim);
if (!flag)
{
ExportBinContentsEx.Flush(exportBinItem);
}
return(result);
}
private void Update()
{
UpdateTalking();
UpdateAudio();
InputX = Input.GetAxis(MoveAxisX);
InputY = Input.GetAxis(MoveAxisY);
InputAction = Input.GetButtonDown(ActionButton);
InputTogglePlaceAction = Input.GetButtonDown(TogglePlaceActionButton);
InputToggleLeft = Input.GetButtonDown(ToggleLeftButton);
InputToggleRight = Input.GetButtonDown(ToggleRightButton);
if (PlaceMode)
{
if (PlaceAction == PlaceAction.Buy)
{
if (CurrentPlaceable)
{
CurrentPlaceable.gameObject.SetActive(true);
}
if (InputToggleRight)
{
NextPlaceable();
}
else if (InputToggleLeft)
{
PreviousPlaceable();
}
}
else
{
if (CurrentPlaceable)
{
CurrentPlaceable.gameObject.SetActive(false);
}
}
if (InputAction)
{
HandlePlaceAction();
}
else if (InputTogglePlaceAction)
{
// Cycle to next enum
PlaceAction =
(PlaceAction)(((int)PlaceAction + 1) % Enum.GetNames(typeof(PlaceAction)).Length);
}
}
else
{
if (InputAction)
{
if (TargetEnemy)
{
HandleEnemy(TargetEnemy);
}
}
UpdateEnergy();
}
UpdateTooltip();
}
public static PlaceResult PlaceFromExportBin(EditTownModel ths, UIBinInfo info, ulong lotId, PlaceAction action, bool showConfirmDialog)
{
try
{
PlaceResult contentFailure = PlaceResult.ContentFailure;
Lot lot = LotManager.GetLot(lotId);
if (lot == null)
{
return PlaceResult.InvalidLot;
}
ExportBinContents exportBinItem = ths.FindExportBinContents(info.ContentId);
if (exportBinItem != null)
{
ths.GetInWorldHouseholdBinInfoList();
ths.GetInWorldLotBinInfoList();
Sim newActiveSim = null;
if (lot.Household != null)
{
return BinCommonEx.MergeHouseholdFromExportBin(exportBinItem, lot, showConfirmDialog, Mover.Settings.mAllowGreaterThanEight);
}
BinCommon.KickSimsOffLot(lot, true);
ProgressDialog.Show(Localization.LocalizeString("Ui/Caption/Global:Processing", new object[0x0]));
try
{
try
{
contentFailure = BinCommonEx.PlaceFromExportBin(exportBinItem, lot, action, true, Mover.GetLotCost, ref newActiveSim);
ExportBinContentsEx.Flush(exportBinItem);
UIBinInfo item = BinCommon.CreateInWorldBinInfo(lot.Household, lot);
if (item != null)
{
if (info.HouseholdId != ulong.MaxValue)
{
ths.mInWorldHouseholdBin.Add(item);
}
else
{
ths.mInWorldLotBin.Add(item);
}
}
}
finally
{
ProgressDialog.Close();
}
}
catch (ExecutionEngineException)
{ }
}
return contentFailure;
}
catch (Exception e)
{
Common.Exception("PlaceFromExportBin", e);
return PlaceResult.ContentFailure;
}
}
public static PlaceResult PlaceFromExportBin(EditTownModel ths, UIBinInfo info, ulong lotId, PlaceAction action)
{
return PlaceFromExportBin(ths, info, lotId, action, true);
}
public static PlaceResult PlaceFromExportBin(Household household, ExportBinContents exportBinItem, Lot lot, PlaceAction action, bool buyFurnished, GetLotCost onLotCost, ref Sim newActiveSim)
{
if (household == null)
{
return(PlaceResult.InvalidBinHousehold);
}
else if (lot == null)
{
return(PlaceResult.InvalidLot);
}
else if (exportBinItem == null)
{
return(PlaceResult.ContentFailure);
}
bool flag = exportBinItem.IsLoaded();
if (!flag)
{
ExportBinContentsEx.Import(exportBinItem, false);
}
PlaceResult contentFailure = PlaceResult.ContentFailure;
if (household != null)
{
if (((action & PlaceAction.PlaceAndPay) != PlaceAction.PlaceOnly) && !PayForLot(household, lot, buyFurnished, onLotCost))
{
if (!flag)
{
ExportBinContentsEx.Flush(exportBinItem);
}
Household.CleanupOldIdToNewSimDescriptionMap();
return(PlaceResult.InsufficientFunds);
}
if ((!buyFurnished) && (!lot.IsApartmentLot))
{
lot.MakeLotUnfurnished();
Common.Sleep();
lot.UpdateCachedValues();
}
CreateActors(household, lot, false);
CreateInventories(household, exportBinItem.HouseholdContents, exportBinItem.IndexMap);
Common.Sleep();
BinCommon.UpdateImportedUrnstones(household, lot);
household.PostImport();
if ((action & PlaceAction.MoveIn) != PlaceAction.PlaceOnly)
{
BinCommon.MoveIn(household, lot);
}
if ((action & PlaceAction.Activate) != PlaceAction.PlaceOnly)
{
newActiveSim = BinCommon.ActivateSim(exportBinItem.Household, lot);
}
ThumbnailManager.GenerateHouseholdThumbnail(household.HouseholdId, household.HouseholdId, ThumbnailSizeMask.Large | ThumbnailSizeMask.Medium);
contentFailure = PlaceResult.Success;
}
if (!flag)
{
ExportBinContentsEx.Flush(exportBinItem);
}
return(contentFailure);
}
public static PlaceResult PlaceFromExportBin(EditTownModel ths, UIBinInfo info, ulong lotId, PlaceAction action)
{
return(PlaceFromExportBin(ths, info, lotId, action, true));
}
public static PlaceResult PlaceHouseholdAndContentsFromGameBin(ulong contentId, Lot lot, PlaceAction action, GetLotCost onLotCost)
{
LotContents lotContents = Bin.Singleton.FindLot(contentId);
if (lotContents != null)
{
Household household = lotContents.Household.Household;
if (household != null)
{
if (((action & PlaceAction.PlaceAndPay) != PlaceAction.PlaceOnly) && !PayForLot(household, lot, true, onLotCost))
{
return(PlaceResult.InsufficientFunds);
}
CreateActors(household, lot, false);
CreateInventories(lotContents.Household);
if ((action & PlaceAction.MoveIn) != PlaceAction.PlaceOnly)
{
BinCommon.MoveIn(household, lot);
}
Bin.Singleton.RemoveLotFromGameBin(lotContents);
return(PlaceResult.Success);
}
}
return(PlaceResult.ContentFailure);
}
