public async Task <bool> Handle(CreateQuarryCommand request, CancellationToken cancellationToken)
            {
                if (Guid.TryParse(request.FiefId, out Guid id))
                {
                    var fief = await _context.Fiefs.FindAsync(id);

                    var quarry = new Quarry
                    {
                        Fief             = fief,
                        QuarryTypeId     = request.QuarryTypeId,
                        IsFirstYear      = true,
                        IsBeingDeveloped = false,
                        YearsLeft        = request.YearsLeft
                    };

                    fief.Industries.Add(quarry);

                    await _context.SaveChangesAsync(cancellationToken);

                    return(true);

                    throw new CustomException($"CreateQuarryCommand >> Unauthorized!");
                }

                throw new CustomException($"CreateQuarryCommand >> Could not parse FiefId({request.FiefId}).");
            }
        public RepositoryResult <Quarry> Update(Quarry quarry)
        {
            //var result = new RepositoryResult<Quarry>(false, null,TAG);
            var existQuarry = context.Quarries.FirstOrDefault(q => q.Identifier == quarry.Identifier);

            if (existQuarry != null)
            {
                IDbContextTransaction tx = null;
                try {
                    tx = context.Database.BeginTransaction();
                    existQuarry.Animal = context.Animals.FirstOrDefault(x => x.Identifier == quarry.Animal.Identifier) ?? existQuarry.Animal;
                    existQuarry.Amount = existQuarry.Amount - quarry.Amount;
                    context.SaveChanges();
                    tx.Commit();
                    return(new RepositoryResult <Quarry>(true, existQuarry, TAG + "03"));
                }
                catch (Exception ex) {
                    log.Error(ex);
                    return(new RepositoryResult <Quarry>(false, null, TAG + "04"));
                }
                finally {
                    tx?.Dispose();
                }
            }
            else
            {
                return(new RepositoryResult <Quarry>(false, null, TAG + "12"));
            }
        }
Beispiel #3
0
        public MasterPage()
        {
            InitializeComponent();

            _connection = DependencyService.Get <ISQLiteDB>().GetConnection();
            _quarry     = new Quarry(_connection);
        }
Beispiel #4
0
    public override ICharacter GetTarget()
    {
        // if our quarry isn't set, just use any quarry on the board
        if (quarry == null)
        {
            quarry = transform.parent.GetComponentInChildren <Quarry>();
        }

        return((ICharacter)quarry ?? this);
    }
Beispiel #5
0
    internal override int CalculateProductionChanges(Building newNeighbour, Tile neighbourTile)
    {
        if (newNeighbour is Quarry)
        {
            Quarry quarry = newNeighbour as Quarry;
            return(quarry.CalculateProduction(neighbourTile));
        }

        return(0);
    }
        public void TestNewTileIsPlaced()
        {
            var target = new Quarry();
            Tile tile = new MockTile();
            Space space = _control.GetPlacableSpaces(tile).First();

            target.Transition(null);
            target.Transition(tile);
            target.Transition(space);

            Assert.AreEqual(tile, space.Tile);
        }
Beispiel #7
0
    private void Update()
    {
        if (Input.GetKey(KeyCode.S))
        {
            GameObject go = new GameObject();
            Quarry     q  = go.AddComponent <Quarry>();

            AddResource(q, 4000);
            AddResource(go.AddComponent <Forest>(), 4000);
            AddResource(go.AddComponent <BerryBush>(), 4000);
        }
    }
Beispiel #8
0
        public void RemovesQuarryAbilityFromCharacter()
        {
            var quarry    = new Quarry();
            var impQuarry = new ImprovedQuarry();

            var character = new CharacterSheet(CharacterStrategy.Default());

            character.Add(quarry);
            character.Add(impQuarry);
            Assert.Contains(impQuarry, character.Components.All);
            Assert.DoesNotContain(quarry, character.Components.All);
        }
Beispiel #9
0
        public SwimmingCreationPage(MasterPage master, Quarry quarry) : base(master, quarry)
        {
            InitializeComponent();

            stopwatch = new Stopwatch();
            laps      = new ObservableCollection <TimeSpan>();

            lv_laps.ItemsSource = laps;

            //lv_laps.ItemTapped += async (s, e) =>
            //{
            //};
        }
        public void TransitionTest()
        {
            var target = new Quarry();
            Tile tile = new MockTile();

            Selection actual = target.Transition(null);
            Assert.AreEqual(Selection.TileFromHand, actual);

            actual = target.Transition(tile);
            Assert.AreEqual(Selection.PlayableSpace, actual);

            target.Transition(_control.GetPlacableSpaces(tile).First());
            Assert.AreEqual(tile, _control.ActiveTile);
        }
