public void CreateCharacter(Character character, Game.Game game)
        {
            character.Game  = game;
            character.Stats = new List <Stat>
            {
                new Stat(StatsType.Hunger),
                new Stat(StatsType.Thirst),
                new Stat(StatsType.Energy),
                new Stat(StatsType.Health)
            };

            _characterRepository.AddCharacter(character);
        }
Beispiel #2
0
        public async Task <Dnd35CharacterViewModel> AddCharacter(Dnd35CharacterViewModel character, string userName)
        {
            var bsonCharacter = _mapper.MapViewModelToDocument(character);

            bsonCharacter.Add(new BsonElement("owner", userName));

            var addedCharacter = await _characterRepository.AddCharacter(bsonCharacter);

            return(_mapper.MapDocumentToViewModel(addedCharacter));
        }
        public ActionResult <ServiceResponse <GetCharacterDto> > AddCharacter(AddCharacterDto newCharacter)
        {
            // ServiceResponse<GetCharacterDto> response = new ServiceResponse<GetCharacterDto>();
            var characterEntity = _mapper.Map <Character>(newCharacter);

            _characterRepository.AddCharacter(characterEntity);
            _characterRepository.Save();
            var characterToReturn = _mapper.Map <GetCharacterDto>(characterEntity);

            return(CreatedAtRoute("GetCharacter", new { characterId = characterToReturn.Id }, characterToReturn));
        }
Beispiel #4
0
        public IActionResult Create(CharacterCreateVM create)
        {
            // TODO polaczenie modelu CharacterCreateVM z listą ras z bazy danych
            if (ModelState.IsValid)
            {
                var newCharacter = new Character
                {
                    Name                    = create.Name,
                    Race                    = appDbContext.Races.FirstOrDefault(x => x.RaceID == create.RaceID),
                    Experience              = 0,
                    Level                   = 1,
                    SilfrQuantity           = startSilfrQuantity,
                    AdditionalAgility       = 0,
                    AdditionalAtttackDamage = 0,
                    AdditionalDefence       = 0,
                    AdditionalDexterity     = 0,
                    AdditionalVitality      = 0,
                    StatPoints              = 0
                };

                _ICharacterRepository.AddCharacter(newCharacter);

                var currentUser = appDbContext.Users.FirstOrDefault(x => x.UserName == HttpContext.User.Identity.Name);
                currentUser.IsCharacterCreated = true;
                currentUser.AccountCharacterID = newCharacter.CharacterID;

                appDbContext.SaveChanges();


                // dodanie startowych itemow
                for (int i = 1; i <= 7; i++)
                {
                    _ICharacterRepository.AddItem(i, currentUser.AccountCharacterID);
                }

                return(RedirectToAction("Index", "Home"));
            }


            create.RacesList = new List <SelectListItem>();
            foreach (var x in appDbContext.Races)
            {
                create.RacesList.Add(new SelectListItem(x.Name, x.RaceID.ToString()));
            }
            return(View(create));
        }
Beispiel #5
0
        public IActionResult AddCharacter([FromBody] Dictionary <string, string> content)
        {
            if (!Extras.CheckLogin(Request.Cookies, _PlayerRepo))
            {
                return(Unauthorized());
            }
            string[]  jsons = content["jsons"].Split("\"split\":\"line\"");
            Character toAdd = JsonConvert.DeserializeObject <Character>(jsons[0]);

            toAdd.playerId = new ObjectId(Request.Cookies["id"]);
            Dictionary <string, int> classes = JsonConvert.DeserializeObject <Dictionary <string, int> >(jsons[1]);
            Class starterClass = _ClassRepo.GetClass(classes.Keys.First()).Result;
            Dictionary <string, int[]> attributes = JsonConvert.DeserializeObject <Dictionary <string, int[]> >(jsons[2]);
            Armor armor = JsonConvert.DeserializeObject <Armor>(jsons[3]);

            if (!jsons[4].Contains("brak"))
            {
                Shield shield = JsonConvert.DeserializeObject <Shield>(jsons[4]);
                toAdd.shield = shield;
            }
            else
            {
                toAdd.shield = new Shield();
            }
            toAdd.specialAbilities.AddRange(starterClass.Poziomy[0].specjalne);
            toAdd.throws.Add("wytrwalosc", starterClass.Poziomy[0].rzuty[0]);
            toAdd.throws.Add("refleks", starterClass.Poziomy[0].rzuty[1]);
            toAdd.throws.Add("wola", starterClass.Poziomy[0].rzuty[2]);
            toAdd.classes     = classes;
            toAdd.attributes  = attributes;
            toAdd.armor       = armor;
            toAdd.protective1 = new ProtectiveItem();
            toAdd.protective2 = new ProtectiveItem();

            _CharacterRepo.AddCharacter(toAdd);
            return(Ok());
        }
Beispiel #6
0
 public Task AddCharacter(CreateCharacterCommand command)
 => _characterRepository.AddCharacter(command.Name, command.Planet);