Esempio n. 1
0
 protected override void OnStart()
 {
     this.animalKind   = (AnimalKind)Enum.Parse(typeof(AnimalKind), PlayerDataManager.PlayerData.LastSelectedAnimalId);
     this.selectAnimal = this.animalKind;
     MakeSelectAnimal();
     base.OnStart();
 }
Esempio n. 2
0
 public void UpdateProperties(string name, AnimalKind kind, char sex, DateTimeOffset dateOfBirth)
 {
     Name        = name;
     Kind        = kind;
     Sex         = sex;
     DateOfBirth = dateOfBirth;
 }
Esempio n. 3
0
    /// <summary>
    /// タイプしてしてアニマルカーを生成する
    /// </summary>
    public static Animal Create(AnimalKind type)
    {
        var setting = AnimalSettings.Instance[type];
        var jump    = (setting.jump == AnimalSettings.Jump.Short) ? Animal.JumpShort : Animal.JumpStandard;

        return(new Animal(setting.topSpeed, jump, setting));
    }
Esempio n. 4
0
 public Pet(string name, AnimalKind kind, char sex, DateTimeOffset dateOfBirth)
 {
     Name        = name;
     Kind        = kind;
     Sex         = sex;
     DateOfBirth = dateOfBirth;
 }
Esempio n. 5
0
        public AnimalSetting this[AnimalKind kind]
        {
            get
            {
                switch (kind)
                {
                case AnimalKind.Capybara:
                    return(Capybara);

                case AnimalKind.Panda:
                    return(Panda);

                case AnimalKind.Giraffe:
                    return(Giraffe);

                case AnimalKind.Elephant:
                    return(Elephant);

                case AnimalKind.Horse:
                    return(Horse);

                case AnimalKind.Rabbit:
                    return(Rabbit);

                case AnimalKind.Lion:
                    return(Lion);

                case AnimalKind.Pig:
                    return(Pig);

                default:
                    throw new Exception();
                }
            }
        }
        public ActionResult DeleteConfirmed(int id)
        {
            AnimalKind animalKind = db.AnimalKinds.Find(id);

            db.AnimalKinds.Remove(animalKind);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
 public UpdateAnimalKind(UpdateAnimalKindViewModel model)
 {
     vm = model;
     this.DataContext = vm;
     _animalKind      = (AnimalKind)vm.GetEditableItem();
     InitializeComponent();
     nameTextBox.Text = _animalKind.Name;
 }
 private void SetAnimalCount(AnimalKind kind, int count)
 {
     animals.Remove(kind);
     if (count > 0)
     {
         animals.Add(kind, count);
     }
 }
Esempio n. 9
0
    public Animal BuildAnimal(AnimalKind kind, int change, int lastNum, Animal mother = null)
    {
        Animal returnAnimal = new Animal();

        if (mother == null)
        {
            //以标准为基准随机生成
            foreach (AnimalJson animal in normalAnimals)
            {
                if (kind.ToString() == animal.Kind)
                {
                    returnAnimal.编码   = (010100 + lastNum + 1).ToString("000000");
                    returnAnimal.种类   = kind;
                    returnAnimal.当前状态 = CurrentState.发育中;
                    returnAnimal.年龄   = 1;

                    float randomHeight = Random.Range(-5.00f, +5.00f);
                    returnAnimal.身高 = animal.Height + randomHeight;

                    float chaZhi = 0;

                    float randomXiong = Random.Range(-5.00f, +5.00f);
                    returnAnimal.胸围 = returnAnimal.身高 * 0.51f + randomXiong;
                    chaZhi         += randomXiong;

                    float randomYao = Random.Range(-5.00f, +5.00f);
                    returnAnimal.腰围 = returnAnimal.身高 * 0.34f + randomYao;
                    chaZhi         += randomYao;

                    float randomTun = Random.Range(-5.00f, +5.00f);
                    returnAnimal.臀围 = returnAnimal.身高 * 0.54f + randomTun;
                    chaZhi         += randomTun;

                    float randomWeight = Random.Range(-5.00f, +5.00f);
                    randomWeight   += chaZhi;
                    returnAnimal.体重 = (returnAnimal.身高 - 70) * 0.6f + randomWeight;

                    returnAnimal.寿命 = animal.Age + (int)chaZhi;

                    int fayuChaZhi = (int)((5 - randomXiong) / 2);
                    returnAnimal.发育期 = animal.FaYu + fayuChaZhi;

                    int renshenChaZhi = (int)((5 - randomTun) / 2);
                    returnAnimal.妊娠期 = animal.RenShen + renshenChaZhi;

                    int feedChaZhi = (int)((5 - randomYao) / 2);
                    returnAnimal.妊娠期 = Mathf.Max(1, animal.RenShen - renshenChaZhi);

                    returnAnimal.魅力值 = Mathf.Max(30, (100 - Mathf.Abs(chaZhi) * 10));

                    returnAnimal.食物种类   = (FeedFood)(System.Enum.Parse(typeof(FeedFood), animal.Food));
                    returnAnimal.消耗食物速度 = Mathf.Max(1, (animal.Feed + (int)randomWeight / 3));
                }
            }
        }

        return(returnAnimal);
    }
        public void Backup(object obj, object copy)
        {
            AnimalKind kind = (AnimalKind)obj;
            AnimalKind cpy  = (AnimalKind)copy;

            kind.Name           = cpy.Name;
            kind.EatingStrategy = cpy.EatingStrategy;
            kind.Biome          = cpy.Biome;
        }
Esempio n. 11
0
        protected AnimalBase(AnimalKind kind, AnimalGender gender, int ageLimit = 3)
        {
            TheWorld = World.Instance;
            Kind     = kind;
            Gender   = gender;

            _ageLimit = ageLimit;
            Age       = 0;
        }
Esempio n. 12
0
 public static IAnimal GetAnimal(AnimalKind kind)
 {
     if (!repository.TryGetValue(kind, out IAnimal result))
     {
         result = new Animal(kind);
         repository.Add(kind, result);
     }
     return(result);
 }
        public UpdateAnimalKindViewModel(AnimalKind animalKind, EFDbContext context)
        {
            _animalKind  = animalKind;
            _context     = context;
            _animalKinds = new EFRepository <AnimalKind>(_context);

            UpdateAnimalKind window = new UpdateAnimalKind(this);

            window.ShowDialog();
        }
Esempio n. 14
0
        public void CallEdit(object item)
        {
            AnimalKind animalKind = (AnimalKind)item;

            if (animalKind != null)
            {
                UpdateAnimalKindViewModel updateAnimalKind = new UpdateAnimalKindViewModel(animalKind, _context);
                Refresh();
            }
        }
 public ActionResult Edit([Bind(Include = "Id,Name")] AnimalKind animalKind)
 {
     if (ModelState.IsValid)
     {
         db.Entry(animalKind).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(animalKind));
 }
        public ActionResult Create([Bind(Include = "Id,Name")] AnimalKind animalKind)
        {
            if (ModelState.IsValid)
            {
                db.AnimalKinds.Add(animalKind);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            return(View(animalKind));
        }
 public Animal(string name, AnimalKind kind, int age, List <string> food, string color, bool hair, bool fur, bool teeth)
 {
     Name             = name;
     Kind             = kind;
     Age              = age;
     Food             = food;
     Color            = color;
     PresenceOfHair   = hair;
     PresenceOfFur    = fur;
     SpecializedTeeth = teeth;
 }
Esempio n. 18
0
        public void OnClickToggle(Transform trn)
        {
            var tgl = trn.GetComponent <Toggle>();

            if (!tgl.isOn)
            {
                return;
            }

            switch (trn.name)
            {
            case "Panda":
                this.selectAnimal = AnimalKind.Panda;
                MakeRanking(GameServer.RankingType.AnimalScore, (int)AnimalKind.Panda);
                break;

            case "Capybara":
                this.selectAnimal = AnimalKind.Capybara;
                MakeRanking(GameServer.RankingType.AnimalScore, (int)AnimalKind.Capybara);
                break;

            case "Giraffe":
                this.selectAnimal = AnimalKind.Giraffe;
                MakeRanking(GameServer.RankingType.AnimalScore, (int)AnimalKind.Giraffe);
                break;

            case "Elephant":
                this.selectAnimal = AnimalKind.Elephant;
                MakeRanking(GameServer.RankingType.AnimalScore, (int)AnimalKind.Elephant);
                break;

            case "Horse":
                this.selectAnimal = AnimalKind.Horse;
                MakeRanking(GameServer.RankingType.AnimalScore, (int)AnimalKind.Horse);
                break;

            case "Rabbit":
                this.selectAnimal = AnimalKind.Rabbit;
                MakeRanking(GameServer.RankingType.AnimalScore, (int)AnimalKind.Rabbit);
                break;

            case "Lion":
                this.selectAnimal = AnimalKind.Lion;
                MakeRanking(GameServer.RankingType.AnimalScore, (int)AnimalKind.Lion);
                break;

            case "Pig":
                this.selectAnimal = AnimalKind.Pig;
                MakeRanking(GameServer.RankingType.AnimalScore, (int)AnimalKind.Pig);
                break;
            }
        }
Esempio n. 19
0
    // アイテム出現率を取得
    int GetRate(ItemPatternInfo.Body body, AnimalKind kind)
    {
        // アニマルカー別に拡張された確率があるか探す
        foreach (var extra in body.ExtraRate)
        {
            if (extra.Kind == kind)
            {
                return(extra.Rate);
            }
        }

        return(body.Rate);
    }
Esempio n. 20
0
    AnimalJson FindAnimalJsonByKind(AnimalKind kind)
    {
        AnimalJson returnJson = new AnimalJson();

        foreach (AnimalJson item in normalAnimals)
        {
            if (kind.ToString() == item.Kind)
            {
                returnJson = item;
            }
        }
        return(returnJson);
    }
Esempio n. 21
0
        // アニマル解放
        // 戻り値 true 解放した
        public bool RegistAnimal(AnimalKind kind)
        {
            if (CanUseAnimal(kind))
            {
                return(false);
            }

            var key = kind.ToString();

            this.ReleasedAnimals.Add(key);
            PlayerDataManager.DoUpdate();
            return(true);
        }
Esempio n. 22
0
        public Animal CreateAnimal(AnimalKind animalType)
        {
            switch (animalType)
            {
            case AnimalKind.Dog:
                return(new Dog());

            case AnimalKind.Cat:
                return(new Cat());

            default:
                return(new Bird());
            }
        }
        // GET: AnimalKinds/Delete/5
        public ActionResult Delete(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            AnimalKind animalKind = db.AnimalKinds.Find(id);

            if (animalKind == null)
            {
                return(HttpNotFound());
            }
            return(View(animalKind));
        }
        public bool AddAnimalKind(string name, EatingStrategy eatingStrategy, Biome biome)
        {
            AnimalKind kind = new AnimalKind(name, biome, eatingStrategy);

            _animalKinds.Create(kind);

            try{
                _animalKinds.Save();
                NotifyPropertyChanged();
                return(true);
            } catch (DbUpdateException ex) {
                _animalKinds.Remove(kind);
                return(false);
            }
        }
Esempio n. 25
0
        // アニマルカー別BGM番号
        public static BgmKind AnimalBgm(AnimalKind kind)
        {
            Dictionary <AnimalKind, BgmKind> bgm = new Dictionary <AnimalKind, BgmKind>()
            {
                { AnimalKind.Capybara, BgmKind.Animal_Capybara },
                { AnimalKind.Panda, BgmKind.Animal_Panda },
                { AnimalKind.Giraffe, BgmKind.Animal_Kirin },
                { AnimalKind.Elephant, BgmKind.Animal_elephant },
                { AnimalKind.Horse, BgmKind.Animal_Horse },
                { AnimalKind.Rabbit, BgmKind.Animal_Rabbit },
                { AnimalKind.Lion, BgmKind.Animal_Lion },
                { AnimalKind.Pig, BgmKind.Animal_Pig }
            };

            return(bgm[kind]);
        }
Esempio n. 26
0
        // プレイ後のデータ更新
        public void SetResult(string area, float latitude, float longitude, AnimalKind animal, int star, float distance, int score)
        {
            Debug.Log($"Result: Map: {area}  Animal: {animal.ToString()} Star: {star} Dist: {distance} Score: {score}");

            // サイズが10を超えている時は先頭要素を削除
            if (this.ResultHistory.Count > 10)
            {
                this.ResultHistory.RemoveAt(0);
            }

            var result = new Result()
            {
                AreaName  = area,
                Latitude  = latitude,
                Longitude = longitude,
                Animal    = animal.ToString(),
                Star      = star,
                Score     = score,
                Distance  = distance
            };

            // 最後尾に追加
            this.ResultHistory.Add(result);
            // 最後のプレイ状況
            //this.LastSelectedAnimalId = animal.ToString();
            this.LastPlayMapId = area;
            // 所持スター
            this.StarNum += star;
            // 総プレイ回数
            this.TotalPlayCount += 1;
            // 総走行距離
            this.TotalDistance += distance;
            // エリア履歴
            RegistPlayArea(area);

            // ハイスコアを記録したエリア
            // FIXME 同じスコアだった場合の扱い
            if (score > this.HighScoreData.Score)
            {
                this.HighScoreData.Score = score;
                this.HighScoreData.MapId = area;
            }

            PlayerDataManager.DoUpdate();
        }
        public bool Create(object item)
        {
            AnimalKind kind = (AnimalKind)item;

            _animalKinds.Create(kind);

            try
            {
                _animalKinds.Save();
                NotifyPropertyChanged();
                return(true);
            }
            catch (DbUpdateException ex)
            {
                _animalKinds.Remove(kind);
                return(false);
            }
        }
        // GET: AnimalKinds/Details/5
        public ActionResult Details(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            AnimalKind animalKind = db.AnimalKinds.Find(id);

            if (animalKind == null)
            {
                return(HttpNotFound());
            }
            return(View(new AnimalKindViewModel
            {
                AnimalKind = animalKind,
                Breeds = db.Breeds.Where(breed => breed.AnimalKind.Id == id).ToList()
            }));
        }
        public bool Update(object item)
        {
            AnimalKind kind = (AnimalKind)item;
            AnimalKind copy = (AnimalKind)_animalKind.Clone();

            _animalKind.Name           = kind.Name;
            _animalKind.EatingStrategy = kind.EatingStrategy;
            _animalKind.Biome          = kind.Biome;

            try
            {
                _animalKinds.Update(_animalKind);
                _animalKinds.Save();
                return(true);
            }
            catch (DbUpdateException ex)
            {
                Backup(_animalKind, copy);
                _animalKinds.Update(_animalKind);
                return(false);
            }
        }
      private void AddAnimals(AnimalKind kind, int count)
      {
          int existingCount;

          if (kind == AnimalKind.Wolf)
          {
              if (animals.TryGetValue(AnimalKind.BigDog, out existingCount))
              {
                  SetAnimalCount(AnimalKind.BigDog, existingCount - 1);
              }
              else
              {
                  //SetAnimalCount(AnimalKind.Rabbit, 0);
                  SetAnimalCount(AnimalKind.Sheep, 0);
                  SetAnimalCount(AnimalKind.Pig, 0);
                  SetAnimalCount(AnimalKind.Cow, 0);
                  SetAnimalCount(AnimalKind.SmallDog, 0);
              }
          }
          else
          if (kind == AnimalKind.Fox)
          {
              if (animals.TryGetValue(AnimalKind.SmallDog, out existingCount))
              {
                  SetAnimalCount(AnimalKind.SmallDog, existingCount - 1);
              }
              else
              {
                  SetAnimalCount(AnimalKind.Rabbit, 0);
              }
          }
          else
          {
              animals.TryGetValue(kind, out existingCount);
              SetAnimalCount(kind, existingCount + (existingCount + count) / 2);
          }
      }