Beispiel #11
0
    public override int CalculateProduction(Tile tile)
    {
        List <Tile> tilesInRange   = tile.GetAllTilesAround(collectionRange);
        int         collectedFunds = baseProduction;

        foreach (var tempTile in tilesInRange)
        {
            if (tempTile.placedBuilding != null && tempTile.placedBuilding is Quarry)
            {
                Quarry quarry = tempTile.placedBuilding as Quarry;
                collectedFunds += quarry.CalculateProduction();
            }
        }

        return(collectedFunds);
    }
        public void TestTileIsRemoved()
        {
            var target = new Quarry();

            Selection actual = target.Transition(null);
            Assert.AreEqual(Selection.TileFromHand, actual);

            Player player = _control.ActivePlayer;
            Tile tile = player.Hand.First();
            actual = target.Transition(tile);
            Assert.AreEqual(Selection.PlayableSpace, actual);

            target.Transition(_control.GetPlacableSpaces(tile).First());
            Assert.AreEqual(tile, _control.ActiveTile);

            Assert.IsFalse(player.Hand.Contains(tile));
        }
        public void CanMoveColonists()
        {
            Game.Players.ForEach(p => {
                var tile = new Quarry();
                tile.AddWorker(new Colonist());
                p.Plant(tile);
                p.Build(new SmallMarket());
            });
            var action = new MoveColonist {
                FromIndex      = 1,
                ToIndex        = 0,
                IsMoveFromTile = true,
                IsMoveToTile   = false
            };

            Game.Players.ForEach(p => CanExecuteActionMultiple(action, p));
        }
        public MemberCreationPage(MasterPage master, Quarry quarry)
        {
            InitializeComponent();

            btn_create.Clicked += async(s, e) =>
            {
                var forename = ety_forename.Text;
                var surname  = ety_surname.Text;

                var member = new Member()
                {
                    Forename = forename, Surname = surname
                };

                await quarry.Add(member);

                await master.RefreshList();

                await master.ShowMemberDetail(member);
            };
        }
        private void CanUseQuarry_ToBuild <T>(int expectedDiscount, IPlayer player, int quarryCount) where T : IBuilding
        {
            const int playerFunds = 21;

            player.Doubloons = playerFunds;
            for (var i = 0; i < quarryCount; i++)
            {
                var quarry = new Quarry();
                quarry.AddWorker(new Colonist());
                player.Plant(quarry);
            }

            var building = Game.Buildings.OfType <T>().First();
            var index    = Game.Buildings.IndexOf(building);
            var action   = new Build {
                BuildingIndex = index
            };

            Role.Execute(action, player);

            Assert.Equal(playerFunds - building.Cost + expectedDiscount, player.Doubloons);
        }
        public Program()
        {
            List <IMyShipDrill> drills = new List <IMyShipDrill>();
            List <IMyTextPanel> panels = new List <IMyTextPanel>();

            Piston[] pistonArray = new Piston[3];

            GridTerminalSystem.GetBlocksOfType(panels, x => x.CustomName.ToLower().Contains(LCDSCREEN));
            GridTerminalSystem.GetBlocksOfType(drills, x => x.CustomName.ToLower().Contains(DRILLNAME.ToLower()));
            GridTerminalSystem.GetBlocksOfType <IMyPistonBase>(null, x =>
            {
                string name = x.CustomName.ToLower();
                if (name.Contains(PISTONNAME.ToLower()))
                {
                    if (name.Last() == 'x')
                    {
                        pistonArray[0] = new Piston(x); return(false);
                    }
                    if (name.Last() == 'y')
                    {
                        pistonArray[1] = new Piston(x); return(false);
                    }
                    if (name.Last() == 'z')
                    {
                        pistonArray[2] = new Piston(x); return(false);
                    }
                }
                return(false);
            });

            if (panels.Count > 0)
            {
                m_lcd = panels[0];
            }
            m_quarry = new Quarry(pistonArray, drills, Print);
            Runtime.UpdateFrequency = UpdateFrequency.Update100;
        }
        public RepositoryResult <Quarry> Add(Quarry quarry)
        {
            //var result = new RepositoryResult<Quarry>(false, new Quarry());
            IDbContextTransaction tx = null;

            try
            {
                tx = context.Database.BeginTransaction();
                quarry.Identifier = Guid.NewGuid();
                quarry.Animal     = context.Animals.FirstOrDefault(i => i.Identifier == quarry.Animal.Identifier);
                context.Quarries.Add(quarry);
                context.SaveChanges();
                tx.Commit();
                log.Info("Dodana quarry");
                return(new RepositoryResult <Quarry>(true, quarry, TAG + "01"));;
            }
            catch (Exception ex) {
                log.Error($"Nie dodano quarry{ex}");
                return(new RepositoryResult <Quarry>(true, null, TAG + "02"));;
            }
            finally {
                tx?.Dispose();
            }
        }
