Example #1
0
        Treaty GetModelDatas(TreatyViewModel _viewModel)
        {
            Treaty _model = new Treaty()
            {
                TreatyID                      = _viewModel.TreatyID,
                ContractorID                  = _viewModel.ContractorID,
                TreatyNumber                  = _viewModel.TreatyNumber,
                TreatyFileName                = _viewModel.TreatyFileName,
                TreatyBinData                 = _viewModel.TreatyBinData,
                SurnameTreatyPers             = _viewModel.SurnameTreatyPers,
                NameTreatyPers                = _viewModel.NameTreatyPers,
                PatronymicTreatyPers          = _viewModel.PatronymicTreatyPers,
                PositionTreatyPers            = _viewModel.PositionTreatyPers,
                DepartmentTreatyPers          = _viewModel.DepartmentTreatyPers,
                PhoneTreatyPers               = _viewModel.PhoneTreatyPers,
                InternalPnoneTreatyPers       = _viewModel.InternalPnoneTreatyPers,
                MobilePhoneTreatyPers         = _viewModel.MobilePhoneTreatyPers,
                EmailTreatyPers               = _viewModel.EmailTreatyPers,
                AgreementTerm                 = _viewModel.AgreementTerm,
                CommencementAgreement         = _viewModel.CommencementAgreement,
                TerminationAgreement          = _viewModel.TerminationAgreement,
                CostAgreement                 = _viewModel.CostAgreement,
                PriceContractMonth            = _viewModel.PriceContractMonth,
                CertificateCompletionFileName = _viewModel.CertificateCompletionFileName,
                CertificateCompletionBinData  = _viewModel.CertificateCompletionBinData,
                CreateDateTime                = _viewModel.CreateDateTime,
                ChangeDateTime                = _viewModel.ChangeDateTime,
                Contractor                    = _viewModel.Contractor
            };

            return(_model);
        }
