Example #1
0
    private void NewRoom()
    {
        random = new System.Random(Time.realtimeSinceStartup.GetHashCode());
        if (trainingRoom != null)
        {
            Destroy(trainingRoom.gameObject);
        }
        if (setup == null)
        {
            setup = GetComponent <BootCampSetup>();
        }
        trainingRoom = setup.SetupEnvironment(random);

        var navMeshSurface = transform.parent.GetComponent <UnityEngine.AI.NavMeshSurface>();

        navMeshSurface.collectObjects = UnityEngine.AI.CollectObjects.Children;
        navMeshSurface.BuildNavMesh();
        if (navMeshHandle.valid)
        {
            UnityEngine.AI.NavMesh.RemoveNavMeshData(navMeshHandle);
        }
        navMeshHandle = UnityEngine.AI.NavMesh.AddNavMeshData(navMeshSurface.navMeshData);

        NewSimulatedPlayer();
        NewSquad();
    }
		// Token: 0x0600E0D4 RID: 57556 RVA: 0x003C9744 File Offset: 0x003C7944
		public void InitRoomToggleInfo(int roomId)
		{
			if (!BJLuaObjHelper.IsSkipLuaHotfix && this.TryInitHotFix("") && this.m_InitRoomToggleInfoInt32_hotfix != null)
			{
				this.m_InitRoomToggleInfoInt32_hotfix.call(new object[]
				{
					this,
					roomId
				});
				return;
			}
			BJLuaObjHelper.IsSkipLuaHotfix = false;
			ProjectLPlayerContext projectLPlayerContext = GameManager.Instance.PlayerContext as ProjectLPlayerContext;
			TrainingRoom trainingRoomById = projectLPlayerContext.GetTrainingRoomById(roomId);
			if (trainingRoomById == null)
			{
				return;
			}
			this.Room = trainingRoomById;
			bool locked = trainingRoomById.Locked;
			if (locked)
			{
				this.m_stateCtrl.SetToUIState("Grey", false, true);
			}
			else
			{
				this.m_stateCtrl.SetToUIState("Normal", false, true);
			}
			this.m_lvValueText.text = trainingRoomById.Level.ToString();
			this.m_toggle.interactable = !locked;
			this.m_redMark.SetActive(projectLPlayerContext.CanTrainingRoomLevelup(trainingRoomById));
		}
Example #3
0
        /// <inheritdoc cref="ITrainingRoomService.StartTrainingSessionAsync(StartTrainingSessionRequest)"/>
        public async Task <StartTrainingSessionResponse> StartTrainingSessionAsync(StartTrainingSessionRequest startTrainingSessionRequest)
        {
            Expression <Func <TrainingRoom, bool> > predicate = tr => tr.Id.Equals(startTrainingSessionRequest.TrainingRoomId);

            if (!await _trainingRoomRepository.ExistsAsync(predicate))
            {
                return(new StartTrainingSessionResponse(startTrainingSessionRequest.Id, null, "Training room does not exist."));
            }
            if (!await _userRepository.ExistsAsync(usr => usr.Id.Equals(startTrainingSessionRequest.UserId)))
            {
                return(new StartTrainingSessionResponse(startTrainingSessionRequest.Id, null, "User does not exist."));
            }

            TrainingRoom trainingRoom = await _trainingRoomRepository.FindSingleByExpressionAsync(predicate);

            if (!trainingRoom.IsUserAuthorized(startTrainingSessionRequest.UserId))
            {
                return(new StartTrainingSessionResponse(startTrainingSessionRequest.Id, null, "User is not authorized"));
            }
            if (!trainingRoom.StartTrainingSession(startTrainingSessionRequest.UserId, out TrainingSession trainingSession))
            {
                return(new StartTrainingSessionResponse(startTrainingSessionRequest.Id, null, "Failed to start a training session."));
            }

            await _trainingRoomRepository.UpdateAsync(trainingRoom);

            _trainingSessionOrganismsDictionary.TryAdd(trainingSession.Id, new ConcurrentQueue <Organism>(trainingRoom.Species.SelectMany(sp => sp.LastGenerationOrganisms)));

            TrainingSessionDto trainingSessionDto = EntityToDtoConverter.Convert <TrainingSessionDto, TrainingSession>(trainingSession);

            return(new StartTrainingSessionResponse(startTrainingSessionRequest.Id, trainingSessionDto, "Successfully started a training session.", true));
        }