Beispiel #18
0
        private void TryUpdateQuarry(BasePlayer player, HitInfo hitInfo)
        {
            var hitEntity = hitInfo.HitEntity;

            if (hitEntity.GetComponentInParent <BaseEntity>() == null || hitEntity.GetComponentInParent <BaseEntity>().GetComponent <StorageContainer>() == null)
            {
                return;
            }

            var owningQuarry = GetQuarryForPart(hitEntity);

            if (owningQuarry != null)
            {
                Quarries.Remove(owningQuarry);
                SaveQuarries();
                player.ChatMessage("Quarry Removed!");
                return;
            }

            List <BaseEntity> containers;
            bool nearBuilding;

            if (!HasValidQuarryConstruction(hitEntity.transform.position, out containers, out nearBuilding))
            {
                if (nearBuilding)
                {
                    player.ChatMessage("Cannot build quarry near buildings!");
                }
                else
                {
                    player.ChatMessage("Invalid quarry construction! There must be a 3x3 area of wooden boxes (small or large). Smack the middle with a torch!");
                }
                return;
            }

            HashSet <uint> containerIds = new HashSet <uint>(containers.Select(c => c.net.ID));

            for (int i = Quarries.Count - 1; i >= 0; i--)
            {
                var q = Quarries[i];
                if (q.EntityIds.Any(id => containerIds.Contains(id)))
                {
                    // Quarry already exists.
                    // There's nothing to do here.
                    Quarries.RemoveAt(i);
                    SaveQuarries();
                    player.ChatMessage("Quarry Removed!");
                    return;
                }
            }

            var quarry = new Quarry(hitEntity.net.ID, containers.Select(c => c.net.ID).ToList());

            Quarries.Add(quarry);
            SaveQuarries();

#if DEBUG
            player.ChatMessage("Quarry Created! ID: " + quarry.Id + ", Entities: " + string.Join(", ", quarry.EntityIds.Select(i => i.ToString()).ToArray()));
#else
            player.ChatMessage("Quarry Created!");
#endif
        }
        protected override CommandResult Execute(ConsoleContext context, QuarryArguments arguments)
        {
            IList <Quarry> quarriesList = new List <Quarry>();
            Quarry         quarry       = new Quarry();

            if (string.IsNullOrEmpty(arguments.Identifier))
            {
                Task <ConnectorResult <Response <IEnumerable <Quarry> > > > quarries  = WinApiConnector.RequestGet <Response <IEnumerable <Quarry> > >($"{context.ConsoleSettings.ServerAddress}:{context.ConsoleSettings.Port}/Api/Hunting/GetQuarries");
                ConnectorResult <Response <IEnumerable <Quarry> > >         preResult = quarries.Result;
                if (!preResult.IsSuccess)
                {
                    return(new CommandResult(preResult.Message, false));
                }
                if (!preResult.Response.IsSuccess)
                {
                    return(new CommandResult(preResult.Response.Code, false));
                }
                if (!preResult.Response.Payload.Any())
                {
                    return(new CommandResult("The payload of response is null or empty", false));
                }
                int index = 1;
                foreach (var item in preResult.Response.Payload)
                {
                    System.Console.WriteLine($"{index++}. {item.Animal.Name} - amount: {item.Amount} szt.");
                    quarriesList.Add(item);
                }
                bool shouldWork = true;
                int  choisenOne = 0;

                do
                {
                    System.Console.Write("Wybierz zwierzyne do aktualizacji: ");
                    string userChoice = System.Console.ReadLine();
                    bool   isParsed   = int.TryParse(userChoice, out choisenOne);
                    shouldWork = isParsed ? choisenOne > quarriesList.Count(): true;
                }while(shouldWork);

                quarry.Identifier = quarriesList[choisenOne - 1].Identifier;
            }
            if (!string.IsNullOrEmpty(arguments.Identifier))
            {
                Task <ConnectorResult <Response <IEnumerable <Quarry> > > > result = WinApiConnector.RequestGet <Response <IEnumerable <Quarry> > >($"{context.ConsoleSettings.ServerAddress}:{context.ConsoleSettings.Port}/Api/Hunting/GetQuarry/" +
                                                                                                                                                    $"{arguments.Identifier}");
                ConnectorResult <Response <IEnumerable <Quarry> > > connectorResult = result.Result;
                if (!connectorResult.IsSuccess)
                {
                    return(new CommandResult(connectorResult.Message, false));
                }
                if (!connectorResult.Response.IsSuccess)
                {
                    return(new CommandResult(connectorResult.Response.Code, false));
                }
                if (!connectorResult.Response.Payload.Any())
                {
                    return(new CommandResult("The payload od response is null or empty", false));
                }
                if (connectorResult.Response.Payload.Count() != 1)
                {
                    return(new CommandResult("Too many results in payload", false));
                }
                quarry.Identifier = connectorResult.Response.Payload.FirstOrDefault().Identifier;
            }
            quarry.Amount = arguments.Amount;
            Task <ConnectorResult <Response <string> > > update     = WinApiConnector.RequestPut <Quarry, Response <string> >($"{context.ConsoleSettings.ServerAddress}:{context.ConsoleSettings.Port}/Api/Hunting/UpdateQuarry", quarry);
            ConnectorResult <Response <string> >         postResult = update.Result;

            if (!postResult.IsSuccess)
            {
                return(new CommandResult(postResult.Message, false));
            }
            if (!postResult.Response.IsSuccess)
            {
                return(new CommandResult(postResult.Response.Code, false));
            }
            if (string.IsNullOrEmpty(postResult.Response.Payload))
            {
                return(new CommandResult("The paylod of response is null or empty", false));
            }
            return(new CommandResult(postResult.Response.Payload, true));
        }