Example #2
0
        public ActionResult DeleteConfirmed(int id)
        {
            Treaty treaty = db.Treaties.Find(id);

            db.Treaties.Remove(treaty);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
        private void DoBatchDelete()
        {
            IList <object> idList = RequestData.GetList <object>("IdList");

            if (idList != null && idList.Count > 0)
            {
                Treaty.DoBatchDelete(idList.ToArray());
            }
        }
        private void DoSelect()
        {
            string title = RequestData.Get("title") + "";

            if (title.Contains("baoxian"))
            {
                Treaty ty = Treaty.FindFirstByProperties(Treaty.Prop_TreatyKey, "Welfare_One");
                this.PageState.Add("Ent", ty);
            }
        }
Example #5
0
        // GET: Treaties/Delete/5
        public ActionResult Delete(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            Treaty treaty = db.Treaties.Find(id);

            if (treaty == null)
            {
                return(HttpNotFound());
            }
            return(View(treaty));
        }
Example #6
0
        public ActionResult Create(TreatyViewModel _viewModel)
        {
            if (ModelState.IsValid)
            {
                Treaty _model = new Treaty();
                _model = GetModelDatas(_viewModel);
                db.Treaties.Add(_model);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            ViewBag.ContractorID = new SelectList(db.Contractors, "ContractorID", "Company", _viewModel.ContractorID);
            return(View(_viewModel));
        }
Example #7
0
        public ActionResult Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            Treaty _model     = db.Treaties.Find(id);
            var    _viewModel = TreatyViewModel.GetViewModelDatas(_model);

            if (_model == null)
            {
                return(HttpNotFound());
            }
            ViewBag.ContractorID = new SelectList(db.Contractors, "ContractorID", "Company", _model.ContractorID);
            return(View(_viewModel));
        }
        protected void Page_Load(object sender, EventArgs e)
        {
            Treaty ent = null;

            switch (this.RequestActionString)
            {
            default:
                if (RequestActionString == "batchdelete")
                {
                    DoBatchDelete();
                }
                else
                {
                    DoSelect();
                }
                break;
            }
        }
Example #9
0
        string type = String.Empty; // 对象类型

        #endregion

        #region ASP.NET 事件

        protected void Page_Load(object sender, EventArgs e)
        {
            op   = RequestData.Get <string>("op");
            id   = RequestData.Get <string>("id");
            type = RequestData.Get <string>("type");

            Treaty ent = null;

            switch (this.RequestAction)
            {
            case RequestActionEnum.Update:
                ent = this.GetMergedData <Treaty>();
                ent.DoUpdate();

                break;

            case RequestActionEnum.Insert:
            case RequestActionEnum.Create:
                ent = this.GetPostedData <Treaty>();
                ent.DoCreate();
                break;

            case RequestActionEnum.Delete:
                ent = this.GetTargetData <Treaty>();
                ent.DoDelete();

                return;
            }

            if (op != "c" && op != "cs")
            {
                if (!String.IsNullOrEmpty(id))
                {
                    ent = Treaty.Find(id);
                }
                this.SetFormData(ent);
            }
        }
 /// <summary>
 ///     編集項目の色を更新する
 /// </summary>
 /// <param name="control">コントロール</param>
 /// <param name="treaty">協定</param>
 public void UpdateItemColor(Control control, Treaty treaty)
 {
     ScenarioEditorItemId itemId = (ScenarioEditorItemId) control.Tag;
     control.ForeColor = IsItemDirty(itemId, treaty) ? Color.Red : SystemColors.WindowText;
 }
        /// <summary>
        ///     編集項目の値を更新する
        /// </summary>
        /// <param name="control">コントロール</param>
        /// <param name="treaty">協定</param>
        public void UpdateItemValue(TextBox control, Treaty treaty)
        {
            ScenarioEditorItemId itemId = (ScenarioEditorItemId) control.Tag;
            object val = GetItemValue(itemId, treaty);
            switch (itemId)
            {
                case ScenarioEditorItemId.TradeEnergy1:
                case ScenarioEditorItemId.TradeEnergy2:
                case ScenarioEditorItemId.TradeMetal1:
                case ScenarioEditorItemId.TradeMetal2:
                case ScenarioEditorItemId.TradeRareMaterials1:
                case ScenarioEditorItemId.TradeRareMaterials2:
                case ScenarioEditorItemId.TradeOil1:
                case ScenarioEditorItemId.TradeOil2:
                case ScenarioEditorItemId.TradeSupplies1:
                case ScenarioEditorItemId.TradeSupplies2:
                case ScenarioEditorItemId.TradeMoney1:
                case ScenarioEditorItemId.TradeMoney2:
                    control.Text = DoubleHelper.IsPositive((double) val) ? DoubleHelper.ToString((double) val) : "";
                    break;

                default:
                    control.Text = ObjectHelper.ToString(val);
                    break;
            }
        }
 public Treaty DuplicateFor(Player pOwner)
 {
     Treaty treaty = new Treaty ();
     treaty.Name = name;
     treaty.FlavorText = flavorText;
     treaty.rulesText = rulesText.Replace ("<%race%>", pOwner.Race.ShortName);
     treaty.SuggestionText = suggestionText.Replace ("<%race%>", pOwner.Race.ShortName);
     treaty.Rank = rank;
     treaty.Race = pOwner.Race;
     treaty.Owner = pOwner;
     return treaty;
 }
Example #13
0
        /// <summary>
        ///     不可侵条約を削除する
        /// </summary>
        /// <param name="treaty">不可侵条約</param>
        public static void RemoveNonAggression(Treaty treaty)
        {
            if (NonAggressionTable.ContainsKey(treaty.Country1) &&
                NonAggressionTable[treaty.Country1].ContainsKey(treaty.Country2))
            {
                NonAggressionTable[treaty.Country1].Remove(treaty.Country2);
            }

            if (NonAggressionTable.ContainsKey(treaty.Country2) &&
                NonAggressionTable[treaty.Country2].ContainsKey(treaty.Country1))
            {
                NonAggressionTable[treaty.Country2].Remove(treaty.Country1);
            }
        }
Example #14
0
        /// <summary>
        ///     貿易リストの項目を作成する
        /// </summary>
        /// <param name="treaty">貿易情報</param>
        /// <returns>貿易リストの項目</returns>
        private static ListViewItem CreateTradeListViewItem(Treaty treaty)
        {
            ListViewItem item = new ListViewItem
            {
                Text = Countries.GetName(treaty.Country1),
                Tag = treaty
            };
            item.SubItems.Add(Countries.GetName(treaty.Country2));
            item.SubItems.Add(treaty.GetTradeString());

            return item;
        }
Example #15
0
        /// <summary>
        ///     貿易の新規ボタン押下時の処理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnTradeNewButtonClick(object sender, EventArgs e)
        {
            Scenario scenario = Scenarios.Data;
            List<Treaty> trades = scenario.GlobalData.Trades;

            // 貿易リストに項目を追加する
            Treaty trade = new Treaty
            {
                StartDate = new GameDate(),
                EndDate = new GameDate(),
                Id = Scenarios.GetNewTypeId(Scenarios.DefaultTreatyType, 1)
            };
            trades.Add(trade);

            // 貿易リストビューに項目を追加する
            ListViewItem item = new ListViewItem { Tag = trade };
            item.SubItems.Add("");
            item.SubItems.Add("");
            tradeListView.Items.Add(item);

            // 編集済みフラグを設定する
            trade.SetDirty(Treaty.ItemId.StartYear);
            trade.SetDirty(Treaty.ItemId.StartMonth);
            trade.SetDirty(Treaty.ItemId.StartDay);
            trade.SetDirty(Treaty.ItemId.EndYear);
            trade.SetDirty(Treaty.ItemId.EndMonth);
            trade.SetDirty(Treaty.ItemId.EndDay);
            trade.SetDirty(Treaty.ItemId.Type);
            trade.SetDirty(Treaty.ItemId.Id);
            trade.SetDirty(Treaty.ItemId.Cancel);
            Scenarios.Data.SetDirty();
            Scenarios.SetDirty();

            // 追加した項目を選択する
            if (tradeListView.SelectedIndices.Count > 0)
            {
                ListViewItem prev = tradeListView.SelectedItems[0];
                prev.Focused = false;
                prev.Selected = false;
            }
            item.Focused = true;
            item.Selected = true;
        }
Example #16
0
        private static Tuple <StatesDB, Player[], Player> loadSaveData(IkonComposite saveData, ObjectDeindexer deindexer, StaticsDB statics)
        {
            var stateData  = saveData[MainGame.StatesKey].To <IkonComposite>();
            var ordersData = saveData[MainGame.OrdersKey].To <IkonArray>();

            var stars = new StarCollection();

            foreach (var rawData in stateData[StatesDB.StarsKey].To <IEnumerable <IkonComposite> >())
            {
                stars.Add(StarData.Load(rawData, deindexer));
            }

            var planets = new PlanetCollection();

            foreach (var rawData in stateData[StatesDB.PlanetsKey].To <IEnumerable <IkonComposite> >())
            {
                planets.Add(Planet.Load(rawData, deindexer));
            }

            var wormholes = new WormholeCollection();

            foreach (var rawData in stateData[StatesDB.WormholesKey].To <IEnumerable <IkonComposite> >())
            {
                wormholes.Add(Wormhole.Load(rawData, deindexer));
            }

            var players = new List <Player>();

            foreach (var rawData in saveData[MainGame.PlayersKey].To <IEnumerable <IkonComposite> >())
            {
                players.Add(Player.Load(rawData, deindexer));
            }

            var organellePlayer = Player.Load(saveData[MainGame.OrganellePlayerKey].To <IkonComposite>(), deindexer);

            var developments = new DevelopmentProgressCollection();

            foreach (var rawData in stateData[StatesDB.DevelopmentAdvancesKey].To <IEnumerable <IkonComposite> >())
            {
                developments.Add(DevelopmentProgress.Load(rawData, deindexer));
            }

            var research = new ResearchProgressCollection();

            foreach (var rawData in stateData[StatesDB.ResearchAdvancesKey].To <IEnumerable <IkonComposite> >())
            {
                research.Add(ResearchProgress.Load(rawData, deindexer));
            }

            var treaties = new TreatyCollection();

            foreach (var rawData in stateData[StatesDB.TreatiesKey].To <IEnumerable <IkonComposite> >())
            {
                treaties.Add(Treaty.Load(rawData, deindexer));
            }

            var reports = new ReportCollection();

            foreach (var rawData in stateData[StatesDB.ReportsKey].To <IEnumerable <IkonComposite> >())
            {
                reports.Add(ReportFactory.Load(rawData, deindexer));
            }

            var designs = new DesignCollection();

            foreach (var rawData in stateData[StatesDB.DesignsKey].To <IEnumerable <IkonComposite> >())
            {
                var design = Design.Load(rawData, deindexer);
                design.CalcHash(statics);
                designs.Add(design);
                deindexer.Add(design.ConstructionProject, design.ConstructionProject.IdCode);
            }

            var colonizations = new ColonizationCollection();

            foreach (var rawData in stateData[StatesDB.ColonizationKey].To <IEnumerable <IkonComposite> >())
            {
                colonizations.Add(ColonizationProject.Load(rawData, deindexer));
            }

            var fleets = new FleetCollection();

            foreach (var rawData in stateData[StatesDB.IdleFleetsKey].To <IEnumerable <IkonComposite> >())
            {
                fleets.Add(Fleet.Load(rawData, deindexer));
            }

            var colonies = new ColonyCollection();

            foreach (var rawData in stateData[StatesDB.ColoniesKey].To <IEnumerable <IkonComposite> >())
            {
                colonies.Add(Colony.Load(rawData, deindexer));
            }

            var stellarises = new StellarisCollection();

            foreach (var rawData in stateData[StatesDB.StellarisesKey].To <IEnumerable <IkonComposite> >())
            {
                stellarises.Add(StellarisAdmin.Load(rawData, deindexer));
            }

            for (int i = 0; i < players.Count; i++)
            {
                players[i].Orders = PlayerOrders.Load(ordersData[i].To <IkonComposite>(), deindexer);
            }
            organellePlayer.Orders = PlayerOrders.Load(saveData[MainGame.OrganelleOrdersKey].To <IkonComposite>(), deindexer);

            return(new Tuple <StatesDB, Player[], Player>(
                       new StatesDB(stars, wormholes, planets, colonies, stellarises, developments, research, treaties, reports, designs, fleets, colonizations),
                       players.ToArray(),
                       organellePlayer
                       ));
        }
Example #17
0
        /// <summary>
        ///     貿易内容の編集項目を更新する
        /// </summary>
        /// <param name="treaty">協定</param>
        private void UpdateTradeDealsItems(Treaty treaty)
        {
            // 編集項目の表示を更新する
            _controller.UpdateItemValue(tradeCountryComboBox1, treaty);
            _controller.UpdateItemValue(tradeCountryComboBox2, treaty);
            _controller.UpdateItemValue(tradeEnergyTextBox1, treaty);
            _controller.UpdateItemValue(tradeEnergyTextBox2, treaty);
            _controller.UpdateItemValue(tradeMetalTextBox1, treaty);
            _controller.UpdateItemValue(tradeMetalTextBox2, treaty);
            _controller.UpdateItemValue(tradeRareMaterialsTextBox1, treaty);
            _controller.UpdateItemValue(tradeRareMaterialsTextBox2, treaty);
            _controller.UpdateItemValue(tradeOilTextBox1, treaty);
            _controller.UpdateItemValue(tradeOilTextBox2, treaty);
            _controller.UpdateItemValue(tradeSuppliesTextBox1, treaty);
            _controller.UpdateItemValue(tradeSuppliesTextBox2, treaty);
            _controller.UpdateItemValue(tradeMoneyTextBox1, treaty);
            _controller.UpdateItemValue(tradeMoneyTextBox2, treaty);

            // 編集項目の色を更新する
            _controller.UpdateItemColor(tradeEnergyTextBox1, treaty);
            _controller.UpdateItemColor(tradeEnergyTextBox2, treaty);
            _controller.UpdateItemColor(tradeMetalTextBox1, treaty);
            _controller.UpdateItemColor(tradeMetalTextBox2, treaty);
            _controller.UpdateItemColor(tradeRareMaterialsTextBox1, treaty);
            _controller.UpdateItemColor(tradeRareMaterialsTextBox2, treaty);
            _controller.UpdateItemColor(tradeOilTextBox1, treaty);
            _controller.UpdateItemColor(tradeOilTextBox2, treaty);
            _controller.UpdateItemColor(tradeSuppliesTextBox1, treaty);
            _controller.UpdateItemColor(tradeSuppliesTextBox2, treaty);
            _controller.UpdateItemColor(tradeMoneyTextBox1, treaty);
            _controller.UpdateItemColor(tradeMoneyTextBox2, treaty);
        }
        /// <summary>
        ///     項目変更前の処理 - 協定id
        /// </summary>
        /// <param name="control">typeのコントロール</param>
        /// <param name="val">編集項目の値</param>
        /// <param name="treaty">協定</param>
        private void PreItemChangedTreatyId(TextBox control, object val, Treaty treaty)
        {
            treaty.Id.Type = Scenarios.GetNewType(Scenarios.DefaultTreatyType, (int) val);

            // 編集済みフラグを設定する
            ScenarioEditorItemId itemId = (ScenarioEditorItemId) control.Tag;
            SetItemDirty(itemId, treaty);

            // 編集項目の値を更新する
            UpdateItemValue(control, treaty);

            // 編集項目の色を更新する
            UpdateItemColor(control, treaty);
        }
        /// <summary>
        ///     項目変更前の処理 - 協定type
        /// </summary>
        /// <param name="control">idのコントロール</param>
        /// <param name="val">編集項目の値</param>
        /// <param name="treaty">協定</param>
        private void PreItemChangedTreatyType(TextBox control, object val, Treaty treaty)
        {
            // 新規idを設定する
            treaty.Id.Id = Scenarios.GetNewId((int) val, 1);

            // 編集済みフラグを設定する
            ScenarioEditorItemId itemId = (ScenarioEditorItemId) control.Tag;
            SetItemDirty(itemId, treaty);

            // 編集項目の値を更新する
            UpdateItemValue(control, treaty);

            // 編集項目の色を更新する
            UpdateItemColor(control, treaty);
        }
        /// <summary>
        ///     項目値変更後の処理 - 貿易量
        /// </summary>
        /// <param name="control1">変更対象のコントロール</param>
        /// <param name="control2">連動するコントロール</param>
        /// <param name="treaty">協定</param>
        private void PostItemChangedTradeDeals(TextBox control1, TextBox control2, Treaty treaty)
        {
            // 項目の値を更新する
            UpdateItemValue(control1, treaty);
            UpdateItemValue(control2, treaty);

            // 項目の色を更新する
            UpdateItemColor(control2, treaty);

            // 貿易リストビューの項目を更新する
            _form.SetTradeListItemText(2, treaty.GetTradeString());
        }
 /// <summary>
 ///     編集項目の値を更新する
 /// </summary>
 /// <param name="control">コントロール</param>
 /// <param name="treaty">協定</param>
 public void UpdateItemValue(ComboBox control, Treaty treaty)
 {
     ScenarioEditorItemId itemId = (ScenarioEditorItemId) control.Tag;
     control.SelectedIndex = Array.IndexOf(Countries.Tags, (Country) GetItemValue(itemId, treaty));
 }
Example #22
0
        /// <summary>
        ///     講和条約を削除する
        /// </summary>
        /// <param name="peace">講和条約</param>
        public static void RemovePeace(Treaty peace)
        {
            if (PeaceTable.ContainsKey(peace.Country1) &&
                PeaceTable[peace.Country1].ContainsKey(peace.Country2))
            {
                PeaceTable[peace.Country1].Remove(peace.Country2);
            }

            if (PeaceTable.ContainsKey(peace.Country2) &&
                PeaceTable[peace.Country2].ContainsKey(peace.Country1))
            {
                PeaceTable[peace.Country2].Remove(peace.Country1);
            }
        }
 /// <summary>
 /// 查询
 /// </summary>
 private void DoSelect()
 {
     ents = Treaty.FindAll(SearchCriterion);
     this.PageState.Add("DataList", ents);
 }
    private Treaty readTreaty(string dataType, string dataText, string fileName, StreamReader reader)
    {
        if (dataText == "<{>") {
            Treaty treaty = new Treaty();
            string line = reader.ReadLine().Trim ();

            do {
                string[] lineParts;
                //Split category name from data
                lineParts = line.Split(":".ToCharArray(), 2);

                //Remove any extra whitespace from parts & set descriptive variables
                string newDataType = gameManager.LanguageMgr.StringToDataType(lineParts[0].Trim ());
                string newDataText = lineParts[1].Trim ();

                if (newDataType == "Name") {
                    treaty.Name = readTextLine(newDataType, newDataText, fileName);
                } else if (newDataType == "Flavor Text") {
                    treaty.FlavorText = readTextLine (newDataType, newDataText, fileName);
                } else if (newDataType == "Rule Text") {
                    treaty.RulesText = readTextLine(newDataType, newDataText, fileName);
                } else if (newDataType == "Suggestion") {
                    treaty.SuggestionText = readTextLine(newDataType, newDataText, fileName);
                } else if (newDataType == "Rank") {
                    treaty.Rank = readIntLine (newDataType, newDataText, fileName);
                } else if (newDataType == "Race") {
                    treaty.Race = gameManager.PlayerMgr.GetRace (readTextLine(newDataType, newDataText, fileName));
                } else if (newDataType == "ID") {
                    treaty.Id = readTextLine (newDataType, newDataText, fileName);
                }

                line = reader.ReadLine().Trim ();
            } while (line != "<}>");
            // End of outermost block

            if (treaty.Id == default(string)) {
                treaty.Id = treaty.Name;
            }

            return treaty;
        } else {
            throw new System.Exception(string.Format("Error reading file {0}:: got \"{1}\" should be <{>", fileName, dataText));
        }
    }
 /// <summary>
 ///     編集項目の値を更新する
 /// </summary>
 /// <param name="control">コントロール</param>
 /// <param name="treaty">協定</param>
 public void UpdateItemValue(CheckBox control, Treaty treaty)
 {
     ScenarioEditorItemId itemId = (ScenarioEditorItemId) control.Tag;
     control.Checked = (bool) GetItemValue(itemId, treaty);
 }
Example #26
0
 /// <summary>
 ///     外交協定情報を書き出す
 /// </summary>
 /// <param name="treaty">外交協定情報</param>
 /// <param name="writer">ファイル書き込み用</param>
 private static void WriteTreaty(Treaty treaty, TextWriter writer)
 {
     writer.WriteLine("  treaty = {");
     if (treaty.Id != null)
     {
         writer.Write("    id             = ");
         WriteTypeId(treaty.Id, writer);
         writer.WriteLine();
     }
     if (treaty.IsOverSea && (Game.Type == GameType.ArsenalOfDemocracy))
     {
         writer.WriteLine("    isoversea      = yes");
     }
     writer.WriteLine("    type           = {0}", Scenarios.TreatyStrings[(int) treaty.Type]);
     writer.WriteLine("    country        = \"{0}\"", treaty.Country1);
     writer.WriteLine("    country        = \"{0}\"", treaty.Country2);
     if (treaty.StartDate != null)
     {
         writer.Write("    startdate      = ");
         WriteDate(treaty.StartDate, writer);
         writer.WriteLine();
     }
     if (treaty.EndDate != null)
     {
         writer.Write("    expirydate     = ");
         WriteDate(treaty.EndDate, writer);
         writer.WriteLine();
     }
     if (!DoubleHelper.IsZero(treaty.Energy))
     {
         writer.WriteLine("    energy         = {0}", DoubleHelper.ToString(treaty.Energy));
     }
     if (!DoubleHelper.IsZero(treaty.Metal))
     {
         writer.WriteLine("    metal          = {0}", DoubleHelper.ToString(treaty.Metal));
     }
     if (!DoubleHelper.IsZero(treaty.RareMaterials))
     {
         writer.WriteLine("    rare_materials = {0}", DoubleHelper.ToString(treaty.RareMaterials));
     }
     if (!DoubleHelper.IsZero(treaty.Oil))
     {
         writer.WriteLine("    oil            = {0}", DoubleHelper.ToString(treaty.Oil));
     }
     if (!DoubleHelper.IsZero(treaty.Supplies))
     {
         writer.WriteLine("    supplies       = {0}", DoubleHelper.ToString(treaty.Supplies));
     }
     if (!DoubleHelper.IsZero(treaty.Money))
     {
         writer.WriteLine("    money          = {0}", DoubleHelper.ToString(treaty.Money));
     }
     if (!treaty.Cancel)
     {
         writer.WriteLine("    cancel         = no");
     }
     writer.WriteLine("  }");
 }
        /// <summary>
        ///     項目値変更後の処理 - 不可侵条約/講和条約
        /// </summary>
        /// <param name="control1">コントロール1</param>
        /// <param name="control2">コントロール2</param>
        /// <param name="control3">コントロール3</param>
        /// <param name="control4">コントロール4</param>
        /// <param name="control5">コントロール5</param>
        /// <param name="control6">コントロール6</param>
        /// <param name="control7">コントロール7</param>
        /// <param name="control8">コントロール8</param>
        /// <param name="val">編集項目の値</param>
        /// <param name="treaty">協定</param>
        /// <param name="no">関係リストビューの項目番号</param>
        private void PostItemChangedTreaty(TextBox control1, TextBox control2, TextBox control3, TextBox control4,
            TextBox control5, TextBox control6, TextBox control7, TextBox control8, object val, Treaty treaty, int no)
        {
            // 項目の値を更新する
            UpdateItemValue(control1, treaty);
            UpdateItemValue(control2, treaty);
            UpdateItemValue(control3, treaty);
            UpdateItemValue(control4, treaty);
            UpdateItemValue(control5, treaty);
            UpdateItemValue(control6, treaty);
            UpdateItemValue(control7, treaty);
            UpdateItemValue(control8, treaty);

            // 項目の色を更新する
            UpdateItemColor(control1, treaty);
            UpdateItemColor(control2, treaty);
            UpdateItemColor(control3, treaty);
            UpdateItemColor(control4, treaty);
            UpdateItemColor(control5, treaty);
            UpdateItemColor(control6, treaty);
            UpdateItemColor(control7, treaty);
            UpdateItemColor(control8, treaty);

            // 項目を有効化/無効化する
            control1.Enabled = (bool) val;
            control2.Enabled = (bool) val;
            control3.Enabled = (bool) val;
            control4.Enabled = (bool) val;
            control5.Enabled = (bool) val;
            control6.Enabled = (bool) val;
            control7.Enabled = (bool) val;
            control8.Enabled = (bool) val;

            // 関係リストビューの項目を更新する
            _form.SetRelationListItemText(no, (bool) val ? Resources.Yes : "");
        }
        /// <summary>
        ///     編集項目の値を取得する
        /// </summary>
        /// <param name="itemId">項目ID</param>
        /// <param name="treaty">協定</param>
        /// <returns>編集項目の値</returns>
        public object GetItemValue(ScenarioEditorItemId itemId, Treaty treaty)
        {
            switch (itemId)
            {
                case ScenarioEditorItemId.DiplomacyNonAggression:
                case ScenarioEditorItemId.DiplomacyPeace:
                    return treaty != null;

                case ScenarioEditorItemId.DiplomacyNonAggressionStartYear:
                case ScenarioEditorItemId.DiplomacyPeaceStartYear:
                case ScenarioEditorItemId.TradeStartYear:
                    return treaty?.StartDate?.Year;

                case ScenarioEditorItemId.DiplomacyNonAggressionStartMonth:
                case ScenarioEditorItemId.DiplomacyPeaceStartMonth:
                case ScenarioEditorItemId.TradeStartMonth:
                    return treaty?.StartDate?.Month;

                case ScenarioEditorItemId.DiplomacyNonAggressionStartDay:
                case ScenarioEditorItemId.DiplomacyPeaceStartDay:
                case ScenarioEditorItemId.TradeStartDay:
                    return treaty?.StartDate?.Day;

                case ScenarioEditorItemId.DiplomacyNonAggressionEndYear:
                case ScenarioEditorItemId.DiplomacyPeaceEndYear:
                case ScenarioEditorItemId.TradeEndYear:
                    return treaty?.EndDate?.Year;

                case ScenarioEditorItemId.DiplomacyNonAggressionEndMonth:
                case ScenarioEditorItemId.DiplomacyPeaceEndMonth:
                case ScenarioEditorItemId.TradeEndMonth:
                    return treaty?.EndDate?.Month;

                case ScenarioEditorItemId.DiplomacyNonAggressionEndDay:
                case ScenarioEditorItemId.DiplomacyPeaceEndDay:
                case ScenarioEditorItemId.TradeEndDay:
                    return treaty?.EndDate?.Day;

                case ScenarioEditorItemId.DiplomacyNonAggressionType:
                case ScenarioEditorItemId.DiplomacyPeaceType:
                case ScenarioEditorItemId.TradeType:
                    return treaty?.Id?.Type;

                case ScenarioEditorItemId.DiplomacyNonAggressionId:
                case ScenarioEditorItemId.DiplomacyPeaceId:
                case ScenarioEditorItemId.TradeId:
                    return treaty?.Id?.Id;

                case ScenarioEditorItemId.TradeCancel:
                    return treaty.Cancel;

                case ScenarioEditorItemId.TradeCountry1:
                    return treaty.Country1;

                case ScenarioEditorItemId.TradeCountry2:
                    return treaty.Country2;

                case ScenarioEditorItemId.TradeEnergy1:
                    return -treaty.Energy;

                case ScenarioEditorItemId.TradeEnergy2:
                    return treaty.Energy;

                case ScenarioEditorItemId.TradeMetal1:
                    return -treaty.Metal;

                case ScenarioEditorItemId.TradeMetal2:
                    return treaty.Metal;

                case ScenarioEditorItemId.TradeRareMaterials1:
                    return -treaty.RareMaterials;

                case ScenarioEditorItemId.TradeRareMaterials2:
                    return treaty.RareMaterials;

                case ScenarioEditorItemId.TradeOil1:
                    return -treaty.Oil;

                case ScenarioEditorItemId.TradeOil2:
                    return treaty.Oil;

                case ScenarioEditorItemId.TradeSupplies1:
                    return -treaty.Supplies;

                case ScenarioEditorItemId.TradeSupplies2:
                    return treaty.Supplies;

                case ScenarioEditorItemId.TradeMoney1:
                    return -treaty.Money;

                case ScenarioEditorItemId.TradeMoney2:
                    return treaty.Money;
            }

            return null;
        }
        /// <summary>
        ///     項目変更前の処理 - 協定開始日時
        /// </summary>
        /// <param name="control1">連動するコントロール1</param>
        /// <param name="control2">連動するコントロール2</param>
        /// <param name="treaty">協定</param>
        private void PreItemChangedTreatyStartDate(TextBox control1, TextBox control2, Treaty treaty)
        {
            if (treaty.StartDate == null)
            {
                treaty.StartDate = new GameDate();

                // 編集済みフラグを設定する
                ScenarioEditorItemId itemId1 = (ScenarioEditorItemId) control1.Tag;
                SetItemDirty(itemId1, treaty);
                ScenarioEditorItemId itemId2 = (ScenarioEditorItemId) control2.Tag;
                SetItemDirty(itemId2, treaty);

                // 編集項目の値を更新する
                UpdateItemValue(control1, treaty);
                UpdateItemValue(control2, treaty);

                // 編集項目の色を更新する
                UpdateItemColor(control1, treaty);
                UpdateItemColor(control2, treaty);
            }
        }
        /// <summary>
        ///     編集項目の編集済みフラグを取得する
        /// </summary>
        /// <param name="itemId">項目ID</param>
        /// <param name="treaty">協定</param>
        /// <returns>編集済みフラグ</returns>
        public bool IsItemDirty(ScenarioEditorItemId itemId, Treaty treaty)
        {
            switch (itemId)
            {
                case ScenarioEditorItemId.DiplomacyNonAggression:
                case ScenarioEditorItemId.DiplomacyPeace:
                    return (treaty != null) && treaty.IsDirty();

                default:
                    return (treaty != null) && treaty.IsDirty((Treaty.ItemId) ItemDirtyFlags[(int) itemId]);
            }
        }
Example #31
0
        /// <summary>
        ///     外交協定設定を構文解析する
        /// </summary>
        /// <param name="lexer">字句解析器</param>
        /// <returns>外交協定設定</returns>
        private static Treaty ParseTreaty(TextLexer lexer)
        {
            // =
            Token token = lexer.GetToken();
            if (token.Type != TokenType.Equal)
            {
                Log.InvalidToken(LogCategory, token, lexer);
                return null;
            }

            // {
            token = lexer.GetToken();
            if (token.Type != TokenType.OpenBrace)
            {
                Log.InvalidToken(LogCategory, token, lexer);
                return null;
            }

            Treaty treaty = new Treaty();
            while (true)
            {
                token = lexer.GetToken();

                // ファイルの終端
                if (token == null)
                {
                    break;
                }

                // } (セクション終端)
                if (token.Type == TokenType.CloseBrace)
                {
                    break;
                }

                // 無効なトークン
                if (token.Type != TokenType.Identifier)
                {
                    Log.InvalidToken(LogCategory, token, lexer);
                    lexer.SkipLine();
                    continue;
                }

                string keyword = token.Value as string;
                if (string.IsNullOrEmpty(keyword))
                {
                    continue;
                }
                keyword = keyword.ToLower();

                // id
                if (keyword.Equals("id"))
                {
                    TypeId id = ParseTypeId(lexer);
                    if (id == null)
                    {
                        Log.InvalidSection(LogCategory, "id", lexer);
                        continue;
                    }

                    // typeとidの組
                    treaty.Id = id;
                    continue;
                }

                // type
                if (keyword.Equals("type"))
                {
                    string s = ParseIdentifier(lexer);
                    if (string.IsNullOrEmpty(s))
                    {
                        Log.InvalidClause(LogCategory, "type", lexer);
                        continue;
                    }
                    s = s.ToLower();

                    // non_aggression
                    if (s.Equals("non_aggression"))
                    {
                        treaty.Type = TreatyType.NonAggression;
                        continue;
                    }

                    // peace
                    if (s.Equals("peace"))
                    {
                        treaty.Type = TreatyType.Peace;
                        continue;
                    }

                    // trade
                    if (s.Equals("trade"))
                    {
                        treaty.Type = TreatyType.Trade;
                        continue;
                    }

                    // 無効なトークン
                    Log.InvalidToken(LogCategory, token, lexer);
                    continue;
                }

                // country
                if (keyword.Equals("country"))
                {
                    Country? tag = ParseTag(lexer);
                    if (!tag.HasValue)
                    {
                        Log.InvalidClause(LogCategory, "country", lexer);
                        continue;
                    }

                    // 対象国
                    if (treaty.Country1 == Country.None)
                    {
                        treaty.Country1 = (Country) tag;
                    }
                    else if (treaty.Country2 == Country.None)
                    {
                        treaty.Country2 = (Country) tag;
                    }
                    continue;
                }

                // startdate
                if (keyword.Equals("startdate"))
                {
                    GameDate date = ParseDate(lexer);
                    if (date == null)
                    {
                        Log.InvalidSection(LogCategory, "startdate", lexer);
                        continue;
                    }

                    // 開始日時
                    treaty.StartDate = date;
                    continue;
                }

                // expirydate
                if (keyword.Equals("expirydate"))
                {
                    GameDate date = ParseDate(lexer);
                    if (date == null)
                    {
                        Log.InvalidSection(LogCategory, "expirydate", lexer);
                        continue;
                    }

                    // 失効日時
                    treaty.EndDate = date;
                    continue;
                }

                // money
                if (keyword.Equals("money"))
                {
                    double? d = ParseDouble(lexer);
                    if (!d.HasValue)
                    {
                        Log.InvalidClause(LogCategory, "money", lexer);
                        continue;
                    }

                    // 資金
                    treaty.Money = (double) d;
                    continue;
                }

                // supplies
                if (keyword.Equals("supplies"))
                {
                    double? d = ParseDouble(lexer);
                    if (!d.HasValue)
                    {
                        Log.InvalidClause(LogCategory, "supplies", lexer);
                        continue;
                    }

                    // 物資
                    treaty.Supplies = (double) d;
                    continue;
                }

                // energy
                if (keyword.Equals("energy"))
                {
                    double? d = ParseDouble(lexer);
                    if (!d.HasValue)
                    {
                        Log.InvalidClause(LogCategory, "energy", lexer);
                        continue;
                    }

                    // エネルギー
                    treaty.Energy = (double) d;
                    continue;
                }

                // metal
                if (keyword.Equals("metal"))
                {
                    double? d = ParseDouble(lexer);
                    if (!d.HasValue)
                    {
                        Log.InvalidClause(LogCategory, "metal", lexer);
                        continue;
                    }

                    // 金属
                    treaty.Metal = (double) d;
                    continue;
                }

                // rare_materials
                if (keyword.Equals("rare_materials"))
                {
                    double? d = ParseDouble(lexer);
                    if (!d.HasValue)
                    {
                        Log.InvalidClause(LogCategory, "rare_materials", lexer);
                        continue;
                    }

                    // 希少資源
                    treaty.RareMaterials = (double) d;
                    continue;
                }

                // oil
                if (keyword.Equals("oil"))
                {
                    double? d = ParseDouble(lexer);
                    if (!d.HasValue)
                    {
                        Log.InvalidClause(LogCategory, "oil", lexer);
                        continue;
                    }

                    // 石油
                    treaty.Oil = (double) d;
                    continue;
                }

                // cancel
                if (keyword.Equals("cancel"))
                {
                    bool? b = ParseBool(lexer);
                    if (!b.HasValue)
                    {
                        Log.InvalidClause(LogCategory, "cancel", lexer);
                        continue;
                    }

                    // 取り消し可能かどうか
                    treaty.Cancel = (bool) b;
                    continue;
                }

                if (Game.Type == GameType.ArsenalOfDemocracy)
                {
                    // isoversea
                    if (keyword.Equals("isoversea"))
                    {
                        bool? b = ParseBool(lexer);
                        if (!b.HasValue)
                        {
                            Log.InvalidClause(LogCategory, "isoversea", lexer);
                            continue;
                        }

                        // 海外貿易かどうか
                        treaty.IsOverSea = (bool) b;
                        continue;
                    }
                }

                // 無効なトークン
                Log.InvalidToken(LogCategory, token, lexer);
                lexer.SkipLine();
            }

            return treaty;
        }
        /// <summary>
        ///     編集項目の値が有効かどうかを判定する
        /// </summary>
        /// <param name="itemId">項目ID</param>
        /// <param name="val">編集項目の値</param>
        /// <param name="treaty">協定</param>
        /// <returns>編集項目の値が有効でなければfalseを返す</returns>
        public bool IsItemValueValid(ScenarioEditorItemId itemId, object val, Treaty treaty)
        {
            switch (itemId)
            {
                case ScenarioEditorItemId.DiplomacyNonAggressionStartYear:
                case ScenarioEditorItemId.DiplomacyNonAggressionEndYear:
                case ScenarioEditorItemId.DiplomacyPeaceStartYear:
                case ScenarioEditorItemId.DiplomacyPeaceEndYear:
                case ScenarioEditorItemId.TradeStartYear:
                case ScenarioEditorItemId.TradeEndYear:
                    if (((int) val < GameDate.MinYear) || ((int) val > GameDate.MaxYear))
                    {
                        return false;
                    }
                    break;

                case ScenarioEditorItemId.DiplomacyNonAggressionStartMonth:
                case ScenarioEditorItemId.DiplomacyNonAggressionEndMonth:
                case ScenarioEditorItemId.DiplomacyPeaceStartMonth:
                case ScenarioEditorItemId.DiplomacyPeaceEndMonth:
                case ScenarioEditorItemId.TradeStartMonth:
                case ScenarioEditorItemId.TradeEndMonth:
                    if (((int) val < GameDate.MinMonth) || ((int) val > GameDate.MaxMonth))
                    {
                        return false;
                    }
                    break;

                case ScenarioEditorItemId.DiplomacyNonAggressionStartDay:
                case ScenarioEditorItemId.DiplomacyNonAggressionEndDay:
                case ScenarioEditorItemId.DiplomacyPeaceStartDay:
                case ScenarioEditorItemId.DiplomacyPeaceEndDay:
                case ScenarioEditorItemId.TradeStartDay:
                case ScenarioEditorItemId.TradeEndDay:
                    if (((int) val < GameDate.MinDay) || ((int) val > GameDate.MaxDay))
                    {
                        return false;
                    }
                    break;

                case ScenarioEditorItemId.DiplomacyNonAggressionType:
                case ScenarioEditorItemId.DiplomacyPeaceType:
                case ScenarioEditorItemId.TradeType:
                    if ((treaty.Id != null) && Scenarios.ExistsTypeId((int) val, treaty.Id.Id))
                    {
                        return false;
                    }
                    break;

                case ScenarioEditorItemId.DiplomacyNonAggressionId:
                case ScenarioEditorItemId.DiplomacyPeaceId:
                case ScenarioEditorItemId.TradeId:
                    if ((treaty.Id != null) && Scenarios.ExistsTypeId(treaty.Id.Type, (int) val))
                    {
                        return false;
                    }
                    break;
            }

            return true;
        }
Example #33
0
        /// <summary>
        ///     講和条約の編集項目を更新する
        /// </summary>
        /// <param name="treaty">協定</param>
        private void UpdatePeaceItems(Treaty treaty)
        {
            _controller.UpdateItemValue(peaceCheckBox, treaty);
            _controller.UpdateItemValue(peaceStartYearTextBox, treaty);
            _controller.UpdateItemValue(peaceStartMonthTextBox, treaty);
            _controller.UpdateItemValue(peaceStartDayTextBox, treaty);
            _controller.UpdateItemValue(peaceEndYearTextBox, treaty);
            _controller.UpdateItemValue(peaceEndMonthTextBox, treaty);
            _controller.UpdateItemValue(peaceEndDayTextBox, treaty);
            _controller.UpdateItemValue(peaceTypeTextBox, treaty);
            _controller.UpdateItemValue(peaceIdTextBox, treaty);

            _controller.UpdateItemColor(peaceCheckBox, treaty);
            _controller.UpdateItemColor(peaceStartYearTextBox, treaty);
            _controller.UpdateItemColor(peaceStartMonthTextBox, treaty);
            _controller.UpdateItemColor(peaceStartDayTextBox, treaty);
            _controller.UpdateItemColor(peaceEndYearTextBox, treaty);
            _controller.UpdateItemColor(peaceEndMonthTextBox, treaty);
            _controller.UpdateItemColor(peaceEndDayTextBox, treaty);
            _controller.UpdateItemColor(peaceTypeTextBox, treaty);
            _controller.UpdateItemColor(peaceIdTextBox, treaty);

            bool flag = (bool) _controller.GetItemValue(ScenarioEditorItemId.DiplomacyPeace, treaty);
            peaceStartLabel.Enabled = flag;
            peaceStartYearTextBox.Enabled = flag;
            peaceStartMonthTextBox.Enabled = flag;
            peaceStartDayTextBox.Enabled = flag;
            peaceEndLabel.Enabled = flag;
            peaceEndYearTextBox.Enabled = flag;
            peaceEndMonthTextBox.Enabled = flag;
            peaceEndDayTextBox.Enabled = flag;
            peaceIdLabel.Enabled = flag;
            peaceTypeTextBox.Enabled = flag;
            peaceIdTextBox.Enabled = flag;
        }
 /// <summary>
 ///     編集項目の値変更時のログを出力する
 /// </summary>
 /// <param name="itemId">項目ID</param>
 /// <param name="val">編集項目の値</param>
 /// <param name="prev">変更前の値</param>
 /// <param name="treaty">協定</param>
 public void OutputItemValueChangedLog(ScenarioEditorItemId itemId, object val, object prev, Treaty treaty)
 {
     Log.Info("[Scenario] {0}: {1} -> {2} ({3}:{4})", ItemStrings[(int) itemId],
         ObjectHelper.ToString(prev), ObjectHelper.ToString(val), Countries.Strings[(int) treaty.Country1],
         Countries.Strings[(int) treaty.Country2]);
 }
Example #35
0
        /// <summary>
        ///     貿易情報の編集項目を更新する
        /// </summary>
        /// <param name="treaty">協定</param>
        private void UpdateTradeInfoItems(Treaty treaty)
        {
            // 編集項目の表示を更新する
            _controller.UpdateItemValue(tradeStartYearTextBox, treaty);
            _controller.UpdateItemValue(tradeStartMonthTextBox, treaty);
            _controller.UpdateItemValue(tradeStartDayTextBox, treaty);
            _controller.UpdateItemValue(tradeEndYearTextBox, treaty);
            _controller.UpdateItemValue(tradeEndMonthTextBox, treaty);
            _controller.UpdateItemValue(tradeEndDayTextBox, treaty);
            _controller.UpdateItemValue(tradeTypeTextBox, treaty);
            _controller.UpdateItemValue(tradeIdTextBox, treaty);
            _controller.UpdateItemValue(tradeCancelCheckBox, treaty);

            // 編集項目の色を更新する
            _controller.UpdateItemColor(tradeStartYearTextBox, treaty);
            _controller.UpdateItemColor(tradeStartMonthTextBox, treaty);
            _controller.UpdateItemColor(tradeStartDayTextBox, treaty);
            _controller.UpdateItemColor(tradeEndYearTextBox, treaty);
            _controller.UpdateItemColor(tradeEndMonthTextBox, treaty);
            _controller.UpdateItemColor(tradeEndDayTextBox, treaty);
            _controller.UpdateItemColor(tradeTypeTextBox, treaty);
            _controller.UpdateItemColor(tradeIdTextBox, treaty);
            _controller.UpdateItemColor(tradeCancelCheckBox, treaty);
        }
        /// <summary>
        ///     項目値変更後の処理
        /// </summary>
        /// <param name="itemId">項目ID</param>
        /// <param name="val">編集項目の値</param>
        /// <param name="treaty">協定</param>
        public void PostItemChanged(ScenarioEditorItemId itemId, object val, Treaty treaty)
        {
            switch (itemId)
            {
                case ScenarioEditorItemId.DiplomacyNonAggression:
                    PostItemChangedTreaty(
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyNonAggressionStartYear),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyNonAggressionStartMonth),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyNonAggressionStartDay),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyNonAggressionEndYear),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyNonAggressionEndMonth),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyNonAggressionEndDay),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyNonAggressionType),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyNonAggressionId), val, treaty, 6);
                    break;

                case ScenarioEditorItemId.DiplomacyPeace:
                    PostItemChangedTreaty((TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyPeaceStartYear),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyPeaceStartMonth),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyPeaceStartDay),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyPeaceEndYear),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyPeaceEndMonth),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyPeaceEndDay),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyPeaceType),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyPeaceId), val, treaty, 7);
                    break;

                case ScenarioEditorItemId.TradeCountry1:
                    _form.SetTradeListItemText(0, Countries.GetName((Country) val));
                    break;

                case ScenarioEditorItemId.TradeCountry2:
                    _form.SetTradeListItemText(1, Countries.GetName((Country) val));
                    break;

                case ScenarioEditorItemId.TradeEnergy1:
                    PostItemChangedTradeDeals((TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeEnergy1),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeEnergy2), treaty);
                    break;

                case ScenarioEditorItemId.TradeEnergy2:
                    PostItemChangedTradeDeals((TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeEnergy2),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeEnergy1), treaty);
                    break;

                case ScenarioEditorItemId.TradeMetal1:
                    PostItemChangedTradeDeals((TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeMetal1),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeMetal2), treaty);
                    break;

                case ScenarioEditorItemId.TradeMetal2:
                    PostItemChangedTradeDeals((TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeMetal2),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeMetal1), treaty);
                    break;

                case ScenarioEditorItemId.TradeRareMaterials1:
                    PostItemChangedTradeDeals((TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeRareMaterials1),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeRareMaterials2), treaty);
                    break;

                case ScenarioEditorItemId.TradeRareMaterials2:
                    PostItemChangedTradeDeals((TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeRareMaterials2),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeRareMaterials1), treaty);
                    break;

                case ScenarioEditorItemId.TradeOil1:
                    PostItemChangedTradeDeals((TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeOil1),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeOil2), treaty);
                    break;

                case ScenarioEditorItemId.TradeOil2:
                    PostItemChangedTradeDeals((TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeOil2),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeOil1), treaty);
                    break;

                case ScenarioEditorItemId.TradeSupplies1:
                    PostItemChangedTradeDeals((TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeSupplies1),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeSupplies2), treaty);
                    break;

                case ScenarioEditorItemId.TradeSupplies2:
                    PostItemChangedTradeDeals((TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeSupplies2),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeSupplies1), treaty);
                    break;

                case ScenarioEditorItemId.TradeMoney1:
                    PostItemChangedTradeDeals((TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeMoney1),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeMoney2), treaty);
                    break;

                case ScenarioEditorItemId.TradeMoney2:
                    PostItemChangedTradeDeals((TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeMoney2),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeMoney1), treaty);
                    break;
            }
        }