Example #4
0
            public void DifferentOutputSizeTest()
            {
                Guid  id1    = Guid.NewGuid();
                Brain brain1 = new Brain(id1, _trainingRoom, new List <ConnectionGene>()
                {
                    new ConnectionGene(id1, 0, 3, 1, 1),
                    new ConnectionGene(id1, 1, 3, 1, 2, false),
                    new ConnectionGene(id1, 2, 3, 1, 3),
                    new ConnectionGene(id1, 1, 4, 1, 4),
                    new ConnectionGene(id1, 4, 3, 1, 5),
                    new ConnectionGene(id1, 0, 4, 1, 8)
                });

                Guid         id2          = Guid.NewGuid();
                TrainingRoom trainingRoom = new TrainingRoom(_fakeUser, "FakeRoom", new TrainingRoomSettings(0, 3, 2, 1, 1, 0.4, 3, 0.05, 0.03, 0.75, 0.001, 1, 0.8, 0.1, 0.5, 0.25, 0));

                Brain brain2 = new Brain(id2, trainingRoom, new List <ConnectionGene>()
                {
                    new ConnectionGene(id2, 0, 3, 1, 1),
                    new ConnectionGene(id2, 1, 3, 1, 2, false),
                    new ConnectionGene(id2, 2, 3, 1, 3),
                    new ConnectionGene(id2, 1, 4, 1, 4),
                    new ConnectionGene(id2, 4, 3, 1, 5),
                    new ConnectionGene(id2, 0, 4, 1, 8)
                });

                Assert.IsFalse(brain1.Equals(brain2));
            }
    public TrainingRoom SetupEnvironment(System.Random rand)
    {
        TrainingRoom level = Instantiate(levels.GetRandom(rand).gameObject, transform.parent).GetComponent <TrainingRoom>();

        SpawnSpawnables(level, rand);
        return(level);
    }
 public void EditItemWithInvalidDetails(TrainingRoom trainingRoomToEdit, TrainingRoom newTrainingRoom)
 {
     this.EditItem(trainingRoomToEdit, newTrainingRoom);
     ExecutionDelayProvider.SleepFor(3000);
     this.TrainingRoomsPage.Map.CancelChangesToItemButton.MouseClick();
     this.Browser.RefreshDomTree();
 }
        /// <inheritdoc cref="ITrainingRoomService.CreateTrainingRoomAsync(CreateTrainingRoomRequest)"/>
        public async Task <CreateTrainingRoomResponse> CreateTrainingRoomAsync(CreateTrainingRoomRequest createTrainingRoomRequest)
        {
            if (createTrainingRoomRequest.OwnerId.Equals(Guid.Empty))
            {
                return(new CreateTrainingRoomResponse(createTrainingRoomRequest.Id, Guid.Empty, "The ownerId must not be an empty guid."));
            }

            if (string.IsNullOrWhiteSpace(createTrainingRoomRequest.TrainingRoomName))
            {
                return(new CreateTrainingRoomResponse(createTrainingRoomRequest.Id, Guid.Empty, "The training room name cannot be null or be empty"));
            }

            if (await _trainingRoomRepository.ExistsAsync(tr => tr.Name.Equals(createTrainingRoomRequest.TrainingRoomName, StringComparison.CurrentCultureIgnoreCase)))
            {
                return(new CreateTrainingRoomResponse(createTrainingRoomRequest.Id, Guid.Empty, "A training room with the requested name already exists."));
            }

            if (!await _userRepository.ExistsAsync(user => user.Id.Equals(createTrainingRoomRequest.OwnerId)))
            {
                return(new CreateTrainingRoomResponse(createTrainingRoomRequest.Id, Guid.Empty, "User not found."));
            }

            User owner = await _userRepository.FindSingleOrDefaultAsync(user => user.Id.Equals(createTrainingRoomRequest.OwnerId));

            TrainingRoom trainingRoom = new TrainingRoom(owner, createTrainingRoomRequest.TrainingRoomName, createTrainingRoomRequest.TrainingRoomSettings);

            if (!await _trainingRoomRepository.CreateAsync(trainingRoom))
            {
                return(new CreateTrainingRoomResponse(createTrainingRoomRequest.Id, Guid.Empty, "Failed to create training room."));
            }

            return(new CreateTrainingRoomResponse(createTrainingRoomRequest.Id, trainingRoom.Id, "Successfully created a training room.", true));
        }
 public void RemoveItem(TrainingRoom trainingRoom)
 {
     var rowToDelete = this.TrainingRoomsPage.Map.KendoGrid.IndexOfGridRowContainingText(trainingRoom.Name);
     this.TrainingRoomsPage.Map.AllDeleteEntryButtons[rowToDelete].MouseClick();
     this.TrainingRoomsPage.Map.DeleteEntryButton.MouseClick();
     ExecutionDelayProvider.SleepFor(3000);
     Manager.Current.Desktop.KeyBoard.KeyPress(Keys.Enter);
 }