Beispiel #20
0
 public PushUpCreationPage(MasterPage master, Quarry quarry) : base(master, quarry)
 {
     InitializeComponent();
 }
        protected override CommandResult Execute(ConsoleContext context, QuarryArguments arguments)
        {
            List <Quarry> quarries = new List <Quarry>();
            Quarry        quarry   = new Quarry();

            if (string.IsNullOrEmpty(arguments.Identifier))
            {
                Task <ConnectorResult <Response <IEnumerable <Quarry> > > > result    = WinApiConnector.RequestGet <Response <IEnumerable <Quarry> > >($"{context.ConsoleSettings.ServerAddress}:{context.ConsoleSettings.Port}/Api/Hunting/GetQuarries");
                ConnectorResult <Response <IEnumerable <Quarry> > >         preResult = result.Result;
                if (!preResult.IsSuccess)
                {
                    return(new CommandResult(preResult.Message, false));
                }
                if (!preResult.Response.IsSuccess)
                {
                    return(new CommandResult(preResult.Response.Code, false));
                }
                if (!preResult.Response.Payload.Any())
                {
                    return(new CommandResult("The payload of response is null or empty", false));
                }

                foreach (var item in preResult.Response.Payload)
                {
                    System.Console.WriteLine($"{item.Animal.Name} - {item.Amount}");
                    quarries.Add(item);
                }

                bool shoudWork  = true;
                int  choisenOne = 0;

                do
                {
                    System.Console.Write("WYbierz zwierzyne do usunięcia");
                    string readLine = System.Console.ReadLine();
                    bool   isParsed = int.TryParse(readLine, out choisenOne);
                    shoudWork = isParsed ? choisenOne > quarries.Count() : true;
                }while(shoudWork);

                quarry.Identifier = quarries[choisenOne - 1].Identifier;
            }
            if (!string.IsNullOrEmpty(arguments.Identifier))
            {
                Guid deleteGuid   = Guid.Empty;
                bool isParsedGuid = Guid.TryParse(arguments.Identifier, out deleteGuid);
                if (isParsedGuid)
                {
                    quarry.Identifier = deleteGuid;
                }
                return(new CommandResult("The Identifier parsing error. Please use the correct identifier or do not use the -i param"));
            }

            Task <ConnectorResult <Response <string> > > deleteResult = WinApiConnector.RequestDelete <Response <string> >($"{context.ConsoleSettings.ServerAddress}:{context.ConsoleSettings.Port}/Api/Hunting/DeleteQuarry" +
                                                                                                                           $"{quarry.Identifier}");
            ConnectorResult <Response <string> > connectorResult = deleteResult.Result;

            if (!connectorResult.IsSuccess)
            {
                return(new CommandResult(connectorResult.Message, false));
            }
            if (!connectorResult.Response.IsSuccess)
            {
                return(new CommandResult(connectorResult.Response.Code, false));
            }
            if (string.IsNullOrEmpty(connectorResult.Response.Payload))
            {
                return(new CommandResult("The payload of response is null or empty", false));
            }
            return(new CommandResult(connectorResult.Response.Payload, true));
        }
 public ExerciseCreationPage(MasterPage master, Quarry quarry)
 {
     _master = master;
     _quarry = quarry;
 }
 /// <summary>
 /// It couples an exercise with a member
 /// </summary>
 /// <param name="quarry">Quarry to the DB</param>
 /// <param name="exerciseID">Id of an exercise</param>
 /// <param name="memberID">Id of a member</param>
 /// <returns></returns>
 private async Task AddExerciseToMember(Quarry quarry, int memberID, int exerciseID, int exerciseIdentifier)
 => await quarry.Add(new MemberExercise()
 {
     MemberID = memberID, ExerciseID = exerciseID, ExerciseIdentifier = exerciseIdentifier
 });