Example #37
0
        /// <summary>
        ///     チェックボックスのチェック状態変更時の処理
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void OnRelationPeaceItemCheckBoxCheckedChanged(object sender, EventArgs e)
        {
            // 選択項目がなければ何もしない
            Country selected = GetSelectedRelationCountry();
            if (selected == Country.None)
            {
                return;
            }
            Country target = GetTargetRelationCountry();
            if (target == Country.None)
            {
                return;
            }

            CheckBox control = sender as CheckBox;
            if (control == null)
            {
                return;
            }
            ScenarioEditorItemId itemId = (ScenarioEditorItemId) control.Tag;

            Treaty treaty = Scenarios.GetPeace(selected, target);

            // 初期値から変更されていなければ何もしない
            bool val = control.Checked;
            object prev = _controller.GetItemValue(itemId, treaty);
            if ((prev == null) && !val)
            {
                return;
            }

            // 値に変化がなければ何もしない
            if ((prev != null) && (val == (bool) prev))
            {
                return;
            }

            // 項目値変更前の処理
            _controller.PreItemChanged(itemId, val, treaty);

            // 値を更新する
            if (val)
            {
                treaty = new Treaty
                {
                    Type = TreatyType.Peace,
                    Country1 = selected,
                    Country2 = target,
                    StartDate = new GameDate(),
                    EndDate = new GameDate(),
                    Id = Scenarios.GetNewTypeId(Scenarios.DefaultTreatyType, 1)
                };
                Scenarios.Data.GlobalData.Peaces.Add(treaty);
                Scenarios.SetPeace(treaty);
            }
            else
            {
                Scenarios.Data.GlobalData.Peaces.Remove(treaty);
                Scenarios.RemovePeace(treaty);
            }

            _controller.OutputItemValueChangedLog(itemId, val, !val, treaty);

            // 編集済みフラグを設定する
            _controller.SetItemDirty(itemId, treaty);

            // 文字色を変更する
            control.ForeColor = Color.Red;

            // 項目値変更後の処理
            _controller.PostItemChanged(itemId, val, val ? treaty : null);
        }
        /// <summary>
        ///     項目値変更前の処理
        /// </summary>
        /// <param name="itemId">項目ID</param>
        /// <param name="val">編集項目の値</param>
        /// <param name="treaty">協定</param>
        public void PreItemChanged(ScenarioEditorItemId itemId, object val, Treaty treaty)
        {
            switch (itemId)
            {
                case ScenarioEditorItemId.DiplomacyNonAggressionStartYear:
                    PreItemChangedTreatyStartDate(
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyNonAggressionStartMonth),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyNonAggressionStartDay), treaty);
                    break;

                case ScenarioEditorItemId.DiplomacyNonAggressionStartMonth:
                    PreItemChangedTreatyStartDate(
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyNonAggressionStartYear),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyNonAggressionStartDay), treaty);
                    break;

                case ScenarioEditorItemId.DiplomacyNonAggressionStartDay:
                    PreItemChangedTreatyStartDate(
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyNonAggressionStartYear),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyNonAggressionStartMonth), treaty);
                    break;

                case ScenarioEditorItemId.DiplomacyNonAggressionEndYear:
                    PreItemChangedTreatyEndDate(
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyNonAggressionEndMonth),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyNonAggressionEndDay), treaty);
                    break;

                case ScenarioEditorItemId.DiplomacyNonAggressionEndMonth:
                    PreItemChangedTreatyEndDate(
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyNonAggressionEndYear),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyNonAggressionEndDay), treaty);
                    break;

                case ScenarioEditorItemId.DiplomacyNonAggressionEndDay:
                    PreItemChangedTreatyEndDate(
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyNonAggressionEndYear),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyNonAggressionEndMonth), treaty);
                    break;

                case ScenarioEditorItemId.DiplomacyNonAggressionType:
                    if (treaty.Id == null)
                    {
                        treaty.Id = new TypeId();
                        PreItemChangedTreatyType(
                            (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyNonAggressionId), val, treaty);
                    }
                    break;

                case ScenarioEditorItemId.DiplomacyNonAggressionId:
                    if (treaty.Id == null)
                    {
                        treaty.Id = new TypeId();
                        PreItemChangedTreatyId(
                            (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyNonAggressionType), val, treaty);
                    }
                    break;

                case ScenarioEditorItemId.DiplomacyPeaceStartYear:
                    PreItemChangedTreatyStartDate(
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyPeaceStartMonth),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyPeaceStartDay), treaty);
                    break;

                case ScenarioEditorItemId.DiplomacyPeaceStartMonth:
                    PreItemChangedTreatyStartDate(
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyPeaceStartYear),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyPeaceStartDay), treaty);
                    break;

                case ScenarioEditorItemId.DiplomacyPeaceStartDay:
                    PreItemChangedTreatyStartDate(
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyPeaceStartYear),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyPeaceStartMonth), treaty);
                    break;

                case ScenarioEditorItemId.DiplomacyPeaceEndYear:
                    PreItemChangedTreatyEndDate(
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyPeaceEndMonth),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyPeaceEndDay), treaty);
                    break;

                case ScenarioEditorItemId.DiplomacyPeaceEndMonth:
                    PreItemChangedTreatyEndDate(
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyPeaceEndYear),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyPeaceEndDay), treaty);
                    break;

                case ScenarioEditorItemId.DiplomacyPeaceEndDay:
                    PreItemChangedTreatyEndDate(
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyPeaceEndYear),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyPeaceEndMonth), treaty);
                    break;

                case ScenarioEditorItemId.DiplomacyPeaceType:
                    if (treaty.Id == null)
                    {
                        treaty.Id = new TypeId();
                        PreItemChangedTreatyType((TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyPeaceId),
                            val, treaty);
                    }
                    break;

                case ScenarioEditorItemId.DiplomacyPeaceId:
                    if (treaty.Id == null)
                    {
                        treaty.Id = new TypeId();
                        PreItemChangedTreatyId((TextBox) _form.GetItemControl(ScenarioEditorItemId.DiplomacyPeaceType),
                            val, treaty);
                    }
                    break;

                case ScenarioEditorItemId.TradeStartYear:
                    PreItemChangedTreatyStartDate((TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeStartMonth),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeStartDay), treaty);
                    break;

                case ScenarioEditorItemId.TradeStartMonth:
                    PreItemChangedTreatyStartDate((TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeStartYear),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeStartDay), treaty);
                    break;

                case ScenarioEditorItemId.TradeStartDay:
                    PreItemChangedTreatyStartDate((TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeStartYear),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeStartMonth), treaty);
                    break;

                case ScenarioEditorItemId.TradeEndYear:
                    PreItemChangedTreatyEndDate((TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeEndMonth),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeEndDay), treaty);
                    break;

                case ScenarioEditorItemId.TradeEndMonth:
                    PreItemChangedTreatyEndDate((TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeEndYear),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeEndDay), treaty);
                    break;

                case ScenarioEditorItemId.TradeEndDay:
                    PreItemChangedTreatyEndDate((TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeEndYear),
                        (TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeEndMonth), treaty);
                    break;

                case ScenarioEditorItemId.TradeType:
                    if (treaty.Id == null)
                    {
                        treaty.Id = new TypeId();
                        PreItemChangedTreatyType((TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeId), val,
                            treaty);
                    }
                    break;

                case ScenarioEditorItemId.TradeId:
                    if (treaty.Id == null)
                    {
                        treaty.Id = new TypeId();
                        PreItemChangedTreatyId((TextBox) _form.GetItemControl(ScenarioEditorItemId.TradeType), val,
                            treaty);
                    }
                    break;
            }
        }