Example #9
0
            public void Initialize()
            {
                _fakeUser = new User();
                Guid trainingRoomId = Guid.NewGuid();

                _roomName        = "CoolRoom";
                _organismFactory = new OrganismFactory();
                _trainingRoom    = new TrainingRoom(trainingRoomId, _fakeUser, _roomName, new TrainingRoomSettings(trainingRoomId, 0, 2, 1, 1, 1, 0.4, 3, 0.05, 0.03, 0.75, 0.001, 1, 0.8, 0.1, 0.5, 0.25, 0, 15, 5), _organismFactory);
            }
        //public bool HireInstructor(Instructor instructor) {
        //    if (Inventory.Instance.Moolah < hireCost ||
        //        instructors.Count == rooms.Count) {
        //        return false;
        //    }

        //    // For now we just adding it to the list
        //    instructors.Add(instructor);
        //    applicants.Remove(instructor);
        //    Inventory.Instance.ModifyMoolah(-hireCost);

        //    return true;
        //}

        //public void FireInstructor(Instructor instructor) {
        //    instructors.Remove(instructor);
        //}

        // Create rooom for instructor
        public void CreateRoom(Instructor instructor, int availiblePlaceCount, int capacity)
        {
            TrainingRoom room = new TrainingRoom();

            room.instructor          = instructor;
            room.availiblePlaceCount = availiblePlaceCount;
            room.capacity            = capacity;
            rooms.Add(room);
        }
Example #11
0
 public void Initialize()
 {
     _user = new User()
     {
         Id       = Guid.NewGuid(),
         Username = "******"
     };
     _trainingRoomSettings = new TrainingRoomSettings(0, 2, 1, 1, 1, 0.4, 3, 0.05, 0.03, 0.75, 0.001, 1, 0.8, 0.1, 0.5, 0.25, 0);
     _trainingRoom         = new TrainingRoom(_user, "CoolRoom", _trainingRoomSettings);
 }
Example #12
0
        public async Task <IActionResult> UpdateTrainingRoom([FromBody] TrainingRoom trainingRoom)
        {
            using (var context = new GymDbContext())
            {
                context.TrainingRooms.Update(trainingRoom);
                await context.SaveChangesAsync();

                return(Ok());
            }
        }
Example #13
0
            public void Initialize()
            {
                _user = new User()
                {
                    Id       = Guid.NewGuid(),
                    Username = "******"
                };
                Guid trainingRoomId = Guid.NewGuid();

                _organismFactory      = new OrganismFactory();
                _trainingRoomSettings = new TrainingRoomSettings(trainingRoomId, 0, 2, 1, 1, 1, 0.4, 3, 0.05, 0.03, 0.75, 0.001, 1, 0.8, 0.1, 0.5, 0.25, 0, 15, 5);
                _trainingRoom         = new TrainingRoom(trainingRoomId, _user, "CoolRoom", _trainingRoomSettings, _organismFactory);
            }
