public ShaftRemoteData UnlockShaft(int unlockedCount)
        {
            if (unlockedCount < MetaData.Shafts.Count)
            {
                ShaftRemoteData shaft = new ShaftRemoteData();

                // PATCH: MetaData is not designed properly.
                shaft.ShaftId = "S" + (unlockedCount + 1);

                ShaftLevelData data = MetaData.Shafts[shaft.ShaftId][0];

                shaft.ShaftLevel = 1;

                shaft.Miners = new List <MinerRemoteData>();
                for (int i = 0; i < data.Miners; i++)
                {
                    shaft.Miners.Add(new MinerRemoteData());
                }

                // PATCH: Remove this after adding Assign and Hire Managers functionality.
                shaft.Manager = "M1";


                return(shaft);
            }
            return(null);
        }
        public void AddShaft(ShaftRemoteData shaftRemoteData)
        {
            ShaftRemoteDataModel shaft = _shaftRemoteDataModelFactory.Create();

            shaft.SeedShaftRemoteData(shaftRemoteData);

            Shafts.Add(shaft);
        }
Esempio n. 3
0
 public void UpdateShaft(ShaftRemoteData shaftRemoteData)
 {
     if (_shafts.ContainsKey(shaftRemoteData.ShaftId))
     {
         var shaft = _shafts[shaftRemoteData.ShaftId];
         shaft.SetShaftRemoteData(shaftRemoteData);
     }
     else
     {
         Debug.LogError("Shaft missing.");
     }
 }
        public void SeedShaftRemoteData(ShaftRemoteData shaftRemoteData)
        {
            ShaftRemoteData = shaftRemoteData;

            if (shaftRemoteData.ShaftLevelData == null)
            {
                shaftRemoteData.ShaftLevelData = _staticDataModel.GetShaftLevelData(shaftRemoteData.ShaftId,
                                                                                    shaftRemoteData.ShaftLevel);
            }

            // TODO: Move this to respective Facade.
            Observable.EveryFixedUpdate().Subscribe((interval) => Tick()).AddTo(_disposables);
        }
Esempio n. 5
0
        public ShaftView AddShaft(ShaftRemoteData shaftRemoteData)
        {
            ShaftView shaftView;

            if (_shafts.ContainsKey(shaftRemoteData.ShaftId))
            {
                shaftView = _shafts[shaftRemoteData.ShaftId];
                shaftView.SetShaftRemoteData(shaftRemoteData);
            }
            else
            {
                shaftView = Instantiate(ShaftViewPrefab, _shaftsContainer);
                _shafts[shaftRemoteData.ShaftId] = shaftView;
                shaftView.SetShaftRemoteData(shaftRemoteData);
            }

            return(shaftView);
        }
 public void Execute()
 {
     try
     {
         ShaftRemoteData shaftData = _staticDataModel.UnlockShaft(_remoteDataModel.Shafts.Count);
         if (shaftData != null)
         {
             _remoteDataModel.UserData.UserShafts.Add(shaftData);
             _remoteDataModel.AddShaft(shaftData);
         }
         else
         {
             Debug.LogError("Error: No more shafts.");
         }
     }
     catch (Exception ex)
     {
         Debug.LogError("Error while Adding Shaft: " + ex.ToString());
     }
 }
Esempio n. 7
0
        public void SetShaftRemoteData(ShaftRemoteData shaftRemoteData)
        {
            _shaftRemoteData = shaftRemoteData;

            _width        = _path.rect.width;
            _unitDistance = _width / Constants.MineLength;
            _mineEndPos   = new Vector2(_width, 0f);

            while (_shaftRemoteData.Miners.Count > _miners.Count)
            {
                CreateMinerView();
            }

            for (int c = 0; c < _miners.Count; c++)
            {
                _miners[c].LoadStuff(_shaftRemoteData.Miners[c].MinedCash,
                                     _shaftRemoteData.ShaftLevelData.WorkerCapacity);
                SetMinerPosition(_miners[c], _shaftRemoteData.Miners[c]);
            }

            _binCount.text = _shaftRemoteData.BinCash.ToShort();

            _currentLevelText.text = _shaftRemoteData.ShaftLevel.ToString();
        }