Example #39
0
        /// <summary>
        ///     不可侵条約の編集項目を更新する
        /// </summary>
        /// <param name="treaty">協定</param>
        private void UpdateNonAggressionItems(Treaty treaty)
        {
            _controller.UpdateItemValue(nonAggressionCheckBox, treaty);
            _controller.UpdateItemValue(nonAggressionStartYearTextBox, treaty);
            _controller.UpdateItemValue(nonAggressionStartMonthTextBox, treaty);
            _controller.UpdateItemValue(nonAggressionStartDayTextBox, treaty);
            _controller.UpdateItemValue(nonAggressionEndYearTextBox, treaty);
            _controller.UpdateItemValue(nonAggressionEndMonthTextBox, treaty);
            _controller.UpdateItemValue(nonAggressionEndDayTextBox, treaty);
            _controller.UpdateItemValue(nonAggressionTypeTextBox, treaty);
            _controller.UpdateItemValue(nonAggressionIdTextBox, treaty);

            _controller.UpdateItemColor(nonAggressionCheckBox, treaty);
            _controller.UpdateItemColor(nonAggressionStartYearTextBox, treaty);
            _controller.UpdateItemColor(nonAggressionStartMonthTextBox, treaty);
            _controller.UpdateItemColor(nonAggressionStartDayTextBox, treaty);
            _controller.UpdateItemColor(nonAggressionEndYearTextBox, treaty);
            _controller.UpdateItemColor(nonAggressionEndMonthTextBox, treaty);
            _controller.UpdateItemColor(nonAggressionEndDayTextBox, treaty);
            _controller.UpdateItemColor(nonAggressionTypeTextBox, treaty);
            _controller.UpdateItemColor(nonAggressionIdTextBox, treaty);

            bool flag = (bool) _controller.GetItemValue(ScenarioEditorItemId.DiplomacyNonAggression, treaty);
            nonAggressionStartLabel.Enabled = flag;
            nonAggressionStartYearTextBox.Enabled = flag;
            nonAggressionStartMonthTextBox.Enabled = flag;
            nonAggressionStartDayTextBox.Enabled = flag;
            nonAggressionEndLabel.Enabled = flag;
            nonAggressionEndYearTextBox.Enabled = flag;
            nonAggressionEndMonthTextBox.Enabled = flag;
            nonAggressionEndDayTextBox.Enabled = flag;
            nonAggressionIdLabel.Enabled = flag;
            nonAggressionTypeTextBox.Enabled = flag;
            nonAggressionIdTextBox.Enabled = flag;
        }
        /// <summary>
        ///     編集項目の編集済みフラグを設定する
        /// </summary>
        /// <param name="itemId">項目ID</param>
        /// <param name="treaty">協定</param>
        public void SetItemDirty(ScenarioEditorItemId itemId, Treaty treaty)
        {
            switch (itemId)
            {
                case ScenarioEditorItemId.DiplomacyNonAggression:
                case ScenarioEditorItemId.DiplomacyPeace:
                    if (treaty != null)
                    {
                        treaty.SetDirty(Treaty.ItemId.StartYear);
                        treaty.SetDirty(Treaty.ItemId.StartMonth);
                        treaty.SetDirty(Treaty.ItemId.StartDay);
                        treaty.SetDirty(Treaty.ItemId.EndYear);
                        treaty.SetDirty(Treaty.ItemId.EndMonth);
                        treaty.SetDirty(Treaty.ItemId.EndDay);
                        treaty.SetDirty(Treaty.ItemId.Type);
                        treaty.SetDirty(Treaty.ItemId.Id);
                        treaty.SetDirty();
                    }
                    break;

                default:
                    treaty.SetDirty((Treaty.ItemId) ItemDirtyFlags[(int) itemId]);
                    break;
            }
            Scenarios.Data.SetDirty();
            Scenarios.SetDirty();
        }