Example #14
0
        public void CrossOverTest()
        {
            Guid id = Guid.NewGuid();

            _trainingRoom = new TrainingRoom(_fakeUser, "FakeRoom", new TrainingRoomSettings(0, 2, 3, 1, 1, 0.4, 3, 0.05, 0.03, 0.75, 0.001, 1, 0.8, 0.1, 0.5, 0.25, 0));
            Brain expectedBrain = new Brain(id, _trainingRoom, new List <ConnectionGene>()
            {
                new ConnectionGene(id, 0, 3, 1, 1),
                new ConnectionGene(id, 1, 3, 1, 2, false),
                new ConnectionGene(id, 2, 3, 1, 3),
                new ConnectionGene(id, 1, 4, -1, 4),
                new ConnectionGene(id, 4, 3, 1, 5, false),
                new ConnectionGene(id, 4, 5, 1, 6),
                new ConnectionGene(id, 5, 3, 1, 7),
                new ConnectionGene(id, 0, 4, -1, 8),
                new ConnectionGene(id, 2, 4, 1, 9),
                new ConnectionGene(id, 0, 5, 1, 10)
            });
            List <ConnectionGene> expectedGenes = expectedBrain.ConnectionGenes.OrderBy(x => x.InnovationNumber).ToList();
            Guid  id2    = Guid.NewGuid();
            Brain brain1 = new Brain(id2, _trainingRoom, new List <ConnectionGene>()
            {
                new ConnectionGene(id2, 0, 3, -1, 1),
                new ConnectionGene(id2, 1, 3, -1, 2, false),
                new ConnectionGene(id2, 2, 3, -1, 3),
                new ConnectionGene(id2, 1, 4, -1, 4),
                new ConnectionGene(id2, 4, 3, -1, 5),
                new ConnectionGene(id2, 0, 4, -1, 8)
            });
            Guid  id3    = Guid.NewGuid();
            Brain brain2 = new Brain(id3, _trainingRoom, new List <ConnectionGene>()
            {
                new ConnectionGene(id3, 0, 3, 1, 1),
                new ConnectionGene(id3, 1, 3, 1, 2, false),
                new ConnectionGene(id3, 2, 3, 1, 3),
                new ConnectionGene(id3, 1, 4, 1, 4),
                new ConnectionGene(id3, 4, 3, 1, 5, false),
                new ConnectionGene(id3, 4, 5, 1, 6),
                new ConnectionGene(id3, 5, 3, 1, 7),
                new ConnectionGene(id3, 2, 4, 1, 9),
                new ConnectionGene(id3, 0, 5, 1, 10)
            });

            Brain child = brain1.Crossover(brain2);

            List <ConnectionGene> childGenes = child.ConnectionGenes.OrderBy(a => a.InnovationNumber).ToList();

            CollectionAssert.AreEqual(childGenes, expectedGenes);
        }
 public void AddItem(TrainingRoom trainingRoom)
 {
     this.TrainingRoomsPage.Map.AddItemButton.MouseClick();
     this.TrainingRoomsPage.Validator.ValidateAddPopUpAppeared();
     ExecutionDelayProvider.SleepFor(3000);
     this.TrainingRoomsPage.Map.TrainingRoomName.MouseClick(MouseClickType.LeftDoubleClick);
     Manager.Current.ActiveBrowser.Desktop.KeyBoard.TypeText(trainingRoom.Name, 30);
     this.TrainingRoomsPage.Map.TrainingRoomAddress.MouseClick(MouseClickType.LeftDoubleClick);
     Manager.Current.ActiveBrowser.Desktop.KeyBoard.TypeText(trainingRoom.Address, 30);
     this.TrainingRoomsPage.Map.TrainingRoomCapacity.MouseClick(MouseClickType.LeftDoubleClick);
     Manager.Current.ActiveBrowser.Desktop.KeyBoard.TypeText(trainingRoom.Capacity, 30);
     this.TrainingRoomsPage.Map.TrainingRoomEquipment.MouseClick(MouseClickType.LeftDoubleClick);
     Manager.Current.ActiveBrowser.Desktop.KeyBoard.TypeText(trainingRoom.Equipment, 30);
     this.TrainingRoomsPage.Map.UpdateItemButton.MouseClick();
     this.Browser.RefreshDomTree();
 }
Example #16
0
            public void Initialize()
            {
                _fakeUser     = new User();
                _trainingRoom = new TrainingRoom(_fakeUser, "FakeRoom", new TrainingRoomSettings(0, 2, 3, 1, 1, 0.4, 3, 0.05, 0.03, 0.75, 0.001, 1, 0.8, 0.1, 0.5, 0.25, 0));
                Guid id = Guid.NewGuid();

                _original = new Brain(id, _trainingRoom, new List <ConnectionGene>()
                {
                    new ConnectionGene(id, 0, 3, 1, 1),
                    new ConnectionGene(id, 1, 3, 1, 2, false),
                    new ConnectionGene(id, 2, 3, 1, 3),
                    new ConnectionGene(id, 1, 4, 1, 4),
                    new ConnectionGene(id, 4, 3, 1, 5),
                    new ConnectionGene(id, 0, 4, 1, 6)
                });
            }
