public void GetSlmmMoveDirectionNotImplementedtest()
{
var slmmMoveDirectionFactoryService = ObjectsContainer.GetObject <ISlmmMoveDirectionFactoryService>();
Assert.That(() => slmmMoveDirectionFactoryService.GetSlmmMoveDirection(DirectionEnum.Direction.SouthEast),
Throws.Exception.TypeOf <Exception>().With.Property("Message").EqualTo("Slmm Move not implemented for Direction : SouthEast"));
}
public void TestSingleDecor()
{
var container = new ObjectsContainer();
container.AddDecor(new Chair());
Assert.True(container.ShowDecor() is Chair);
}
public void TestNotSolid()
{
var container = new ObjectsContainer();
container.AddDecor(new Carpet());
Assert.False(container.IsSolid);
}
public void TestObjectReferenceSameInstance()
{
var nodeContainer = new NodeContainer();
var instance = new TestObject {
Name = "Test"
};
var container = new ObjectsContainer {
Instance1 = instance, Instance2 = instance
};
var containerNode = nodeContainer.GetOrCreateNode(container);
Helper.TestNonCollectionObjectNode(containerNode, container, 2);
var member1Node = containerNode.Members.First();
Helper.TestMemberNode(containerNode, member1Node, container, instance, nameof(ObjectsContainer.Instance1), true);
Helper.TestNonNullObjectReference(member1Node.TargetReference, instance, false);
var member2Node = containerNode.Members.Last();
Helper.TestMemberNode(containerNode, member2Node, container, instance, nameof(ObjectsContainer.Instance2), true);
Helper.TestNonNullObjectReference(member2Node.TargetReference, instance, false);
var reference1 = member1Node.TargetReference;
var reference2 = member2Node.TargetReference;
Assert.Equal(reference1.TargetGuid, reference2.TargetGuid);
Assert.Equal(reference1.TargetNode, reference2.TargetNode);
Assert.Equal(reference1.ObjectValue, reference2.ObjectValue);
}
public Cell(string background)
{
Enum.TryParse(background, true, out CellType type);
Type = type;
Creature = null;
ObjectContainer = new ObjectsContainer();
}
public void TestObjectReferenceSameInstance()
{
var nodeContainer = new NodeContainer();
var instance = new TestObject {
Name = "Test"
};
var container = new ObjectsContainer {
Instance1 = instance, Instance2 = instance
};
var containerNode = nodeContainer.GetOrCreateNode(container);
Helper.TestObjectContentNode(containerNode, container, 2);
var member1Node = containerNode.Children.First();
Helper.TestMemberContentNode(containerNode, member1Node, container, instance, nameof(ObjectsContainer.Instance1), true);
Helper.TestNonNullObjectReference(member1Node.Content.Reference, instance);
var member2Node = containerNode.Children.Last();
Helper.TestMemberContentNode(containerNode, member2Node, container, instance, nameof(ObjectsContainer.Instance2), true);
Helper.TestNonNullObjectReference(member2Node.Content.Reference, instance);
var reference1 = member1Node.Content.Reference.AsObject;
var reference2 = member2Node.Content.Reference.AsObject;
Assert.AreEqual(reference1.TargetGuid, reference2.TargetGuid);
Assert.AreEqual(reference1.TargetNode, reference2.TargetNode);
Assert.AreEqual(reference1.ObjectValue, reference2.ObjectValue);
}
public void TestSolid()
{
var container = new ObjectsContainer();
container.AddDecor(new Chair());
Assert.True(container.IsSolid);
}
public void TestTransparency()
{
var container = new ObjectsContainer();
container.AddDecor(new Table());
container.AddDecor(new Vase());
Assert.False(container.IsOpaque);
}
public void TestOpacity()
{
var container = new ObjectsContainer();
container.AddDecor(new Wall());
container.AddDecor(new PaintingFlowers());
Assert.True(container.IsOpaque);
}
public void TestDecorsOrded()
{
var container = new ObjectsContainer();
container.AddDecor(new PaintingFlowers());
container.AddDecor(new Wall());
Assert.True(container.ShowDecor() is PaintingFlowers);
}
static void Main(string[] args)
{
StartUp.SlmmContainer.Configure(x => x.For <IMowerApiHttpClient>().Use <MowerApiHttpClient>()
.Ctor <string>("basePath").Is(@"http://localhost:61177"));
var httpClient = ObjectsContainer.GetObject <IMowerApiHttpClient>();
var mower = new SmartMowerMachine(1, 1, 10, 10, DirectionEnum.Direction.East);
httpClient.Turn90AntiClockwise(mower);
}
public void GetSlmmMoveDirectiontest(DirectionEnum.Direction direction, string expectedType)
{
var mowerApiHttpClientMock = new Mock <IMowerApiHttpClient>();
ObjectsContainer.InjectObject <IMowerApiHttpClient>(mowerApiHttpClientMock.Object);
var slmmMoveDirectionFactoryService = ObjectsContainer.GetObject <ISlmmMoveDirectionFactoryService>();
var res = slmmMoveDirectionFactoryService.GetSlmmMoveDirection(direction);
Assert.AreEqual(expectedType, res.GetType().ToString());
}
void Start()
{
myRoom = GetComponentInParent <ObjectsContainer>();
rnd = new System.Random(myRoom.Seed);
foreach (Pillar p in pillars)
{
p.SetPillarsRoomManager(this);
}
GenerateSolution();
GenerateGUIPaths();
}
public static MesUnit [] GetByItem(Item item)
{
ObjectsContainer <string, string> ret = BusinessDomain.DataAccessProvider.GetUnitsForItem(item.Id);
return(ret != null ?
new [] { new MesUnit {
Name = ret.Value1
}, new MesUnit {
Name = ret.Value2
} } :
new MesUnit [0]);
}
/// <summary>
/// When a new game is launched
/// </summary>
public void SwitchToGame()
{
BeforeSwitch();
AddNewGameObject(new GameBackground());
ObjectsContainer objectsContainer = new ObjectsContainer();
AddNewGameObject(objectsContainer);
AddNewGameObject(new UserLife(objectsContainer.User));
}
private void Start()
{
if (instance == null)
{
instance = this;
}
else
{
Destroy(gameObject);
}
DontDestroyOnLoad(gameObject);
}
public override void Generate(int seed, bool isPlayer2)
{
rnd = new System.Random(seed);
_regions = new List <Region>();
TileList = new List <Tile>();
Wall = new List <Tile>();
Floor = new List <Tile>();
Spawn = new List <Tile>();
Decoration = new List <Tile>();
Entrance = new List <Tile>();
Exit = new List <Tile>();
diaryImageList = new List <Image>();
_occupiedTile = new List <Vector3Int>();
_otherRoomCellsStack = new Stack <Cell>();
_actualRoomCellsStack = new Stack <Cell>();
_cellMap = new Dictionary <int, Cell>();
_listCheckpoints = new List <List <GameObject> >();
_roomList = new List <Room>();
_isPlayer2 = isPlayer2;
_mazeTransform = new GameObject("RoomMaze").transform;
ObjectsContainer objectsContainer = _mazeTransform.gameObject.AddComponent <ObjectsContainer>();
objectsContainer.Seed = seed;
Random.InitState(seed);
rnd = new System.Random(seed);
int random;
while ((random = Random.Range(_minSetSpace, maxSpace)) % 3 != 0)
{
;
}
_sizeX = _minSetSpace; //TODO return to random value
_sizeY = _minSetSpace;
_requiredWidthSpace = _sizeX + 2; //due to the walls
GenerateInternal();
FindRoomNeighbor();
ReshapeRooms();
ReshapeRooms();
ConnectNeighbor();
GenerateTile();
GenerateWall();
SpawnAgent();
removeOverlappingWallsAndFloor();
SpawnResetLever();
_lowestX = -1;//these are due to the presence of the wall
_lowestY = -1;
}
public void test(int currentX, int currentY, int maxX, int maxY, DirectionEnum.Direction direction, bool clockwise, int expectedCurrentX, bool expectedClockwise)
{
//Arrange
var slmmService = ObjectsContainer.GetObject <ISlmmService>();
slmmService.SmartMower = new SmartMowerMachine(currentX, currentY, maxX, maxY, direction);
slmmService.Clockwise = clockwise;
var xCoordinateService = ObjectsContainer.GetObject <IXCoordinateService>();
//Act
xCoordinateService.CheckXValues(slmmService);
//Assert
Assert.AreEqual(expectedCurrentX, slmmService.SmartMower.CurrentX);
Assert.AreEqual(expectedClockwise, slmmService.Clockwise);
}
public static void FillMap(List <List <string> > content)
{
for (var i = 0; i < content.Count; i++)
{
var background = content[i][0];
var newCell = new Cell(background);
foreach (var dec in content[i].Skip(1))
{
newCell.ObjectContainer.AddDecor(ObjectsContainer.ParseDecor(dec));
}
Map[i % Map.Wigth, i / Map.Wigth] = newCell;
NoiseController.Noises[i % Map.Wigth, i / Map.Wigth] = new HashSet <Noise>();
}
}
static void Main(string[] args)
{
var basePath = ConfigurationManager.AppSettings["baseUrl"];
if (string.IsNullOrWhiteSpace(basePath))
{
throw new Exception("Missing basePath config");
}
StartUp.SlmmContainer.Configure(x => x.For <IMowerApiHttpClient>().Use <MowerApiHttpClient>()
.Ctor <string>("basePath").Is(basePath));
var slmmService = ObjectsContainer.GetObject <ISlmmService>();
slmmService.SmartMower = new SmartMowerMachine();
slmmService.SmartMower.ReadFromConfig();
slmmService.StartMovingSlmm();
Console.ReadLine();
}
public ISlmmMove GetSlmmMoveDirection(DirectionEnum.Direction direction)
{
switch (direction)
{
case DirectionEnum.Direction.North:
return(ObjectsContainer.GetObjectByName <ISlmmMove>("SlmmMoveNorthService"));
case DirectionEnum.Direction.South:
return(ObjectsContainer.GetObjectByName <ISlmmMove>("SlmmMoveSouthService"));
case DirectionEnum.Direction.East:
return(ObjectsContainer.GetObjectByName <ISlmmMove>("SlmmMoveEastService"));
case DirectionEnum.Direction.West:
return(ObjectsContainer.GetObjectByName <ISlmmMove>("SlmmMoveWestService"));
default:
throw new Exception(String.Format("Slmm Move not implemented for Direction : {0}", direction));
}
}
public void MoveOneSteptest(int currentX, int currentY, int maxX, int maxY, DirectionEnum.Direction direction, int expectedCurrentX, int expectedCurrentY, DirectionEnum.Direction expectedDirection, int expectedClockWise90, int expectedAntiClockWise90)
{
//Arrange
var mowerHttpClientMock = new Mock<IMowerHttpClient>();
ObjectsContainer.InjectObject<IMowerHttpClient>(mowerHttpClientMock.Object);
var slmmService = ObjectsContainer.GetObject<ISlmmService>();
slmmService.SmartMower = new SmartMowerMachine(currentX, currentY, maxX, maxY, direction);
var slmmMoveService = ObjectsContainer.GetObjectByName<ISlmmMove>("SlmmMoveSouthService");
//Act
slmmMoveService.MoveOneStep(slmmService);
//Assert
Assert.AreEqual(expectedCurrentX, slmmService.SmartMower.CurrentX);
Assert.AreEqual(expectedCurrentY, slmmService.SmartMower.CurrentY);
Assert.AreEqual(expectedDirection, slmmService.SmartMower.Direction);
mowerHttpClientMock.Verify(a => a.Turn90Clockwise(slmmService.SmartMower), Times.Exactly(expectedClockWise90));
mowerHttpClientMock.Verify(a => a.Turn90AntiClockwise(slmmService.SmartMower), Times.Exactly(expectedAntiClockWise90));
}
private void MakeLaserBeam()
{
lastBullet = Instantiate(laserPrefab, shootSource.position, shootSource.rotation);
trajectory[0] = shootSource.position;
objectsContainer = lastBullet.GetComponent <ObjectsContainer>();
if (Physics.Raycast(trajectory[0], (transform.forward * maxDistance), out laserHit, maxDistance))
{
trajectory[1] = laserHit.point;
objectsContainer.objects[0].GetComponent <ScaleAnimator>().scalingTime *= 10;
}
else
{
trajectory[1] = trajectory[0] + (transform.forward * maxDistance);
}
objectsContainer.objects[0].transform.position = trajectory[1];
lineRenderer = lastBullet.GetComponentInChildren <LineRenderer>();
lineRenderer.SetPositions(trajectory);
}
public void TestObjectReferenceSameInstance()
{
var nodeContainer = new NodeContainer();
var instance = new TestObject { Name = "Test" };
var container = new ObjectsContainer { Instance1 = instance, Instance2 = instance };
var containerNode = nodeContainer.GetOrCreateNode(container);
Helper.TestNonCollectionObjectContentNode(containerNode, container, 2);
var member1Node = containerNode.Children.First();
Helper.TestMemberContentNode(containerNode, member1Node, container, instance, nameof(ObjectsContainer.Instance1), true);
Helper.TestNonNullObjectReference(member1Node.Content.Reference, instance, false);
var member2Node = containerNode.Children.Last();
Helper.TestMemberContentNode(containerNode, member2Node, container, instance, nameof(ObjectsContainer.Instance2), true);
Helper.TestNonNullObjectReference(member2Node.Content.Reference, instance, false);
var reference1 = member1Node.Content.Reference.AsObject;
var reference2 = member2Node.Content.Reference.AsObject;
Assert.AreEqual(reference1.TargetGuid, reference2.TargetGuid);
Assert.AreEqual(reference1.TargetNode, reference2.TargetNode);
Assert.AreEqual(reference1.ObjectValue, reference2.ObjectValue);
}
private bool UpdateDocumentsUsage(long?maxId = null)
{
if (numbersUsagePerLocation == null ||
numbersUsageStarts == null)
{
return(false);
}
if (maxId == null)
{
maxId = Operation.GetMaxId();
}
hasEmptyRange = false;
for (int i = 0; i < allStartNumbersPerLocation.Count; i++)
{
foreach (OperationNumberingInfo numberingInfo in allStartNumbersPerLocation[i].Value)
{
long endNumber = maxId.Value;
long endRange = endNumber;
if (i + 1 < allStartNumbersPerLocation.Count)
{
OperationNumberingInfo nextInfo = allStartNumbersPerLocation [i + 1].Value.FirstOrDefault(n => n.OperationType == numberingInfo.OperationType);
if (nextInfo != null)
{
endRange = nextInfo.StartNumber - 1;
if (nextInfo.StartNumber > 0)
{
endNumber = nextInfo.StartNumber - 1;
}
}
}
long usedNumbers = 0;
long startNumber = numberingInfo.StartNumber + 1;
OperationNumbersUsage usage = numbersUsagePerLocation.FirstOrDefault(n => numberingInfo.LocationId == n.LocationId && numberingInfo.OperationType == n.OperationType);
if (usage != null)
{
usedNumbers = usage.UsedNumbers;
startNumber = Math.Max(startNumber, usage.LastUsedNumber);
}
ObjectsContainer <OperationType, long> firtNextNumber = numbersUsageStarts.FirstOrDefault(n => numberingInfo.StartNumber < n.Value2 && numberingInfo.OperationType == n.Value1);
if (firtNextNumber != null)
{
endNumber = Math.Min(endNumber, firtNextNumber.Value2 - 1);
}
double numbersLeft = Math.Max(endNumber - startNumber, 0);
if (numbersLeft < OperationNumberingInfo.MINIMAL_NUMBERS_PER_LOCATION)
{
hasEmptyRange = true;
}
long rangeSize = Math.Max(endRange - numberingInfo.StartNumber, 0);
if (rangeSize == 0)
{
MessageError.ShowDialog(string.Format(Translator.GetString("The selected numbers parameters are not valid! Please select ranges which will generate document numbers lower than {0}."), maxId.Value.ToString("N", formatBigNumber)));
throw new ArgumentOutOfRangeException();
}
numberingInfo.Usage = (rangeSize - numbersLeft) / rangeSize;
numberingInfo.UsageDescription = string.Format(Translator.GetString("{0} used, {1} left"),
usedNumbers.ToString("N", formatBigNumber),
numbersLeft.ToString("N", formatBigNumber));
}
}
frmMessage.Visible = hasEmptyRange;
IListModel model = gridDocumentNumbers.Model;
gridDocumentNumbers.Model = null;
gridDocumentNumbers.Model = model;
return(true);
}
void Start()
{
myRoom = GetComponent <ObjectsContainer>();
rnd = new System.Random(myRoom.Seed);
shuffleOrder = new List <int> {
0, 1, 2, 3, 4, 5, 6, 7, 8
};
firstWinnerIndexes = new List <int>();
secondWinnerIndexes = new List <int>();
selectedPictures = new List <int>();
currentPicture = 0;
//Select 2 pictures from 6
while (selectedPictures.Count < 2)
{
int selectedPicture;
do
{
selectedPicture = rnd.Next(0, 6);
} while (selectedPictures.Contains(selectedPicture));
selectedPictures.Add(selectedPicture);
}
//Select the 3 winning pieces for the first picture
while (firstWinnerIndexes.Count < 3)
{
int selected;
do
{
selected = rnd.Next(0, 9);
} while (firstWinnerIndexes.Contains(selected));
firstWinnerIndexes.Add(selected);
}
//Select the 3 winning pieces for the second picture
while (secondWinnerIndexes.Count < 3)
{
int selected;
do
{
selected = rnd.Next(0, 9);
} while (secondWinnerIndexes.Contains(selected));
secondWinnerIndexes.Add(selected);
}
//Setup yhe diary
for (int i = 0; i < diaryPictures.Length; i++)
{
Transform diarypicture = diaryPictures[i].transform;
if (selectedPictures.Contains(i))
{
if (selectedPictures.IndexOf(i) == 0)
{
for (int j = 0; j < diarypicture.childCount; j++)
{
if (firstWinnerIndexes.Contains(j))
{
diarypicture.GetChild(j).gameObject.SetActive(true);
}
else
{
diarypicture.GetChild(j).gameObject.SetActive(false);
}
}
}
else if (selectedPictures.IndexOf(i) == 1)
{
for (int j = 0; j < diarypicture.childCount; j++)
{
if (secondWinnerIndexes.Contains(j))
{
diarypicture.GetChild(j).gameObject.SetActive(true);
}
else
{
diarypicture.GetChild(j).gameObject.SetActive(false);
}
}
}
}
else
{
List <int> fakeWinnerIndexes = new List <int>();
while (fakeWinnerIndexes.Count < 3)
{
int selected;
do
{
selected = rnd.Next(0, 9);
} while (fakeWinnerIndexes.Contains(selected));
fakeWinnerIndexes.Add(selected);
}
for (int j = 0; j < diarypicture.childCount; j++)
{
if (fakeWinnerIndexes.Contains(j))
{
diarypicture.GetChild(j).gameObject.SetActive(true);
}
else
{
diarypicture.GetChild(j).gameObject.SetActive(false);
}
}
}
}
SetUpRoom();
}