Example #41
0
        public static void Initialize(EstateAgencyContext context)
        {
            context.Database.EnsureCreated();

            if (context.Clients.Any())
            {
                return;
            }

            var clients = new Client[]
            {
                new Firm {
                    CompanyName = "OwnerCompany1", UNP = 111111111, Adress = "Adress1", Phone = "+3752911111111", ClientStatus = ClientStatus.Owner
                },
                new Firm {
                    CompanyName = "OwnerCompany2", UNP = 111111112, Adress = "Adress2", Phone = "+3752911111112", ClientStatus = ClientStatus.Owner
                },
                new Firm {
                    CompanyName = "OwnerCompany3", UNP = 111111113, Adress = "Adress3", Phone = "+3752911111113", ClientStatus = ClientStatus.Owner
                },
                new Firm {
                    CompanyName = "OwnerCompany4", UNP = 111111114, Adress = "Adress4", Phone = "+3752911111114", ClientStatus = ClientStatus.Owner
                },
                new Firm {
                    CompanyName = "OwnerCompany5", UNP = 111111115, Adress = "Adress5", Phone = "+3752911111115", ClientStatus = ClientStatus.Owner
                },
                new Firm {
                    CompanyName = "OwnerCompany6", UNP = 111111116, Adress = "Adress6", Phone = "+3752911111116", ClientStatus = ClientStatus.Owner
                },
                new Firm {
                    CompanyName = "OwnerCompany7", UNP = 111111117, Adress = "Adress7", Phone = "+3752911111117", ClientStatus = ClientStatus.Owner
                },
                new Firm {
                    CompanyName = "OwnerCompany8", UNP = 111111118, Adress = "Adress8", Phone = "+3752911111118", ClientStatus = ClientStatus.Owner
                },
                new Firm {
                    CompanyName = "OwnerCompany9", UNP = 111111119, Adress = "Adress9", Phone = "+3752911111119", ClientStatus = ClientStatus.Owner
                },
                new Firm {
                    CompanyName = "OwnerCompany10", UNP = 111111120, Adress = "Adress10", Phone = "+3752911111120", ClientStatus = ClientStatus.Owner
                },
                new Firm {
                    CompanyName = "RentCompany11", UNP = 111111121, Adress = "Adress11", Phone = "+3752911111121", ClientStatus = ClientStatus.Tenant
                },
                new Firm {
                    CompanyName = "RentCompany12", UNP = 111111122, Adress = "Adress12", Phone = "+3752911111122", ClientStatus = ClientStatus.Tenant
                },
                new Firm {
                    CompanyName = "RentCompany13", UNP = 111111123, Adress = "Adress13", Phone = "+3752911111123", ClientStatus = ClientStatus.Tenant
                },
                new Firm {
                    CompanyName = "RentCompany14", UNP = 111111124, Adress = "Adress14", Phone = "+3752911111124", ClientStatus = ClientStatus.Tenant
                },
                new Firm {
                    CompanyName = "RentCompany15", UNP = 111111125, Adress = "Adress15", Phone = "+3752911111125", ClientStatus = ClientStatus.Tenant
                },
                new Firm {
                    CompanyName = "RentCompany16", UNP = 111111126, Adress = "Adress16", Phone = "+3752911111126", ClientStatus = ClientStatus.Tenant
                },
                new Firm {
                    CompanyName = "RentCompany17", UNP = 111111127, Adress = "Adress17", Phone = "+3752911111127", ClientStatus = ClientStatus.Tenant
                },
                new Firm {
                    CompanyName = "RentCompany18", UNP = 111111128, Adress = "Adress18", Phone = "+3752911111128", ClientStatus = ClientStatus.Tenant
                },
                new Firm {
                    CompanyName = "RentCompany19", UNP = 111111129, Adress = "Adress19", Phone = "+3752911111129", ClientStatus = ClientStatus.Tenant
                },
                new Firm {
                    CompanyName = "RentCompany20", UNP = 111111130, Adress = "Adress20", Phone = "+3752911111130", ClientStatus = ClientStatus.Tenant
                },
                new Firm {
                    CompanyName = "BuyerCompany21", UNP = 111111131, Adress = "Adress21", Phone = "+3752911111131", ClientStatus = ClientStatus.Buyer
                },
                new Firm {
                    CompanyName = "BuyerCompany22", UNP = 111111132, Adress = "Adress22", Phone = "+3752911111132", ClientStatus = ClientStatus.Buyer
                },
                new Firm {
                    CompanyName = "BuyerCompany23", UNP = 111111133, Adress = "Adress23", Phone = "+3752911111133", ClientStatus = ClientStatus.Buyer
                },
                new Firm {
                    CompanyName = "BuyerCompany24", UNP = 111111134, Adress = "Adress24", Phone = "+3752911111134", ClientStatus = ClientStatus.Buyer
                },
                new Firm {
                    CompanyName = "BuyerCompany25", UNP = 111111135, Adress = "Adress25", Phone = "+3752911111135", ClientStatus = ClientStatus.Buyer
                },
                new Firm {
                    CompanyName = "BuyerCompany26", UNP = 111111136, Adress = "Adress26", Phone = "+3752911111136", ClientStatus = ClientStatus.Buyer
                },
                new Firm {
                    CompanyName = "BuyerCompany27", UNP = 111111137, Adress = "Adress27", Phone = "+3752911111137", ClientStatus = ClientStatus.Buyer
                },
                new Firm {
                    CompanyName = "BuyerCompany28", UNP = 111111138, Adress = "Adress28", Phone = "+3752911111138", ClientStatus = ClientStatus.Buyer
                },
                new Firm {
                    CompanyName = "BuyerCompany29", UNP = 111111139, Adress = "Adress29", Phone = "+3752911111139", ClientStatus = ClientStatus.Buyer
                },
                new Person {
                    FirstName = "NameOwnerPerson1", Surname = "SurnameOwnerPerson1", Adress = "Adress30", Phone = "+3752911111140", ClientStatus = ClientStatus.Owner
                },
                new Person {
                    FirstName = "NameOwnerPerson2", Surname = "SurnameOwnerPerson2", Adress = "Adress31", Phone = "+3752911111141", ClientStatus = ClientStatus.Owner
                },
                new Person {
                    FirstName = "NameOwnerPerson3", Surname = "SurnameOwnerPerson3", Adress = "Adress32", Phone = "+3752911111142", ClientStatus = ClientStatus.Owner
                },
                new Person {
                    FirstName = "NameOwnerPerson4", Surname = "SurnameOwnerPerson4", Adress = "Adress33", Phone = "+3752911111143", ClientStatus = ClientStatus.Owner
                },
                new Person {
                    FirstName = "NameOwnerPerson5", Surname = "SurnameOwnerPerson5", Adress = "Adress34", Phone = "+3752911111144", ClientStatus = ClientStatus.Owner
                },
                new Person {
                    FirstName = "NameBuyerPerson1", Surname = "SurnameBuyerPerson1", Adress = "Adress35", Phone = "+3752911111145", ClientStatus = ClientStatus.Buyer
                },
                new Person {
                    FirstName = "NameBuyerPerson2", Surname = "SurnameBuyerPerson2", Adress = "Adress36", Phone = "+3752911111146", ClientStatus = ClientStatus.Buyer
                },
                new Person {
                    FirstName = "NameBuyerPerson3", Surname = "SurnameBuyerPerson3", Adress = "Adress37", Phone = "+3752911111147", ClientStatus = ClientStatus.Buyer
                },
                new Person {
                    FirstName = "NameBuyerPerson4", Surname = "SurnameBuyerPerson4", Adress = "Adress38", Phone = "+3752911111148", ClientStatus = ClientStatus.Buyer
                },
                new Person {
                    FirstName = "NameBuyerPerson5", Surname = "SurnameBuyerPerson5", Adress = "Adress39", Phone = "+3752911111149", ClientStatus = ClientStatus.Buyer
                }
            };

            foreach (Client c in clients)
            {
                context.Clients.Add(c);
            }
            context.SaveChanges();

            var estates = new Estate[]
            {
                new SaleEstate {
                    Name             = "изолированное помещение1", Type = "склад", InventoryNumber = "600/D-111111", Year = 1950, Wall = "бетон", Area = 500, Adress = "Adress39",
                    ShortDescription = "ShortDescription1", LongDescription = "LongDescription1", ImageURL = "1", ImageThumbURL = "1", SalePrice = 100000, ClientID = 1, SaleStatus = false
                },
                new SaleEstate {
                    Name             = "изолированное помещение2", Type = "склад", InventoryNumber = "600/D-111112", Year = 1953, Wall = "бетон", Area = 900, Adress = "Adress40",
                    ShortDescription = "ShortDescription1", LongDescription = "LongDescription1", ImageURL = "1", ImageThumbURL = "1", SalePrice = 105000, ClientID = 1, SaleStatus = false
                },
                new SaleEstate {
                    Name             = "изолированное помещение3", Type = "склад", InventoryNumber = "600/D-111113", Year = 1955, Wall = "бетон", Area = 100, Adress = "Adress41",
                    ShortDescription = "ShortDescription1", LongDescription = "LongDescription1", ImageURL = "1", ImageThumbURL = "1", SalePrice = 200000, ClientID = 1, SaleStatus = false
                },
                new SaleEstate {
                    Name             = "изолированное помещение4", Type = "склад", InventoryNumber = "600/D-111114", Year = 1957, Wall = "бетон", Area = 50, Adress = "Adress42",
                    ShortDescription = "ShortDescription1", LongDescription = "LongDescription1", ImageURL = "1", ImageThumbURL = "1", SalePrice = 205000, ClientID = 1, SaleStatus = false
                },
                new SaleEstate {
                    Name             = "изолированное помещение5", Type = "склад", InventoryNumber = "600/D-111115", Year = 1959, Wall = "бетон", Area = 400, Adress = "Adress43",
                    ShortDescription = "ShortDescription1", LongDescription = "LongDescription1", ImageURL = "1", ImageThumbURL = "1", SalePrice = 300000, ClientID = 11, SaleStatus = false
                },
                new SaleEstate {
                    Name             = "изолированное помещение6", Type = "офис", InventoryNumber = "600/D-111116", Year = 1961, Wall = "бетон", Area = 900, Adress = "Adress44",
                    ShortDescription = "ShortDescription1", LongDescription = "LongDescription1", ImageURL = "1", ImageThumbURL = "1", SalePrice = 305000, ClientID = 11, SaleStatus = false
                },
                new SaleEstate {
                    Name             = "изолированное помещение7", Type = "офис", InventoryNumber = "600/D-111117", Year = 1963, Wall = "бетон", Area = 150, Adress = "Adress45",
                    ShortDescription = "ShortDescription1", LongDescription = "LongDescription1", ImageURL = "1", ImageThumbURL = "1", SalePrice = 400000, ClientID = 12, SaleStatus = false
                },
                new SaleEstate {
                    Name             = "изолированное помещение8", Type = "офис", InventoryNumber = "600/D-111118", Year = 1965, Wall = "бетон", Area = 1000, Adress = "Adress46",
                    ShortDescription = "ShortDescription1", LongDescription = "LongDescription1", ImageURL = "1", ImageThumbURL = "1", SalePrice = 405000, ClientID = 13, SaleStatus = false
                },
                new SaleEstate {
                    Name             = "изолированное помещение9", Type = "офис", InventoryNumber = "600/D-111119", Year = 1967, Wall = "бетон", Area = 50, Adress = "Adress47",
                    ShortDescription = "ShortDescription1", LongDescription = "LongDescription1", ImageURL = "1", ImageThumbURL = "1", SalePrice = 500000, ClientID = 14, SaleStatus = false
                },
                new RentEstate {
                    Name             = "изолированное помещение10", Type = "офис", InventoryNumber = "600/D-111120", Year = 1969, Wall = "бетон", Area = 700, Adress = "Adress48",
                    ShortDescription = "ShortDescription1", LongDescription = "LongDescription1", ImageURL = "1", ImageThumbURL = "1", PerSquareMeterRentPrice = 6, ClientID = 18, SaleStatus = false
                },
                new SaleEstate {
                    Name             = "изолированное помещение11", Type = "офис", InventoryNumber = "600/D-111121", Year = 1970, Wall = "бетон", Area = 100, Adress = "Adress49",
                    ShortDescription = "ShortDescription1", LongDescription = "LongDescription1", ImageURL = "1", ImageThumbURL = "1", SalePrice = 600000, ClientID = 22, SaleStatus = false
                },
                new RentEstate {
                    Name             = "изолированное помещение12", Type = "офис", InventoryNumber = "600/D-111122", Year = 1972, Wall = "бетон", Area = 200, Adress = "Adress50",
                    ShortDescription = "ShortDescription1", LongDescription = "LongDescription1", ImageURL = "1", ImageThumbURL = "1", PerSquareMeterRentPrice = 7, ClientID = 23, SaleStatus = false
                },
                new SaleEstate {
                    Name             = "изолированное помещение13", Type = "офис", InventoryNumber = "600/D-111123", Year = 1974, Wall = "бетон", Area = 350, Adress = "Adress51",
                    ShortDescription = "ShortDescription1", LongDescription = "LongDescription1", ImageURL = "1", ImageThumbURL = "1", SalePrice = 700000, ClientID = 24, SaleStatus = false
                },
                new RentEstate {
                    Name             = "изолированное помещение14", Type = "офис", InventoryNumber = "600/D-111124", Year = 1986, Wall = "бетон", Area = 500, Adress = "Adress52",
                    ShortDescription = "ShortDescription1", LongDescription = "LongDescription1", ImageURL = "1", ImageThumbURL = "1", PerSquareMeterRentPrice = 10, ClientID = 25, SaleStatus = false
                },
                new SaleEstate {
                    Name             = "изолированное помещение15", Type = "офис", InventoryNumber = "600/D-111125", Year = 1988, Wall = "бетон", Area = 650, Adress = "Adress53",
                    ShortDescription = "ShortDescription1", LongDescription = "LongDescription1", ImageURL = "1", ImageThumbURL = "1", SalePrice = 800000, ClientID = 26, SaleStatus = false
                },
                new RentEstate {
                    Name             = "капитальное строение1", Type = "магазин", InventoryNumber = "600/C-111126", Year = 1991, Wall = "бетон", Area = 400, Adress = "Adress54",
                    ShortDescription = "ShortDescription1", LongDescription = "LongDescription1", ImageURL = "1", ImageThumbURL = "1", PerSquareMeterRentPrice = 8, ClientID = 27, SaleStatus = false
                },
                new SaleEstate {
                    Name             = "капитальное строение2", Type = "магазин", InventoryNumber = "600/C-111127", Year = 1993, Wall = "бетон", Area = 1000, Adress = "Adress55",
                    ShortDescription = "ShortDescription1", LongDescription = "LongDescription1", ImageURL = "1", ImageThumbURL = "1", SalePrice = 900000, ClientID = 28, SaleStatus = false
                },
                new RentEstate {
                    Name             = "капитальное строение3", Type = "производство", InventoryNumber = "600/C-111128", Year = 1999, Wall = "бетон", Area = 1030, Adress = "Adress56",
                    ShortDescription = "ShortDescription1", LongDescription = "LongDescription1", ImageURL = "1", ImageThumbURL = "1", PerSquareMeterRentPrice = 5, ClientID = 38, SaleStatus = false
                },
                new SaleEstate {
                    Name             = "капитальное строение4", Type = "производство", InventoryNumber = "600/C-111129", Year = 2001, Wall = "бетон", Area = 800, Adress = "Adress57",
                    ShortDescription = "ShortDescription1", LongDescription = "LongDescription1", ImageURL = "1", ImageThumbURL = "1", SalePrice = 1000000, ClientID = 38, SaleStatus = false
                },
                new RentEstate {
                    Name             = "капитальное строение5", Type = "офис", InventoryNumber = "600/C-111130", Year = 2010, Wall = "бетон", Area = 5000, Adress = "Adress58",
                    ShortDescription = "ShortDescription1", LongDescription = "LongDescription1", ImageURL = "1", ImageThumbURL = "1", PerSquareMeterRentPrice = 14, ClientID = 24, SaleStatus = false
                }
            };

            foreach (Estate e in estates)
            {
                context.Estates.Add(e);
            }
            context.SaveChanges();

            var treaties = new Treaty[]
            {
                new Lease {
                    Number = 1, Area = 400, SignDate = DateTime.Parse("2016-09-01"), EndDate = DateTime.Parse("2019-09-01"), TotalRentPrice = 6
                },
                new Lease {
                    Number = 2, Area = 300, SignDate = DateTime.Parse("2015-06-08"), EndDate = DateTime.Parse("2020-06-08"), TotalRentPrice = 6
                },
                new Lease {
                    Number = 3, Area = 200, SignDate = DateTime.Parse("2018-01-01"), EndDate = DateTime.Parse("2021-01-01"), TotalRentPrice = 7
                },
                new Lease {
                    Number = 4, Area = 500, SignDate = DateTime.Parse("2017-03-01"), EndDate = DateTime.Parse("2018-12-01"), TotalRentPrice = 10
                },
                new Lease {
                    Number = 5, Area = 400, SignDate = DateTime.Parse("2016-02-01"), EndDate = DateTime.Parse("2019-02-01"), TotalRentPrice = 8
                },
                new Lease {
                    Number = 6, Area = 1030, SignDate = DateTime.Parse("2017-06-01"), EndDate = DateTime.Parse("2020-06-01"), TotalRentPrice = 5
                },
                new Lease {
                    Number = 7, Area = 1000, SignDate = DateTime.Parse("2017-10-01"), EndDate = DateTime.Parse("2019-01-01"), TotalRentPrice = 13
                },
                new Lease {
                    Number = 8, Area = 700, SignDate = DateTime.Parse("2018-01-01"), EndDate = DateTime.Parse("2021-01-01"), TotalRentPrice = 14
                },
                new Lease {
                    Number = 9, Area = 900, SignDate = DateTime.Parse("2016-11-01"), EndDate = DateTime.Parse("2019-11-01"), TotalRentPrice = 13
                },

                new SaleTreaty {
                    Number = 10, SignDate = DateTime.Parse("2016-09-01"), TotalSalePrice = 100000
                },
                new SaleTreaty {
                    Number = 11, SignDate = DateTime.Parse("2015-07-12"), TotalSalePrice = 100000
                },
                new SaleTreaty {
                    Number = 12, SignDate = DateTime.Parse("2016-06-21"), TotalSalePrice = 100000
                },
                new SaleTreaty {
                    Number = 13, SignDate = DateTime.Parse("2017-05-31"), TotalSalePrice = 100000
                },
                new SaleTreaty {
                    Number = 14, SignDate = DateTime.Parse("2017-11-22"), TotalSalePrice = 100000
                },
                new SaleTreaty {
                    Number = 15, SignDate = DateTime.Parse("2017-01-10"), TotalSalePrice = 100000
                }
            };

            foreach (Treaty t in treaties)
            {
                context.Treaties.Add(t);
            }
            context.SaveChanges();

            var rentEstate_leases = new RentEstate_Lease[]
            {
                new RentEstate_Lease {
                    EstateID = estates.Single(e => e.InventoryNumber == "600/D-111120").ID,
                    LeaseID  = treaties.Single(l => l.Number == 1).ID
                },
                new RentEstate_Lease {
                    EstateID = estates.Single(e => e.InventoryNumber == "600/D-111120").ID,
                    LeaseID  = treaties.Single(l => l.Number == 2).ID
                },
                new RentEstate_Lease {
                    EstateID = estates.Single(e => e.InventoryNumber == "600/D-111122").ID,
                    LeaseID  = treaties.Single(l => l.Number == 3).ID
                },
                new RentEstate_Lease {
                    EstateID = estates.Single(e => e.InventoryNumber == "600/D-111124").ID,
                    LeaseID  = treaties.Single(l => l.Number == 4).ID
                },
                new RentEstate_Lease {
                    EstateID = estates.Single(e => e.InventoryNumber == "600/C-111126").ID,
                    LeaseID  = treaties.Single(l => l.Number == 5).ID
                },
                new RentEstate_Lease {
                    EstateID = estates.Single(e => e.InventoryNumber == "600/C-111128").ID,
                    LeaseID  = treaties.Single(l => l.Number == 6).ID
                },
                new RentEstate_Lease {
                    EstateID = estates.Single(e => e.InventoryNumber == "600/C-111130").ID,
                    LeaseID  = treaties.Single(l => l.Number == 7).ID
                },
                new RentEstate_Lease {
                    EstateID = estates.Single(e => e.InventoryNumber == "600/C-111130").ID,
                    LeaseID  = treaties.Single(l => l.Number == 8).ID
                },
                new RentEstate_Lease {
                    EstateID = estates.Single(e => e.InventoryNumber == "600/C-111130").ID,
                    LeaseID  = treaties.Single(l => l.Number == 9).ID
                }
            };

            foreach (RentEstate_Lease rel in rentEstate_leases)
            {
                context.RentEstate_Leases.Add(rel);
            }
            context.SaveChanges();

            var clientTreaties = new Client_Treaty[]
            {
                new Client_Treaty {
                    ClientID = clients.Single(c => c.ID == 20).ID,
                    TreatyID = treaties.Single(l => l.Number == 1).ID
                },
                new Client_Treaty {
                    ClientID = clients.Single(c => c.ID == 21).ID,
                    TreatyID = treaties.Single(l => l.Number == 2).ID
                },
                new Client_Treaty {
                    ClientID = clients.Single(c => c.ID == 37).ID,
                    TreatyID = treaties.Single(l => l.Number == 3).ID
                },
                new Client_Treaty {
                    ClientID = clients.Single(c => c.ID == 36).ID,
                    TreatyID = treaties.Single(l => l.Number == 4).ID
                },
                new Client_Treaty {
                    ClientID = clients.Single(c => c.ID == 29).ID,
                    TreatyID = treaties.Single(l => l.Number == 5).ID
                },
                new Client_Treaty {
                    ClientID = clients.Single(c => c.ID == 30).ID,
                    TreatyID = treaties.Single(l => l.Number == 6).ID
                },
                new Client_Treaty {
                    ClientID = clients.Single(c => c.ID == 32).ID,
                    TreatyID = treaties.Single(l => l.Number == 7).ID
                },
                new Client_Treaty {
                    ClientID = clients.Single(c => c.ID == 33).ID,
                    TreatyID = treaties.Single(l => l.Number == 8).ID
                },
                new Client_Treaty {
                    ClientID = clients.Single(c => c.ID == 34).ID,
                    TreatyID = treaties.Single(l => l.Number == 9).ID
                }
            };

            foreach (Client_Treaty ct in clientTreaties)
            {
                context.Client_Treaties.Add(ct);
            }
            context.SaveChanges();
        }
        /// <summary>
        ///     編集項目の値を設定する
        /// </summary>
        /// <param name="itemId">項目ID</param>
        /// <param name="val">編集項目の値</param>
        /// <param name="treaty">協定</param>
        public void SetItemValue(ScenarioEditorItemId itemId, object val, Treaty treaty)
        {
            switch (itemId)
            {
                case ScenarioEditorItemId.DiplomacyNonAggressionStartYear:
                case ScenarioEditorItemId.DiplomacyPeaceStartYear:
                case ScenarioEditorItemId.TradeStartYear:
                    treaty.StartDate.Year = (int) val;
                    break;

                case ScenarioEditorItemId.DiplomacyNonAggressionStartMonth:
                case ScenarioEditorItemId.DiplomacyPeaceStartMonth:
                case ScenarioEditorItemId.TradeStartMonth:
                    treaty.StartDate.Month = (int) val;
                    break;

                case ScenarioEditorItemId.DiplomacyNonAggressionStartDay:
                case ScenarioEditorItemId.DiplomacyPeaceStartDay:
                case ScenarioEditorItemId.TradeStartDay:
                    treaty.StartDate.Day = (int) val;
                    break;

                case ScenarioEditorItemId.DiplomacyNonAggressionEndYear:
                case ScenarioEditorItemId.DiplomacyPeaceEndYear:
                case ScenarioEditorItemId.TradeEndYear:
                    treaty.EndDate.Year = (int) val;
                    break;

                case ScenarioEditorItemId.DiplomacyNonAggressionEndMonth:
                case ScenarioEditorItemId.DiplomacyPeaceEndMonth:
                case ScenarioEditorItemId.TradeEndMonth:
                    treaty.EndDate.Month = (int) val;
                    break;

                case ScenarioEditorItemId.DiplomacyNonAggressionEndDay:
                case ScenarioEditorItemId.DiplomacyPeaceEndDay:
                case ScenarioEditorItemId.TradeEndDay:
                    treaty.EndDate.Day = (int) val;
                    break;

                case ScenarioEditorItemId.DiplomacyNonAggressionType:
                case ScenarioEditorItemId.DiplomacyPeaceType:
                case ScenarioEditorItemId.TradeType:
                    Scenarios.SetType(treaty.Id, (int) val);
                    break;

                case ScenarioEditorItemId.DiplomacyNonAggressionId:
                case ScenarioEditorItemId.DiplomacyPeaceId:
                case ScenarioEditorItemId.TradeId:
                    Scenarios.SetId(treaty.Id, (int) val);
                    break;

                case ScenarioEditorItemId.TradeCancel:
                    treaty.Cancel = (bool) val;
                    break;

                case ScenarioEditorItemId.TradeCountry1:
                    treaty.Country1 = (Country) val;
                    break;

                case ScenarioEditorItemId.TradeCountry2:
                    treaty.Country2 = (Country) val;
                    break;

                case ScenarioEditorItemId.TradeEnergy1:
                    treaty.Energy = -(double) val;
                    break;

                case ScenarioEditorItemId.TradeEnergy2:
                    treaty.Energy = (double) val;
                    break;

                case ScenarioEditorItemId.TradeMetal1:
                    treaty.Metal = -(double) val;
                    break;

                case ScenarioEditorItemId.TradeMetal2:
                    treaty.Metal = (double) val;
                    break;

                case ScenarioEditorItemId.TradeRareMaterials1:
                    treaty.RareMaterials = -(double) val;
                    break;

                case ScenarioEditorItemId.TradeRareMaterials2:
                    treaty.RareMaterials = (double) val;
                    break;

                case ScenarioEditorItemId.TradeOil1:
                    treaty.Oil = -(double) val;
                    break;

                case ScenarioEditorItemId.TradeOil2:
                    treaty.Oil = (double) val;
                    break;

                case ScenarioEditorItemId.TradeSupplies1:
                    treaty.Supplies = -(double) val;
                    break;

                case ScenarioEditorItemId.TradeSupplies2:
                    treaty.Supplies = (double) val;
                    break;

                case ScenarioEditorItemId.TradeMoney1:
                    treaty.Money = -(double) val;
                    break;

                case ScenarioEditorItemId.TradeMoney2:
                    treaty.Money = (double) val;
                    break;
            }
        }