Example #17
0
 public async Task <IActionResult> Post(TrainingRoom trainingRoom)
 {
     try
     {
         _repository.Add(trainingRoom);
         if (await this._repository.SaveChangesAsync())
         {
             return(Ok(trainingRoom));
         }
     }
     catch (Exception ex)
     {
         return(BadRequest($"When posting the training room, an error ocurred: {ex.Message}"));
     }
     return(BadRequest());
 }
Example #18
0
        public async Task <int> Handle(CreateTrainingRoomsCommand request, CancellationToken cancellationToken)
        {
            var entity = new TrainingRoom
            {
                RoomDescription = request.RoomDescription,
                SeatingCapacity = request.SeatingCapacity,
                HasProjector    = request.HasProjector,
                ActiveFlag      = request.ActiveFlag,
                CreatedBy       = request.CreatedBy,
                CreatedOn       = _dateTime.Now
            };

            _context.TrainingRoom.Add(entity);
            await _context.SaveChangesAsync(cancellationToken);

            return(entity.RoomId);
        }
    public static int constructor(IntPtr l)
    {
        int result;

        try
        {
            TrainingRoom o = new TrainingRoom();
            LuaObject.pushValue(l, true);
            LuaObject.pushValue(l, o);
            result = 2;
        }
        catch (Exception e)
        {
            result = LuaObject.error(l, e);
        }
        return(result);
    }
    public static int get_Courses(IntPtr l)
    {
        int result;

        try
        {
            TrainingRoom trainingRoom = (TrainingRoom)LuaObject.checkSelf(l);
            LuaObject.pushValue(l, true);
            LuaObject.pushValue(l, trainingRoom.Courses);
            result = 2;
        }
        catch (Exception e)
        {
            result = LuaObject.error(l, e);
        }
        return(result);
    }
    public static int get_AnikiGymLevelRequired(IntPtr l)
    {
        int result;

        try
        {
            TrainingRoom trainingRoom = (TrainingRoom)LuaObject.checkSelf(l);
            LuaObject.pushValue(l, true);
            LuaObject.pushValue(l, trainingRoom.AnikiGymLevelRequired);
            result = 2;
        }
        catch (Exception e)
        {
            result = LuaObject.error(l, e);
        }
        return(result);
    }
    public static int ReloadConfigData(IntPtr l)
    {
        int result;

        try
        {
            TrainingRoom trainingRoom = (TrainingRoom)LuaObject.checkSelf(l);
            trainingRoom.ReloadConfigData();
            LuaObject.pushValue(l, true);
            result = 1;
        }
        catch (Exception e)
        {
            result = LuaObject.error(l, e);
        }
        return(result);
    }
Example #23
0
        public MainWindow()
        {
            _memory       = new Memory();
            _challenge    = new Challenge(_memory);
            _trainingRoom = new TrainingRoom();
            _updateDelay  = new Stopwatch();

            _memory.OnProcessOpened = process =>
            {
                var filename = process.MainModule?.FileName;
                var location = filename?.Substring(0, filename.LastIndexOf('\\'));
                _trainingRoom.SetGameLocation(location);
                InstallMod.IsChecked = _trainingRoom.IsModInstalled();
            };

            InitializeComponent();
            UpdateFields();
        }
        // Add student to the given room
        public Student AddStudent(TrainingRoom room, HumanoidFighter fighter)
        {
            if (room.HasStudent(fighter))
            {
                return(null);
            }

            // Remove from other locations.
            if (ClinicManager.Instance.IsPatient(fighter))
            {
                ClinicManager.Instance.RemovePatient(fighter);
            }


            Student student = new Student(fighter);

            room.Populate(student);
            return(student);
        }
    public void SpawnSpawnables(TrainingRoom room, System.Random rand)
    {
        var roomType = roomTypes.GetRandom(rand);
        HashSet <Vector2Int> floorTiles = new HashSet <Vector2Int>(room.unitSpaceFloors);
        HashSet <Vector2Int> wallTiles  = new HashSet <Vector2Int>(room.unitSpaceWalls);

        Debug.Log("LEVEL SPAWNED AT: " + transform.position);

        Vector2Int pos = new Vector2Int(Mathf.RoundToInt(transform.position.x), Mathf.RoundToInt(transform.position.z)) + room.Position;

        Debug.Log($"LEVEL SPAWN: {pos}");
        RoomType.RoomSet roomSet = roomType.roomSets.GetRandom(rand);
        var spawned = SpawnGenerator.SpawnItemsInRoom(rand, roomType, roomType.roomSets.GetRandom(rand), floorTiles, wallTiles, pos);

        foreach (var item in spawned)
        {
            item.transform.SetParent(room.transform);
        }
    }
Example #26
0
            public void Initialize()
            {
                _fakeUser = new User();
                Guid trainingRoomId = Guid.NewGuid();

                _organismFactory = new OrganismFactory();
                _trainingRoom    = new TrainingRoom(trainingRoomId, _fakeUser, "FakeRoom", new TrainingRoomSettings(trainingRoomId, 0, 2, 3, 1, 1, 0.4, 3, 0.05, 0.03, 0.75, 0.001, 1, 0.8, 0.1, 0.5, 0.25, 0, 15, 5), _organismFactory);
                Guid id = Guid.NewGuid();

                _original = new Organism(id, _trainingRoom.TrainingRoomSettings, 0, new List <ConnectionGene>()
                {
                    new ConnectionGene(id, 1, 0, 3, 1),
                    new ConnectionGene(id, 2, 1, 3, 1, false),
                    new ConnectionGene(id, 3, 2, 3, 1),
                    new ConnectionGene(id, 4, 1, 4, 1),
                    new ConnectionGene(id, 5, 4, 3, 1),
                    new ConnectionGene(id, 6, 0, 4, 1)
                });
            }
    public static int set_Courses(IntPtr l)
    {
        int result;

        try
        {
            TrainingRoom          trainingRoom = (TrainingRoom)LuaObject.checkSelf(l);
            List <TrainingCourse> courses;
            LuaObject.checkType <List <TrainingCourse> >(l, 2, out courses);
            trainingRoom.Courses = courses;
            LuaObject.pushValue(l, true);
            result = 1;
        }
        catch (Exception e)
        {
            result = LuaObject.error(l, e);
        }
        return(result);
    }
    public static int UpdateInstantiatedData(IntPtr l)
    {
        int result;

        try
        {
            TrainingRoom        trainingRoom = (TrainingRoom)LuaObject.checkSelf(l);
            List <TrainingTech> availableTechs;
            LuaObject.checkType <List <TrainingTech> >(l, 2, out availableTechs);
            trainingRoom.UpdateInstantiatedData(availableTechs);
            LuaObject.pushValue(l, true);
            result = 1;
        }
        catch (Exception e)
        {
            result = LuaObject.error(l, e);
        }
        return(result);
    }
    public static int set_ConfigDataLoader(IntPtr l)
    {
        int result;

        try
        {
            TrainingRoom      trainingRoom = (TrainingRoom)LuaObject.checkSelf(l);
            IConfigDataLoader configDataLoader;
            LuaObject.checkType <IConfigDataLoader>(l, 2, out configDataLoader);
            trainingRoom.ConfigDataLoader = configDataLoader;
            LuaObject.pushValue(l, true);
            result = 1;
        }
        catch (Exception e)
        {
            result = LuaObject.error(l, e);
        }
        return(result);
    }
    public static int set_WhichTrainingGround(IntPtr l)
    {
        int result;

        try
        {
            TrainingRoom   trainingRoom = (TrainingRoom)LuaObject.checkSelf(l);
            TrainingGround whichTrainingGround;
            LuaObject.checkType <TrainingGround>(l, 2, out whichTrainingGround);
            trainingRoom.WhichTrainingGround = whichTrainingGround;
            LuaObject.pushValue(l, true);
            result = 1;
        }
        catch (Exception e)
        {
            result = LuaObject.error(l, e);
        }
        return(result);
    }
Example #31
0
            public void Initialize()
            {
                _fakeUser = new User();
                Guid trainingRoomId = Guid.NewGuid();

                _roomName = "CoolRoom";

                //Create a training room with really high mutation settings
                TrainingRoomSettings trainingRoomSettings = new TrainingRoomSettings(trainingRoomId: trainingRoomId,
                                                                                     organismCount: 25,
                                                                                     inputCount: 3,
                                                                                     outputCount: 1,
                                                                                     c1: 1,
                                                                                     c2: 1,
                                                                                     c3: 0.4,
                                                                                     threshold: 3,
                                                                                     addConnectionChance: 1,
                                                                                     addNodeChance: 1,
                                                                                     crossOverChance: 0.75,
                                                                                     interSpeciesChance: 0.001,
                                                                                     mutationChance: 1,
                                                                                     mutateWeightChance: 0.8,
                                                                                     weightReassignChance: 0.1,
                                                                                     topAmountToSurvive: 0.5,
                                                                                     enableConnectionChance: 0.25,
                                                                                     seed: 1,
                                                                                     maxStagnantTime: 15,
                                                                                     championCloneMinSpeciesSize: 5);

                _organismFactory = new EvaluatableOrganismFactory();
                _trainingRoom    = new TrainingRoom(trainingRoomId, _fakeUser, _roomName, trainingRoomSettings, _organismFactory);

                for (int i = 0; i < trainingRoomSettings.OrganismCount; i++)
                {
                    EvaluatableOrganism organism = new EvaluatableOrganism(trainingRoomSettings, _trainingRoom.GetInnovationNumber)
                    {
                        IsLeased = true
                    };
                    _trainingRoom.AddOrganism(organism);
                }
                _trainingRoom.IncreaseNodeIdTo(trainingRoomSettings.InputCount + trainingRoomSettings.OutputCount);
            }
    public static int __callBase_GetRoom(IntPtr l)
    {
        int result;

        try
        {
            TrainingGroundCompoment trainingGroundCompoment = (TrainingGroundCompoment)LuaObject.checkSelf(l);
            int roomId;
            LuaObject.checkType(l, 2, out roomId);
            TrainingRoom o = trainingGroundCompoment.m_luaExportHelper.__callBase_GetRoom(roomId);
            LuaObject.pushValue(l, true);
            LuaObject.pushValue(l, o);
            result = 2;
        }
        catch (Exception e)
        {
            result = LuaObject.error(l, e);
        }
        return(result);
    }
Example #33
0
    public static int GetRoom(IntPtr l)
    {
        int result;

        try
        {
            TrainingGround trainingGround = (TrainingGround)LuaObject.checkSelf(l);
            int            roomId;
            LuaObject.checkType(l, 2, out roomId);
            TrainingRoom room = trainingGround.GetRoom(roomId);
            LuaObject.pushValue(l, true);
            LuaObject.pushValue(l, room);
            result = 2;
        }
        catch (Exception e)
        {
            result = LuaObject.error(l, e);
        }
        return(result);
    }
 public void EditItem(TrainingRoom trainingRoomToEdit, TrainingRoom newTrainingRoom)
 {
     var rowToEdit = this.TrainingRoomsPage.Map.KendoGrid.IndexOfGridRowContainingText(trainingRoomToEdit.Name);
     this.TrainingRoomsPage.Map.AllEditEntryButtons[rowToEdit].MouseClick();
     this.Browser.RefreshDomTree();
     ExecutionDelayProvider.SleepFor(3000);
     this.TrainingRoomsPage.Map.TrainingRoomName.MouseClick(MouseClickType.LeftDoubleClick);
     Manager.Current.ActiveBrowser.Desktop.KeyBoard.KeyPress(Keys.Back);
     Manager.Current.ActiveBrowser.Desktop.KeyBoard.TypeText(newTrainingRoom.Name, 30);
     this.TrainingRoomsPage.Map.TrainingRoomAddress.MouseClick(MouseClickType.LeftDoubleClick);
     Manager.Current.ActiveBrowser.Desktop.KeyBoard.KeyPress(Keys.Back);
     Manager.Current.ActiveBrowser.Desktop.KeyBoard.TypeText(newTrainingRoom.Address, 30);
     this.TrainingRoomsPage.Map.TrainingRoomCapacity.MouseClick(MouseClickType.LeftDoubleClick);
     Manager.Current.ActiveBrowser.Desktop.KeyBoard.KeyPress(Keys.Back);
     Manager.Current.ActiveBrowser.Desktop.KeyBoard.TypeText(newTrainingRoom.Capacity, 30);
     this.TrainingRoomsPage.Map.TrainingRoomEquipment.MouseClick(MouseClickType.LeftDoubleClick);
     Manager.Current.ActiveBrowser.Desktop.KeyBoard.KeyPress(Keys.Back);
     Manager.Current.ActiveBrowser.Desktop.KeyBoard.TypeText(newTrainingRoom.Equipment, 30);
     this.TrainingRoomsPage.Map.UpdateItemButton.MouseClick();
     this.Browser.RefreshDomTree();
 }