/// <summary>
/// ユニットを追加する
/// </summary>
/// <param name="branch">兵科</param>
/// <param name="parent">親ノード</param>
/// <param name="units">ユニットリスト</param>
/// <param name="settings">国家設定</param>
private void AddUnit(Branch branch, TreeNode parent, List <Unit> units, CountrySettings settings)
{
// ユニットを作成する
Unit unit = new Unit {
Id = settings.GetNewUnitTypeId(), Branch = branch
};
unit.SetDirtyAll();
// ユニットの位置を初期化する
InitUnitLocation(unit, settings);
// ツリーノードを追加する
TreeNode node = CreateUnitNode(unit);
node.Text = Resources.UnitTreeNewUnit;
parent.Nodes.Add(node);
// ユニットリストに追加する
units.Add(unit);
// 編集済みフラグを設定する
settings.SetDirty();
Scenarios.SetDirty();
// 追加したノードを選択する
_treeView.SelectedNode = node;
}
/// <summary>
/// ユニットを削除する
/// </summary>
/// <param name="unit">削除対象のユニット</param>
private void RemoveUnit(Unit unit)
{
TreeNode node = _treeView.SelectedNode;
TreeNode parent = node.Parent;
parent.Nodes.Remove(node);
CountrySettings settings = Scenarios.GetCountrySettings(_country) ??
Scenarios.CreateCountrySettings(_country);
// 編集済みフラグを設定する
settings.SetDirty();
Scenarios.SetDirty();
// 陸軍/海軍/空軍/搭載ユニット
switch ((NodeType)parent.Tag)
{
case NodeType.Land:
settings.LandUnits.Remove(unit);
break;
case NodeType.Naval:
settings.NavalUnits.Remove(unit);
break;
case NodeType.Air:
settings.AirUnits.Remove(unit);
break;
case NodeType.Boarding:
Unit transport = (Unit)parent.Parent.Tag;
transport.LandUnits.Remove(unit);
break;
}
}
/// <summary>
/// ユニットを追加する
/// </summary>
public void AddUnit()
{
CountrySettings settings = Scenarios.GetCountrySettings(_country) ??
Scenarios.CreateCountrySettings(_country);
TreeNode node = _treeView.SelectedNode;
TreeNode parent = node.Parent;
// 陸軍/海軍/空軍ユニットのルートノード
if (parent == null)
{
switch ((NodeType)node.Tag)
{
case NodeType.Land:
AddUnit(Branch.Army, node, settings.LandUnits, settings);
break;
case NodeType.Naval:
AddUnit(Branch.Navy, node, settings.NavalUnits, settings);
break;
case NodeType.Air:
AddUnit(Branch.Airforce, node, settings.AirUnits, settings);
break;
}
return;
}
// 搭載ユニットのルートノード
Unit transport = parent.Tag as Unit;
if (transport != null)
{
AddUnit(Branch.Army, node, transport.LandUnits, settings);
return;
}
// 陸軍/海軍/空軍/搭載ユニット
int index = parent.Nodes.IndexOf(node) + 1;
switch ((NodeType)parent.Tag)
{
case NodeType.Land:
AddUnit(index, Branch.Army, parent, settings.LandUnits, settings);
break;
case NodeType.Naval:
AddUnit(index, Branch.Navy, parent, settings.NavalUnits, settings);
break;
case NodeType.Air:
AddUnit(index, Branch.Airforce, parent, settings.AirUnits, settings);
break;
case NodeType.Boarding:
transport = (Unit)parent.Parent.Tag;
AddUnit(index, Branch.Army, parent, transport.LandUnits, settings);
break;
}
}
/// <summary>
/// ユニットの位置を初期化する
/// </summary>
/// <param name="unit">ユニット</param>
/// <param name="settings">国家設定</param>
private static void InitUnitLocation(Unit unit, CountrySettings settings)
{
ProvinceSettings capitalSettings;
switch (unit.Branch)
{
case Branch.Army:
unit.Location = settings.Capital;
break;
case Branch.Navy:
capitalSettings = Scenarios.GetProvinceSettings(settings.Capital);
if (capitalSettings?.NavalBase != null)
{
unit.Location = settings.Capital;
unit.Base = settings.Capital;
}
else
{
foreach (ProvinceSettings ps in settings.ControlledProvinces
.Select(Scenarios.GetProvinceSettings)
.Where(ps => ps?.NavalBase != null))
{
unit.Location = ps.Id;
unit.Base = ps.Id;
break;
}
}
break;
case Branch.Airforce:
capitalSettings = Scenarios.GetProvinceSettings(settings.Capital);
if (capitalSettings?.AirBase != null)
{
unit.Location = settings.Capital;
unit.Base = settings.Capital;
}
else
{
foreach (ProvinceSettings ps in settings.ControlledProvinces
.Select(Scenarios.GetProvinceSettings)
.Where(ps => ps?.AirBase != null))
{
unit.Location = ps.Id;
unit.Base = ps.Id;
break;
}
}
break;
}
}
/// <summary>
/// 師団を移動する
/// </summary>
/// <param name="division">移動対象の師団</param>
/// <param name="index">移動先のインデックス</param>
private void MoveDivision(Division division, int index)
{
TreeNode node = _treeView.SelectedNode;
TreeNode parent = node.Parent;
parent.Nodes.Remove(node);
parent.Nodes.Insert(index, node);
CountrySettings settings = Scenarios.GetCountrySettings(_country) ??
Scenarios.CreateCountrySettings(_country);
// 編集済みフラグを設定する
settings.SetDirty();
Scenarios.SetDirty();
// 陸軍/海軍/空軍/搭載師団
Unit unit = parent.Tag as Unit;
if (unit != null)
{
unit.Divisions.Remove(division);
unit.Divisions.Insert(index, division);
// 移動対象のノードを選択する
_treeView.SelectedNode = node;
return;
}
// 未配備陸軍/海軍/空軍師団
switch ((NodeType)parent.Tag)
{
case NodeType.UndeployedLand:
settings.LandDivisions.Remove(division);
settings.LandDivisions.Insert(index, division);
break;
case NodeType.UndeployedNaval:
settings.NavalDivisions.Remove(division);
settings.NavalDivisions.Insert(index, division);
break;
case NodeType.UndeployedAir:
settings.AirDivisions.Remove(division);
settings.AirDivisions.Insert(index, division);
break;
}
// 移動対象のノードを選択する
_treeView.SelectedNode = node;
}
/// <summary>
/// 強調表示するプロヴィンスのリストを取得する
/// </summary>
/// <param name="mode">フィルターモード</param>
/// <param name="country">対象国</param>
/// <returns>強調表示するプロヴィンスのリスト</returns>
private static List <ushort> GetHighlightedProvinces(MapFilterMode mode, Country country)
{
if (mode == MapFilterMode.None)
{
return(new List <ushort>());
}
CountrySettings settings = Scenarios.GetCountrySettings(country);
if (settings == null)
{
return(new List <ushort>());
}
switch (mode)
{
case MapFilterMode.Core:
return(Provinces.Items.Where(province => settings.NationalProvinces.Contains(province.Id))
.Select(province => (ushort)province.Id)
.ToList());
case MapFilterMode.Owned:
return(Provinces.Items.Where(province => settings.OwnedProvinces.Contains(province.Id))
.Select(province => (ushort)province.Id)
.ToList());
case MapFilterMode.Controlled:
return(Provinces.Items.Where(province => settings.ControlledProvinces.Contains(province.Id))
.Select(province => (ushort)province.Id)
.ToList());
case MapFilterMode.Claimed:
return(Provinces.Items.Where(province => settings.ClaimedProvinces.Contains(province.Id))
.Select(province => (ushort)province.Id)
.ToList());
}
return(null);
}
/// <summary>
/// ユニットを追加する
/// </summary>
/// <param name="index">追加先のインデックス</param>
/// <param name="branch">兵科</param>
/// <param name="parent">親ノード</param>
/// <param name="divisions">師団リスト</param>
/// <param name="settings">国家設定</param>
private void AddDivision(int index, Branch branch, TreeNode parent, List <Division> divisions,
CountrySettings settings)
{
// 師団を作成する
Division division = new Division {
Id = settings.GetNewUnitTypeId(), Branch = branch
};
division.SetDirtyAll();
switch (branch)
{
case Branch.Army:
division.Type = UnitType.Infantry;
break;
case Branch.Navy:
division.Type = UnitType.BattleShip;
break;
case Branch.Airforce:
division.Type = UnitType.MultiRole;
break;
}
// ツリーノードを追加する
TreeNode node = CreateDivisionNode(division);
node.Text = Resources.UnitTreeNewDivision;
parent.Nodes.Insert(index, node);
// 師団リストに追加する
divisions.Insert(index, division);
// 追加したノードを選択する
_treeView.SelectedNode = node;
}
/// <summary>
/// 項目値変更後の処理 - 師団のユニット種類
/// </summary>
/// <param name="division">師団</param>
/// <param name="settings">国家設定</param>
private void PostItemChangedDivisionType(Division division, CountrySettings settings)
{
// ユニットモデル項目の候補を更新する
ComboBox control = (ComboBox) _form.GetItemControl(ScenarioEditorItemId.DivisionModel);
UpdateListItems(control, division, settings);
// ユニットモデル項目の値を更新する
UpdateItemValue(control, division);
// 付属旅団の項目の値を更新する
UpdateItemValue((ComboBox) _form.GetItemControl(ScenarioEditorItemId.DivisionBrigadeType1), division);
UpdateItemValue((ComboBox) _form.GetItemControl(ScenarioEditorItemId.DivisionBrigadeModel1), division);
UpdateItemValue((ComboBox) _form.GetItemControl(ScenarioEditorItemId.DivisionBrigadeType2), division);
UpdateItemValue((ComboBox) _form.GetItemControl(ScenarioEditorItemId.DivisionBrigadeModel2), division);
UpdateItemValue((ComboBox) _form.GetItemControl(ScenarioEditorItemId.DivisionBrigadeType3), division);
UpdateItemValue((ComboBox) _form.GetItemControl(ScenarioEditorItemId.DivisionBrigadeModel3), division);
UpdateItemValue((ComboBox) _form.GetItemControl(ScenarioEditorItemId.DivisionBrigadeType4), division);
UpdateItemValue((ComboBox) _form.GetItemControl(ScenarioEditorItemId.DivisionBrigadeModel4), division);
UpdateItemValue((ComboBox) _form.GetItemControl(ScenarioEditorItemId.DivisionBrigadeType5), division);
UpdateItemValue((ComboBox) _form.GetItemControl(ScenarioEditorItemId.DivisionBrigadeModel5), division);
}
/// <summary>
/// 編集項目の値を更新する
/// </summary>
/// <param name="control">コントロール</param>
/// <param name="country">選択国</param>
/// <param name="settings">国家設定</param>
public void UpdateItemValue(CheckBox control, Country country, CountrySettings settings)
{
ScenarioEditorItemId itemId = (ScenarioEditorItemId) control.Tag;
control.Checked = (Country) GetItemValue(itemId, settings) == country;
}
/// <summary>
/// 師団を追加する
/// </summary>
public void AddDivision()
{
CountrySettings settings = Scenarios.GetCountrySettings(_country) ??
Scenarios.CreateCountrySettings(_country);
TreeNode node = _treeView.SelectedNode;
TreeNode parent = node.Parent;
// 編集済みフラグを設定する
settings.SetDirty();
Scenarios.SetDirty();
// 未配備陸軍/海軍/空軍師団のルートノード
if (parent == null)
{
switch ((NodeType)node.Tag)
{
case NodeType.UndeployedLand:
AddDivision(Branch.Army, node, settings.LandDivisions, settings);
break;
case NodeType.UndeployedNaval:
AddDivision(Branch.Navy, node, settings.NavalDivisions, settings);
break;
case NodeType.UndeployedAir:
AddDivision(Branch.Airforce, node, settings.AirDivisions, settings);
break;
}
return;
}
// 陸軍/海軍/空軍/搭載ユニット
Unit unit = node.Tag as Unit;
if (unit != null)
{
AddDivision(unit.Branch, node, unit.Divisions, settings);
return;
}
int index = parent.Nodes.IndexOf(node) + 1;
// 陸軍/海軍/空軍/搭載師団
unit = parent.Tag as Unit;
if (unit != null)
{
AddDivision(index, unit.Branch, parent, unit.Divisions, settings);
return;
}
// 未配備陸軍/海軍/空軍師団
switch ((NodeType)parent.Tag)
{
case NodeType.UndeployedLand:
AddDivision(index, Branch.Army, parent, settings.LandDivisions, settings);
break;
case NodeType.UndeployedNaval:
AddDivision(index, Branch.Navy, parent, settings.NavalDivisions, settings);
break;
case NodeType.UndeployedAir:
AddDivision(index, Branch.Airforce, parent, settings.AirDivisions, settings);
break;
}
}
/// <summary>
/// 発明イベントリストの表示を更新する
/// </summary>
/// <param name="settings">国家設定</param>
private void UpdateInventionList(CountrySettings settings)
{
inventionsListView.ItemChecked -= OnInveitionsListViewItemChecked;
inventionsListView.BeginUpdate();
inventionsListView.Items.Clear();
if (settings != null)
{
foreach (TechEvent ev in _inventions)
{
inventionsListView.Items.Add(new ListViewItem
{
Text = ev.ToString(),
Checked = settings.Inventions.Contains(ev.Id),
ForeColor = settings.IsDirtyInvention(ev.Id) ? Color.Red : inventionsListView.ForeColor,
Tag = ev
});
}
}
else
{
foreach (TechEvent ev in _inventions)
{
inventionsListView.Items.Add(new ListViewItem { Text = ev.ToString(), Tag = ev });
}
}
inventionsListView.EndUpdate();
inventionsListView.ItemChecked += OnInveitionsListViewItemChecked;
}
/// <summary>
/// リスト項目の値を更新する
/// </summary>
/// <param name="control">コントロール</param>
/// <param name="division">師団</param>
/// <param name="settings">国家設定</param>
public void UpdateListItems(ComboBox control, Division division, CountrySettings settings)
{
control.BeginUpdate();
control.Items.Clear();
ScenarioEditorItemId itemId = (ScenarioEditorItemId) control.Tag;
UnitClass uc;
switch (itemId)
{
case ScenarioEditorItemId.DivisionUnitType:
case ScenarioEditorItemId.DivisionBrigadeType1:
case ScenarioEditorItemId.DivisionBrigadeType2:
case ScenarioEditorItemId.DivisionBrigadeType3:
case ScenarioEditorItemId.DivisionBrigadeType4:
case ScenarioEditorItemId.DivisionBrigadeType5:
List<UnitType> types = (List<UnitType>) GetListItems(itemId, division);
foreach (UnitType type in types)
{
control.Items.Add(Units.Items[(int) type]);
}
break;
case ScenarioEditorItemId.DivisionModel:
uc = Units.Items[(int) division.Type];
for (int i = 0; i < uc.Models.Count; i++)
{
string name = uc.GetCountryModelName(i, settings.Country);
if (string.IsNullOrEmpty(name))
{
name = uc.GetModelName(i);
}
control.Items.Add(name);
}
break;
case ScenarioEditorItemId.DivisionBrigadeModel1:
uc = Units.Items[(int) division.Extra1];
for (int i = 0; i < uc.Models.Count; i++)
{
string name = uc.GetCountryModelName(i, settings.Country);
if (string.IsNullOrEmpty(name))
{
name = uc.GetModelName(i);
}
control.Items.Add(name);
}
break;
case ScenarioEditorItemId.DivisionBrigadeModel2:
uc = Units.Items[(int) division.Extra2];
for (int i = 0; i < uc.Models.Count; i++)
{
string name = uc.GetCountryModelName(i, settings.Country);
if (string.IsNullOrEmpty(name))
{
name = uc.GetModelName(i);
}
control.Items.Add(name);
}
break;
case ScenarioEditorItemId.DivisionBrigadeModel3:
uc = Units.Items[(int) division.Extra3];
for (int i = 0; i < uc.Models.Count; i++)
{
string name = uc.GetCountryModelName(i, settings.Country);
if (string.IsNullOrEmpty(name))
{
name = uc.GetModelName(i);
}
control.Items.Add(name);
}
break;
case ScenarioEditorItemId.DivisionBrigadeModel4:
uc = Units.Items[(int) division.Extra4];
for (int i = 0; i < uc.Models.Count; i++)
{
string name = uc.GetCountryModelName(i, settings.Country);
if (string.IsNullOrEmpty(name))
{
name = uc.GetModelName(i);
}
control.Items.Add(name);
}
break;
case ScenarioEditorItemId.DivisionBrigadeModel5:
uc = Units.Items[(int) division.Extra5];
for (int i = 0; i < uc.Models.Count; i++)
{
string name = uc.GetCountryModelName(i, settings.Country);
if (string.IsNullOrEmpty(name))
{
name = uc.GetModelName(i);
}
control.Items.Add(name);
}
break;
}
control.EndUpdate();
}
/// <summary>
/// 国家AI情報の編集項目を更新する
/// </summary>
/// <param name="settings">国家設定</param>
private void UpdateCountryAiItems(CountrySettings settings)
{
// 編集項目の表示を更新する
_controller.UpdateItemValue(aiFileNameTextBox, settings);
// 編集項目の色を更新する
_controller.UpdateItemColor(aiFileNameTextBox, settings);
}
/// <summary>
/// 国家補正値の編集項目を更新する
/// </summary>
/// <param name="settings">国家設定</param>
private void UpdateCountryModifierItems(CountrySettings settings)
{
// 編集項目の表示を更新する
_controller.UpdateItemValue(groundDefEffTextBox, settings);
_controller.UpdateItemValue(peacetimeIcModifierTextBox, settings);
_controller.UpdateItemValue(wartimeIcModifierTextBox, settings);
_controller.UpdateItemValue(industrialModifierTextBox, settings);
_controller.UpdateItemValue(relativeManpowerTextBox, settings);
// 編集項目の色を更新する
_controller.UpdateItemColor(groundDefEffTextBox, settings);
_controller.UpdateItemColor(peacetimeIcModifierTextBox, settings);
_controller.UpdateItemColor(wartimeIcModifierTextBox, settings);
_controller.UpdateItemColor(industrialModifierTextBox, settings);
_controller.UpdateItemColor(relativeManpowerTextBox, settings);
}
/// <summary>
/// 項目変更前の処理 - 首都
/// </summary>
/// <param name="control">対象コントロール</param>
/// <param name="val">編集項目の値</param>
/// <param name="province">プロヴィンス</param>
/// <param name="settings">国家設定</param>
private void PreItemChangedCapital(Control control, object val, Province province, CountrySettings settings)
{
// チェックを入れた後はチェックボックスを無効化する
if ((bool) val)
{
control.Enabled = false;
}
// プロヴィンスリストビューの表示を更新する
int index = GetLandProvinceIndex(settings.Capital);
if (index >= 0)
{
_form.SetProvinceListItemText(index, 2, "");
}
index = _landProvinces.IndexOf(province);
if (index >= 0)
{
_form.SetProvinceListItemText(index, 2, Resources.Yes);
}
}
/// <summary>
/// 項目変更前の処理 - 師団type
/// </summary>
/// <param name="control">idのコントロール</param>
/// <param name="val">編集項目の値</param>
/// <param name="division">師団</param>
/// <param name="settings">国家設定</param>
private void PreItemChangedDivisionType(TextBox control, object val, Division division, CountrySettings settings)
{
// 新規idを設定する
division.Id.Id = Scenarios.GetNewId((int) val, 1);
// 編集済みフラグを設定する
ScenarioEditorItemId itemId = (ScenarioEditorItemId) control.Tag;
SetItemDirty(itemId, division, settings);
// 編集項目の値を更新する
UpdateItemValue(control, division);
// 編集項目の色を更新する
UpdateItemColor(control, division);
}
/// <summary>
/// 項目値変更後の処理 - 師団の戦力
/// </summary>
/// <param name="control">最大値のコントロール</param>
/// <param name="division">師団</param>
/// <param name="settings">国家設定</param>
private void PostItemChangedStrength(TextBox control, Division division, CountrySettings settings)
{
if (DoubleHelper.IsZero(division.MaxStrength) ||
DoubleHelper.IsLessOrEqual(division.Strength, division.MaxStrength))
{
return;
}
// 最大値を現在値に合わせる
division.MaxStrength = division.Strength;
// 編集済みフラグを設定する
division.SetDirty(Division.ItemId.MaxStrength);
settings.SetDirty();
Scenarios.SetDirty();
// 項目の値を更新する
UpdateItemValue(control, division);
// 項目の色を更新する
UpdateItemColor(control, division);
}
/// <summary>
/// 項目変更前の処理 - 閣僚id
/// </summary>
/// <param name="control">typeのコントロール</param>
/// <param name="settings">国家設定</param>
/// <param name="typeId">typeとidの組</param>
private void PreItemChangedCabinetId(TextBox control, CountrySettings settings, TypeId typeId)
{
typeId.Type = Scenarios.GetNewType(settings.HeadOfState?.Type ?? 1);
// 編集済みフラグを設定する
ScenarioEditorItemId itemId = (ScenarioEditorItemId) control.Tag;
SetItemDirty(itemId, settings);
// 編集項目の値を更新する
UpdateItemValue(control, settings);
// 編集項目の色を更新する
UpdateItemColor(control, settings);
}
/// <summary>
/// 項目値変更後の処理 - 保有プロヴィンス
/// </summary>
/// <param name="val">編集項目の値</param>
/// <param name="province">プロヴィンス</param>
/// <param name="settings">国家設定</param>
private void PostItemChangedOwnedProvinces(object val, Province province, CountrySettings settings)
{
// 変更前の保有国を解除
foreach (Country country in Countries.Tags)
{
CountrySettings cs = Scenarios.GetCountrySettings(country);
if (cs == null || cs.Country == settings.Country ||
!cs.OwnedProvinces.Contains(province.Id))
{
continue;
}
cs.OwnedProvinces.Remove(province.Id);
cs.SetDirtyOwnedProvinces(province.Id);
}
// プロヴィンスリストビューの表示を更新する
int index = GetLandProvinceIndex(province.Id);
if (index >= 0)
{
_form.SetProvinceListItemText(index, 4, (bool) val ? Resources.Yes : "");
}
// プロヴィンスの強調表示を更新する
if (_mapPanelController.FilterMode == MapPanelController.MapFilterMode.Owned)
{
_mapPanelController.UpdateProvince((ushort) province.Id, (bool) val);
}
}
/// <summary>
/// 項目値変更後の処理 - 師団の最大組織率
/// </summary>
/// <param name="control">現在値のコントロール</param>
/// <param name="division">師団</param>
/// <param name="settings">国家設定</param>
private void PostItemChangedMaxOrganisation(TextBox control, Division division, CountrySettings settings)
{
if (DoubleHelper.IsZero(division.Organisation) ||
DoubleHelper.IsLessOrEqual(division.Organisation, division.MaxOrganisation))
{
return;
}
// 現在値を最大値に合わせる
division.Organisation = division.MaxOrganisation;
// 編集済みフラグを設定する
division.SetDirty(Division.ItemId.Organisation);
settings.SetDirty();
Scenarios.SetDirty();
// 項目の値を更新する
UpdateItemValue(control, division);
// 項目の色を更新する
UpdateItemColor(control, division);
}
/// <summary>
/// 項目値変更後の処理 - 独立保障
/// </summary>
/// <param name="control1">コントロール1</param>
/// <param name="control2">コントロール2</param>
/// <param name="control3">コントロール3</param>
/// <param name="val">編集項目の値</param>
/// <param name="relation">国家関係</param>
/// <param name="settings">国家設定</param>
private void PostItemChangedGuaranteed(TextBox control1, TextBox control2, TextBox control3, object val,
Relation relation, CountrySettings settings)
{
// 編集済みフラグを設定する
ScenarioEditorItemId itemId1 = (ScenarioEditorItemId) control1.Tag;
SetItemDirty(itemId1, relation, settings);
ScenarioEditorItemId itemId2 = (ScenarioEditorItemId) control2.Tag;
SetItemDirty(itemId2, relation, settings);
ScenarioEditorItemId itemId3 = (ScenarioEditorItemId) control3.Tag;
SetItemDirty(itemId3, relation, settings);
// 項目の値を更新する
UpdateItemValue(control1, relation);
UpdateItemValue(control2, relation);
UpdateItemValue(control3, relation);
// 項目の色を更新する
UpdateItemColor(control1, relation);
UpdateItemColor(control2, relation);
UpdateItemColor(control3, relation);
// 項目を有効化/無効化する
control1.Enabled = (bool) val;
control2.Enabled = (bool) val;
control3.Enabled = (bool) val;
// 関係リストビューの項目を更新する
_form.SetRelationListItemText(5, (bool) val ? Resources.Yes : "");
}
/// <summary>
/// 青写真リストの表示を更新する
/// </summary>
/// <param name="settings">国家設定</param>
private void UpdateBlueprintList(CountrySettings settings)
{
blueprintsListView.ItemChecked -= OnBlueprintsListViewItemChecked;
blueprintsListView.BeginUpdate();
blueprintsListView.Items.Clear();
if (settings != null)
{
foreach (TechItem item in _techs)
{
string name = item.ToString();
blueprintsListView.Items.Add(new ListViewItem
{
Text = name,
Checked = settings.BluePrints.Contains(item.Id),
ForeColor = settings.IsDirtyBlueprint(item.Id) ? Color.Red : ownedTechsListView.ForeColor,
Tag = item
});
}
}
else
{
foreach (TechItem item in _techs)
{
string name = item.ToString();
blueprintsListView.Items.Add(new ListViewItem { Text = name, Tag = item });
}
}
blueprintsListView.EndUpdate();
blueprintsListView.ItemChecked += OnBlueprintsListViewItemChecked;
}
/// <summary>
/// 項目変更前の処理 - スライダー移動日時
/// </summary>
/// <param name="control1">連動するコントロール1</param>
/// <param name="control2">連動するコントロール2</param>
/// <param name="settings">国家設定</param>
private void PreItemChangedSliderDate(TextBox control1, TextBox control2, CountrySettings settings)
{
if (settings.Policy == null)
{
settings.Policy = new CountryPolicy();
}
if (settings.Policy.Date == null)
{
settings.Policy.Date = new GameDate();
// 編集済みフラグを設定する
ScenarioEditorItemId itemId1 = (ScenarioEditorItemId) control1.Tag;
SetItemDirty(itemId1, settings);
ScenarioEditorItemId itemId2 = (ScenarioEditorItemId) control2.Tag;
SetItemDirty(itemId2, settings);
// 編集項目の値を更新する
UpdateItemValue(control1, settings);
UpdateItemValue(control2, settings);
// 編集項目の色を更新する
UpdateItemColor(control1, settings);
UpdateItemColor(control2, settings);
}
}
/// <summary>
/// 閣僚の編集項目を更新する
/// </summary>
/// <param name="country">選択国</param>
/// <param name="settings">国家設定</param>
/// <param name="year">対象年次</param>
private void UpdateCabinetItems(Country country, CountrySettings settings, int year)
{
// 閣僚候補リストを更新する
_controller.UpdateMinisterList(country, year);
// 閣僚コンボボックスの表示を更新する
_controller.UpdateItemValue(headOfStateComboBox, settings);
_controller.UpdateItemValue(headOfGovernmentComboBox, settings);
_controller.UpdateItemValue(foreignMinisterComboBox, settings);
_controller.UpdateItemValue(armamentMinisterComboBox, settings);
_controller.UpdateItemValue(ministerOfSecurityComboBox, settings);
_controller.UpdateItemValue(ministerOfIntelligenceComboBox, settings);
_controller.UpdateItemValue(chiefOfStaffComboBox, settings);
_controller.UpdateItemValue(chiefOfArmyComboBox, settings);
_controller.UpdateItemValue(chiefOfNavyComboBox, settings);
_controller.UpdateItemValue(chiefOfAirComboBox, settings);
// 閣僚type/idテキストボックスの表示を更新する
_controller.UpdateItemValue(headOfStateTypeTextBox, settings);
_controller.UpdateItemValue(headOfStateIdTextBox, settings);
_controller.UpdateItemValue(headOfGovernmentTypeTextBox, settings);
_controller.UpdateItemValue(headOfGovernmentIdTextBox, settings);
_controller.UpdateItemValue(foreignMinisterTypeTextBox, settings);
_controller.UpdateItemValue(foreignMinisterIdTextBox, settings);
_controller.UpdateItemValue(armamentMinisterTypeTextBox, settings);
_controller.UpdateItemValue(armamentMinisterIdTextBox, settings);
_controller.UpdateItemValue(ministerOfSecurityTypeTextBox, settings);
_controller.UpdateItemValue(ministerOfSecurityIdTextBox, settings);
_controller.UpdateItemValue(ministerOfIntelligenceTypeTextBox, settings);
_controller.UpdateItemValue(ministerOfIntelligenceIdTextBox, settings);
_controller.UpdateItemValue(chiefOfStaffTypeTextBox, settings);
_controller.UpdateItemValue(chiefOfStaffIdTextBox, settings);
_controller.UpdateItemValue(chiefOfArmyTypeTextBox, settings);
_controller.UpdateItemValue(chiefOfArmyIdTextBox, settings);
_controller.UpdateItemValue(chiefOfNavyTypeTextBox, settings);
_controller.UpdateItemValue(chiefOfNavyIdTextBox, settings);
_controller.UpdateItemValue(chiefOfAirTypeTextBox, settings);
_controller.UpdateItemValue(chiefOfAirIdTextBox, settings);
// 閣僚type/idテキストボックスの色を更新する
_controller.UpdateItemColor(headOfStateTypeTextBox, settings);
_controller.UpdateItemColor(headOfStateIdTextBox, settings);
_controller.UpdateItemColor(headOfGovernmentTypeTextBox, settings);
_controller.UpdateItemColor(headOfGovernmentIdTextBox, settings);
_controller.UpdateItemColor(foreignMinisterTypeTextBox, settings);
_controller.UpdateItemColor(foreignMinisterIdTextBox, settings);
_controller.UpdateItemColor(armamentMinisterTypeTextBox, settings);
_controller.UpdateItemColor(armamentMinisterIdTextBox, settings);
_controller.UpdateItemColor(ministerOfSecurityTypeTextBox, settings);
_controller.UpdateItemColor(ministerOfSecurityIdTextBox, settings);
_controller.UpdateItemColor(ministerOfIntelligenceTypeTextBox, settings);
_controller.UpdateItemColor(ministerOfIntelligenceIdTextBox, settings);
_controller.UpdateItemColor(chiefOfStaffTypeTextBox, settings);
_controller.UpdateItemColor(chiefOfStaffIdTextBox, settings);
_controller.UpdateItemColor(chiefOfArmyTypeTextBox, settings);
_controller.UpdateItemColor(chiefOfArmyIdTextBox, settings);
_controller.UpdateItemColor(chiefOfNavyTypeTextBox, settings);
_controller.UpdateItemColor(chiefOfNavyIdTextBox, settings);
_controller.UpdateItemColor(chiefOfAirTypeTextBox, settings);
_controller.UpdateItemColor(chiefOfAirIdTextBox, settings);
}
/// <summary>
/// 項目変更前の処理 - ユニットtype
/// </summary>
/// <param name="control">idのコントロール</param>
/// <param name="val">編集項目の値</param>
/// <param name="unit">ユニット</param>
/// <param name="settings">国家設定</param>
private void PreItemChangedUnitType(TextBox control, object val, Unit unit, CountrySettings settings)
{
// 新規idを設定する
unit.Id.Id = Scenarios.GetNewId((int) val, 1);
// 編集済みフラグを設定する
ScenarioEditorItemId itemId = (ScenarioEditorItemId) control.Tag;
SetItemDirty(itemId, unit, settings);
// 編集項目の値を更新する
UpdateItemValue(control, unit);
// 編集項目の色を更新する
UpdateItemColor(control, unit);
}
/// <summary>
/// 国家情報の編集項目を更新する
/// </summary>
/// <param name="country">選択国</param>
/// <param name="settings">国家設定</param>
private void UpdateCountryInfoItems(Country country, CountrySettings settings)
{
// 編集項目の表示を更新する
_controller.UpdateItemValue(countryNameKeyTextBox, settings);
_controller.UpdateItemValue(countryNameStringTextBox, country, settings);
_controller.UpdateItemValue(flagExtTextBox, settings);
_controller.UpdateItemValue(regularIdComboBox, settings);
_controller.UpdateItemValue(belligerenceTextBox, settings);
_controller.UpdateItemValue(dissentTextBox, settings);
_controller.UpdateItemValue(extraTcTextBox, settings);
_controller.UpdateItemValue(nukeTextBox, settings);
_controller.UpdateItemValue(nukeYearTextBox, settings);
_controller.UpdateItemValue(nukeMonthTextBox, settings);
_controller.UpdateItemValue(nukeDayTextBox, settings);
// 編集項目の色を更新する
_controller.UpdateItemColor(countryNameKeyTextBox, settings);
_controller.UpdateItemColor(countryNameStringTextBox, country, settings);
_controller.UpdateItemColor(flagExtTextBox, settings);
_controller.UpdateItemColor(belligerenceTextBox, settings);
_controller.UpdateItemColor(dissentTextBox, settings);
_controller.UpdateItemColor(extraTcTextBox, settings);
_controller.UpdateItemColor(nukeTextBox, settings);
_controller.UpdateItemColor(nukeYearTextBox, settings);
_controller.UpdateItemColor(nukeMonthTextBox, settings);
_controller.UpdateItemColor(nukeDayTextBox, settings);
}
/// <summary>
/// ユニットを複製する
/// </summary>
/// <param name="original">複製対象のユニット</param>
private void CloneUnit(Unit original)
{
CountrySettings settings = Scenarios.GetCountrySettings(_country) ??
Scenarios.CreateCountrySettings(_country);
Unit unit = new Unit(original);
unit.SetDirtyAll();
TreeNode selected = _treeView.SelectedNode;
TreeNode parent = selected.Parent;
TreeNode node;
int index = parent.Nodes.IndexOf(selected) + 1;
// 編集済みフラグを設定する
settings.SetDirty();
Scenarios.SetDirty();
// 陸軍/海軍/空軍/搭載ユニット
switch ((NodeType)parent.Tag)
{
case NodeType.Land:
node = CreateLandUnitNode(unit);
if (string.IsNullOrEmpty(unit.Name))
{
node.Text = Resources.UnitTreeNewUnit;
}
parent.Nodes.Insert(index, node);
settings.LandUnits.Insert(index, unit);
_treeView.SelectedNode = node;
break;
case NodeType.Naval:
node = CreateNavalUnitNode(unit);
if (string.IsNullOrEmpty(unit.Name))
{
node.Text = Resources.UnitTreeNewUnit;
}
parent.Nodes.Insert(index, node);
settings.NavalUnits.Insert(index, unit);
_treeView.SelectedNode = node;
break;
case NodeType.Air:
node = CreateAirUnitNode(unit);
if (string.IsNullOrEmpty(unit.Name))
{
node.Text = Resources.UnitTreeNewUnit;
}
parent.Nodes.Insert(index, node);
settings.AirUnits.Insert(index, unit);
_treeView.SelectedNode = node;
break;
case NodeType.Boarding:
node = CreateLandUnitNode(unit);
if (string.IsNullOrEmpty(unit.Name))
{
node.Text = Resources.UnitTreeNewUnit;
}
parent.Nodes.Insert(index, node);
Unit transport = (Unit)parent.Parent.Tag;
transport.LandUnits.Insert(index, unit);
_treeView.SelectedNode = node;
break;
}
}
/// <summary>
/// 国家資源情報の編集項目を更新する
/// </summary>
/// <param name="settings">国家設定</param>
private void UpdateCountryResourceItems(CountrySettings settings)
{
// 編集項目の表示を更新する
_controller.UpdateItemValue(countryEnergyTextBox, settings);
_controller.UpdateItemValue(countryMetalTextBox, settings);
_controller.UpdateItemValue(countryRareMaterialsTextBox, settings);
_controller.UpdateItemValue(countryOilTextBox, settings);
_controller.UpdateItemValue(countrySuppliesTextBox, settings);
_controller.UpdateItemValue(countryMoneyTextBox, settings);
_controller.UpdateItemValue(countryTransportsTextBox, settings);
_controller.UpdateItemValue(countryEscortsTextBox, settings);
_controller.UpdateItemValue(countryManpowerTextBox, settings);
_controller.UpdateItemValue(offmapEnergyTextBox, settings);
_controller.UpdateItemValue(offmapMetalTextBox, settings);
_controller.UpdateItemValue(offmapRareMaterialsTextBox, settings);
_controller.UpdateItemValue(offmapOilTextBox, settings);
_controller.UpdateItemValue(offmapSuppliesTextBox, settings);
_controller.UpdateItemValue(offmapMoneyTextBox, settings);
_controller.UpdateItemValue(offmapTransportsTextBox, settings);
_controller.UpdateItemValue(offmapEscortsTextBox, settings);
_controller.UpdateItemValue(offmapManpowerTextBox, settings);
_controller.UpdateItemValue(offmapIcTextBox, settings);
// 編集項目の色を更新する
_controller.UpdateItemColor(countryEnergyTextBox, settings);
_controller.UpdateItemColor(countryMetalTextBox, settings);
_controller.UpdateItemColor(countryRareMaterialsTextBox, settings);
_controller.UpdateItemColor(countryOilTextBox, settings);
_controller.UpdateItemColor(countrySuppliesTextBox, settings);
_controller.UpdateItemColor(countryMoneyTextBox, settings);
_controller.UpdateItemColor(countryTransportsTextBox, settings);
_controller.UpdateItemColor(countryEscortsTextBox, settings);
_controller.UpdateItemColor(countryManpowerTextBox, settings);
_controller.UpdateItemColor(offmapEnergyTextBox, settings);
_controller.UpdateItemColor(offmapMetalTextBox, settings);
_controller.UpdateItemColor(offmapRareMaterialsTextBox, settings);
_controller.UpdateItemColor(offmapOilTextBox, settings);
_controller.UpdateItemColor(offmapSuppliesTextBox, settings);
_controller.UpdateItemColor(offmapMoneyTextBox, settings);
_controller.UpdateItemColor(offmapTransportsTextBox, settings);
_controller.UpdateItemColor(offmapEscortsTextBox, settings);
_controller.UpdateItemColor(offmapManpowerTextBox, settings);
_controller.UpdateItemColor(offmapIcTextBox, settings);
}
/// <summary>
/// 項目値変更後の処理 - 旅団のユニット種類
/// </summary>
/// <param name="control">ユニットモデルコンボボックス</param>
/// <param name="division">師団</param>
/// <param name="settings">国家設定</param>
private void PostItemChangedBrigadeType(ComboBox control, Division division, CountrySettings settings)
{
// 項目の候補を更新する
UpdateListItems(control, division, settings);
// 項目の値を更新する
UpdateItemValue(control, division);
}
/// <summary>
/// ユニットツリーを更新する
/// </summary>
public void Update()
{
_treeView.BeginUpdate();
_treeView.Nodes.Clear();
if (_country == Country.None)
{
_treeView.EndUpdate();
return;
}
CountrySettings settings = Scenarios.GetCountrySettings(_country);
// 陸軍ユニット
TreeNode node = new TreeNode(Resources.UnitTreeLand)
{
Tag = NodeType.Land
};
if (settings != null)
{
foreach (Unit unit in settings.LandUnits)
{
node.Nodes.Add(CreateLandUnitNode(unit));
}
}
_treeView.Nodes.Add(node);
// 海軍ユニット
node = new TreeNode(Resources.UnitTreeNaval)
{
Tag = NodeType.Naval
};
if (settings != null)
{
foreach (Unit unit in settings.NavalUnits)
{
node.Nodes.Add(CreateNavalUnitNode(unit));
}
}
_treeView.Nodes.Add(node);
// 空軍ユニット
node = new TreeNode(Resources.UnitTreeAir)
{
Tag = NodeType.Air
};
if (settings != null)
{
foreach (Unit unit in settings.AirUnits)
{
node.Nodes.Add(CreateAirUnitNode(unit));
}
}
_treeView.Nodes.Add(node);
// 未配備陸軍師団
node = new TreeNode(Resources.UnitTreeUndeployedLand)
{
Tag = NodeType.UndeployedLand
};
if (settings != null)
{
foreach (Division division in settings.LandDivisions)
{
node.Nodes.Add(CreateLandDivisionNode(division));
}
}
_treeView.Nodes.Add(node);
// 未配備海軍師団
node = new TreeNode(Resources.UnitTreeUndeployedNaval)
{
Tag = NodeType.UndeployedNaval
};
if (settings != null)
{
foreach (Division division in settings.NavalDivisions)
{
node.Nodes.Add(CreateNavalDivisionNode(division));
}
}
_treeView.Nodes.Add(node);
// 未配備空軍師団
node = new TreeNode(Resources.UnitTreeUndeployedAir)
{
Tag = NodeType.UndeployedAir
};
if (settings != null)
{
foreach (Division division in settings.AirDivisions)
{
node.Nodes.Add(CreateAirDivisionNode(division));
}
}
_treeView.Nodes.Add(node);
_treeView.EndUpdate();
}
/// <summary>
/// 編集項目の値を更新する
/// </summary>
/// <param name="control">コントロール</param>
/// <param name="settings">国家設定</param>
public void UpdateItemValue(TrackBar control, CountrySettings settings)
{
ScenarioEditorItemId itemId = (ScenarioEditorItemId) control.Tag;
object val = GetItemValue(itemId, settings);
if (val == null)
{
control.Value = 6;
return;
}
if ((int) val < 1)
{
val = 1;
}
else if ((int) val > 10)
{
val = 10;
}
control.Value = 11 - (int) val;
}
/// <summary>
/// 編集項目の値を更新する
/// </summary>
/// <param name="control">コントロール</param>
/// <param name="province">プロヴィンス</param>
/// <param name="settings">国家設定</param>
public void UpdateItemValue(CheckBox control, Province province, CountrySettings settings)
{
if (settings == null)
{
control.Checked = false;
return;
}
ScenarioEditorItemId itemId = (ScenarioEditorItemId) control.Tag;
switch (itemId)
{
case ScenarioEditorItemId.CountryCapital:
control.Checked = settings.Capital == province.Id;
control.Enabled = !control.Checked;
break;
case ScenarioEditorItemId.CountryCoreProvinces:
control.Checked = settings.NationalProvinces.Contains(province.Id);
break;
case ScenarioEditorItemId.CountryOwnedProvinces:
control.Checked = settings.OwnedProvinces.Contains(province.Id);
control.Enabled = !control.Checked;
break;
case ScenarioEditorItemId.CountryControlledProvinces:
control.Checked = settings.ControlledProvinces.Contains(province.Id);
control.Enabled = !control.Checked;
break;
case ScenarioEditorItemId.CountryClaimedProvinces:
control.Checked = settings.ClaimedProvinces.Contains(province.Id);
control.Enabled = Game.Type == GameType.DarkestHour;
break;
}
}
/// <summary>
/// 国家関係の編集項目を更新する
/// </summary>
/// <param name="relation">国家関係</param>
/// <param name="target">相手国</param>
/// <param name="settings">国家設定</param>
private void UpdateRelationItems(Relation relation, Country target, CountrySettings settings)
{
_controller.UpdateItemValue(relationValueTextBox, relation);
_controller.UpdateItemValue(masterCheckBox, target, settings);
_controller.UpdateItemValue(controlCheckBox, target, settings);
_controller.UpdateItemValue(accessCheckBox, relation);
_controller.UpdateItemColor(relationValueTextBox, relation);
_controller.UpdateItemColor(masterCheckBox, settings);
_controller.UpdateItemColor(controlCheckBox, settings);
_controller.UpdateItemColor(accessCheckBox, relation);
}
/// <summary>
/// 編集項目の値を更新する
/// </summary>
/// <param name="control">コントロール</param>
/// <param name="country">選択国</param>
/// <param name="settings">国家設定</param>
public void UpdateItemValue(TextBox control, Country country, CountrySettings settings)
{
ScenarioEditorItemId itemId = (ScenarioEditorItemId) control.Tag;
control.Text = (string) GetItemValue(itemId, country, settings);
switch (itemId)
{
case ScenarioEditorItemId.CountryNameString:
// 国家設定の国名定義がないか、文字列直接埋め込み形式ならば編集不可
control.ReadOnly = string.IsNullOrEmpty(settings?.Name) || !Config.ExistsKey(settings.Name);
break;
}
}
/// <summary>
/// 国家関係リストビューの項目を作成する
/// </summary>
/// <param name="selected">選択国</param>
/// <param name="target">対象国</param>
/// <param name="settings">国家設定</param>
/// <returns>国家関係リストビューの項目</returns>
private ListViewItem CreateRelationListItem(Country selected, Country target, CountrySettings settings)
{
ListViewItem item = new ListViewItem(Countries.GetTagName(target));
Relation relation = Scenarios.GetCountryRelation(selected, target);
Treaty nonAggression = Scenarios.GetNonAggression(selected, target);
Treaty peace = Scenarios.GetPeace(selected, target);
SpySettings spy = Scenarios.GetCountryIntelligence(selected, target);
item.SubItems.Add(
ObjectHelper.ToString(_controller.GetItemValue(ScenarioEditorItemId.DiplomacyRelationValue, relation)));
item.SubItems.Add(
(Country) _controller.GetItemValue(ScenarioEditorItemId.DiplomacyMaster, settings) == target
? Resources.Yes
: "");
item.SubItems.Add(
(Country) _controller.GetItemValue(ScenarioEditorItemId.DiplomacyMilitaryControl, settings) == target
? Resources.Yes
: "");
item.SubItems.Add(
(bool) _controller.GetItemValue(ScenarioEditorItemId.DiplomacyMilitaryAccess, relation)
? Resources.Yes
: "");
item.SubItems.Add(
(bool) _controller.GetItemValue(ScenarioEditorItemId.DiplomacyGuaranteed, relation) ? Resources.Yes : "");
item.SubItems.Add(
(bool) _controller.GetItemValue(ScenarioEditorItemId.DiplomacyNonAggression, nonAggression)
? Resources.Yes
: "");
item.SubItems.Add(
(bool) _controller.GetItemValue(ScenarioEditorItemId.DiplomacyPeace, peace) ? Resources.Yes : "");
item.SubItems.Add(
ObjectHelper.ToString(_controller.GetItemValue(ScenarioEditorItemId.IntelligenceSpies, spy)));
return item;
}
/// <summary>
/// 国家設定を構文解析する
/// </summary>
/// <param name="lexer">字句解析器</param>
/// <param name="scenario">シナリオデータ</param>
/// <returns>国家設定</returns>
private static CountrySettings ParseCountry(TextLexer lexer, Scenario scenario)
{
// =
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;
}
CountrySettings settings = new CountrySettings();
while (true)
{
token = lexer.GetToken();
// ファイルの終端
if (token == null)
{
Log.MissingCloseBrace(LogCategory, "country", lexer);
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();
// tag
if (keyword.Equals("tag"))
{
Country? tag = ParseTag(lexer);
if (tag == null)
{
Log.InvalidClause(LogCategory, "tag", lexer);
continue;
}
CountrySettings prev = scenario.Countries.FirstOrDefault(s => s.Country == tag.Value);
if (prev != null)
{
settings = prev;
}
// 国タグ
settings.Country = (Country) tag;
continue;
}
// regular_id
if (keyword.Equals("regular_id"))
{
Country? tag = ParseTag(lexer);
if (tag == null)
{
Log.InvalidClause(LogCategory, "regular_id", lexer);
continue;
}
// 兄弟国
settings.RegularId = (Country) tag;
continue;
}
// intrinsic_gov_type
if (keyword.Equals("intrinsic_gov_type"))
{
string s = ParseIdentifier(lexer);
if (string.IsNullOrEmpty(s))
{
continue;
}
s = s.ToLower();
if (!Scenarios.GovernmentStrings.Contains(s))
{
Log.InvalidToken(LogCategory, token, lexer);
continue;
}
// 独立可能政体
settings.IntrinsicGovType = (GovernmentType) Array.IndexOf(Scenarios.GovernmentStrings, s);
continue;
}
// puppet
if (keyword.Equals("puppet"))
{
Country? tag = ParseTag(lexer);
if (tag == null)
{
Log.InvalidClause(LogCategory, "puppet", lexer);
continue;
}
// 宗主国
settings.Master = (Country) tag;
continue;
}
// control
if (keyword.Equals("control"))
{
Country? tag = ParseTag(lexer);
if (tag == null)
{
Log.InvalidClause(LogCategory, "control", lexer);
continue;
}
// 統帥権取得国
settings.Control = (Country) tag;
continue;
}
// belligerence
if (keyword.Equals("belligerence"))
{
int? n = ParseInt(lexer);
if (!n.HasValue)
{
Log.InvalidClause(LogCategory, "belligerence", lexer);
continue;
}
// 好戦性
settings.Belligerence = (int) n;
continue;
}
// extra_tc
if (keyword.Equals("extra_tc"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "extra_tc", lexer);
continue;
}
// 追加輸送能力
settings.ExtraTc = (double) d;
continue;
}
// dissent
if (keyword.Equals("dissent"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "dissent", lexer);
continue;
}
// 国民不満度
settings.Dissent = (double) d;
continue;
}
// capital
if (keyword.Equals("capital"))
{
int? n = ParseInt(lexer);
if (!n.HasValue)
{
Log.InvalidClause(LogCategory, "capital", lexer);
continue;
}
// 首都のプロヴィンスID
settings.Capital = (int) (double) n;
continue;
}
// tc_mod
if (keyword.Equals("tc_mod"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "tc_mod", lexer);
continue;
}
// TC補正
settings.TcModifier = (double) d;
continue;
}
// tc_occupied_mod
if (keyword.Equals("tc_occupied_mod"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "tc_occupied_mod", lexer);
continue;
}
// 占領地TC補正
settings.TcOccupiedModifier = (double) d;
continue;
}
// attrition_mod
if (keyword.Equals("attrition_mod"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "attrition_mod", lexer);
continue;
}
// 消耗補正
settings.AttritionModifier = (double) d;
continue;
}
// trickleback_mod
if (keyword.Equals("trickleback_mod"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "trickleback_mod", lexer);
continue;
}
// 漸次撤退補正
settings.TricklebackModifier = (double) d;
continue;
}
// max_amphib_mod
if (keyword.Equals("max_amphib_mod"))
{
int? n = ParseInt(lexer);
if (!n.HasValue)
{
Log.InvalidClause(LogCategory, "max_amphib_mod", lexer);
continue;
}
// 最大強襲上陸補正
settings.MaxAmphibModifier = (int) n;
continue;
}
// supply_dist_mod
if (keyword.Equals("supply_dist_mod"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "supply_dist_mod", lexer);
continue;
}
// 補給補正
settings.SupplyDistModifier = (double) d;
continue;
}
// repair_mod
if (keyword.Equals("repair_mod"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "repair_mod", lexer);
continue;
}
// 修理補正
settings.RepairModifier = (double) d;
continue;
}
// research_mod
if (keyword.Equals("research_mod"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "research_mod", lexer);
continue;
}
// 研究補正
settings.ResearchModifier = (double) d;
continue;
}
// peacetime_ic_mod
if (keyword.Equals("peacetime_ic_mod"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "peacetime_ic_mod", lexer);
continue;
}
// 平時IC補正
settings.PeacetimeIcModifier = (double) d;
continue;
}
// wartime_ic_mod
if (keyword.Equals("wartime_ic_mod"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "wartime_ic_mod", lexer);
continue;
}
// 戦時IC補正
settings.WartimeIcModifier = (double) d;
continue;
}
// industrial_modifier
if (keyword.Equals("industrial_modifier"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "industrial_modifier", lexer);
continue;
}
// 工業力補正
settings.IndustrialModifier = (double) d;
continue;
}
// ground_def_eff
if (keyword.Equals("ground_def_eff"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "ground_def_eff", lexer);
continue;
}
// 対地防御補正
settings.GroundDefEff = (double) d;
continue;
}
// ai
if (keyword.Equals("ai"))
{
string s = ParseString(lexer);
if (s == null)
{
Log.InvalidClause(LogCategory, "ai", lexer);
continue;
}
// AIファイル名
settings.AiFileName = s;
continue;
}
// manpower
if (keyword.Equals("manpower"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "manpower", lexer);
continue;
}
// 人的資源
settings.Manpower = (double) d;
continue;
}
// relative_manpower
if (keyword.Equals("relative_manpower"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "relative_manpower", lexer);
continue;
}
// 人的資源補正値
settings.RelativeManpower = (double) d;
continue;
}
// energy
if (keyword.Equals("energy"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "energy", lexer);
continue;
}
// エネルギー
settings.Energy = (double) d;
continue;
}
// metal
if (keyword.Equals("metal"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "metal", lexer);
continue;
}
// 金属
settings.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;
}
// 希少資源
settings.RareMaterials = (double) d;
continue;
}
// oil
if (keyword.Equals("oil"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "oil", lexer);
continue;
}
// 石油
settings.Oil = (double) d;
continue;
}
// supplies
if (keyword.Equals("supplies"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "supplies", lexer);
continue;
}
// 物資
settings.Supplies = (double) d;
continue;
}
// money
if (keyword.Equals("money"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "money", lexer);
continue;
}
// 資金
settings.Money = (double) d;
continue;
}
// transports
if (keyword.Equals("transports"))
{
int? n = ParseInt(lexer);
if (!n.HasValue)
{
Log.InvalidClause(LogCategory, "transports", lexer);
continue;
}
// 輸送船団
settings.Transports = (int) n;
continue;
}
// escorts
if (keyword.Equals("escorts"))
{
int? n = ParseInt(lexer);
if (!n.HasValue)
{
Log.InvalidClause(LogCategory, "escorts", lexer);
continue;
}
// 護衛艦
settings.Escorts = (int) n;
continue;
}
// nuke
if (keyword.Equals("nuke"))
{
int? n = ParseInt(lexer);
if (!n.HasValue)
{
Log.InvalidClause(LogCategory, "nuke", lexer);
continue;
}
// 核兵器
settings.Nuke = (int) n;
continue;
}
// free
if (keyword.Equals("free"))
{
ResourceSettings free = ParseFree(lexer);
if (free == null)
{
Log.InvalidSection(LogCategory, "free", lexer);
continue;
}
// マップ外資源
settings.Offmap = free;
continue;
}
// consumer
if (keyword.Equals("consumer"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "consumer", lexer);
continue;
}
// 消費財IC比率
settings.ConsumerSlider = (double) d;
continue;
}
// supply
if (keyword.Equals("supply"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "supply", lexer);
continue;
}
// 物資IC比率
settings.ConsumerSlider = (double) d;
continue;
}
// production
if (keyword.Equals("production"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "production", lexer);
continue;
}
// 生産IC比率
settings.ConsumerSlider = (double) d;
continue;
}
// reinforcement
if (keyword.Equals("reinforcement"))
{
double? d = ParseDouble(lexer);
if (!d.HasValue)
{
Log.InvalidClause(LogCategory, "reinforcement", lexer);
continue;
}
// 補充IC比率
settings.ConsumerSlider = (double) d;
continue;
}
// diplomacy
if (keyword.Equals("diplomacy"))
{
IEnumerable<Relation> list = ParseDiplomacy(lexer);
if (list == null)
{
Log.InvalidSection(LogCategory, "diplomacy", lexer);
continue;
}
// 外交設定
settings.Relations.AddRange(list);
continue;
}
// spyinfo
if (keyword.Equals("spyinfo"))
{
SpySettings spy = ParseSpyInfo(lexer);
if (spy == null)
{
Log.InvalidSection(LogCategory, "spyinfo", lexer);
continue;
}
// 諜報設定
settings.Intelligence.Add(spy);
continue;
}
// nationalprovinces
if (keyword.Equals("nationalprovinces"))
{
IEnumerable<int> list = ParseIdList(lexer);
if (list == null)
{
Log.InvalidSection(LogCategory, "nationalprovinces", lexer);
continue;
}
// 中核プロヴィンス
settings.NationalProvinces.AddRange(list);
continue;
}
// ownedprovinces
if (keyword.Equals("ownedprovinces"))
{
IEnumerable<int> list = ParseIdList(lexer);
if (list == null)
{
Log.InvalidSection(LogCategory, "ownedprovinces", lexer);
continue;
}
// 保有プロヴィンス
settings.OwnedProvinces.AddRange(list);
continue;
}
// controlledprovinces
if (keyword.Equals("controlledprovinces"))
{
IEnumerable<int> list = ParseIdList(lexer);
if (list == null)
{
Log.InvalidSection(LogCategory, "controlledprovinces", lexer);
continue;
}
// 支配プロヴィンス
settings.ControlledProvinces.AddRange(list);
continue;
}
// techapps
if (keyword.Equals("techapps"))
{
IEnumerable<int> list = ParseIdList(lexer);
if (list == null)
{
Log.InvalidSection(LogCategory, "techapps", lexer);
continue;
}
// 保有技術
settings.TechApps.AddRange(list);
continue;
}
// blueprints
if (keyword.Equals("blueprints"))
{
IEnumerable<int> list = ParseIdList(lexer);
if (list == null)
{
Log.InvalidSection(LogCategory, "blueprints", lexer);
continue;
}
// 青写真
settings.BluePrints.AddRange(list);
continue;
}
// inventions
if (keyword.Equals("inventions"))
{
IEnumerable<int> list = ParseIdList(lexer);
if (list == null)
{
Log.InvalidSection(LogCategory, "inventions", lexer);
continue;
}
// 発明イベント
settings.Inventions.AddRange(list);
continue;
}
// deactivate
if (keyword.Equals("deactivate"))
{
IEnumerable<int> list = ParseIdList(lexer);
if (list == null)
{
Log.InvalidSection(LogCategory, "deactivate", lexer);
continue;
}
// 無効技術
settings.Deactivate.AddRange(list);
continue;
}
// policy
if (keyword.Equals("policy"))
{
CountryPolicy policy = ParsePolicy(lexer);
if (policy == null)
{
Log.InvalidSection(LogCategory, "policy", lexer);
continue;
}
// 政策スライダー
settings.Policy = policy;
continue;
}
// nukedate
if (keyword.Equals("nukedate"))
{
GameDate date = ParseDate(lexer);
if (date == null)
{
Log.InvalidSection(LogCategory, "nukedate", lexer);
continue;
}
// 核兵器完成日時
settings.NukeDate = date;
continue;
}
// headofstate
if (keyword.Equals("headofstate"))
{
TypeId id = ParseTypeId(lexer);
if (id == null)
{
Log.InvalidSection(LogCategory, "headofstate", lexer);
continue;
}
// 国家元首
settings.HeadOfState = id;
continue;
}
// headofgovernment
if (keyword.Equals("headofgovernment"))
{
TypeId id = ParseTypeId(lexer);
if (id == null)
{
Log.InvalidSection(LogCategory, "headofgovernment", lexer);
continue;
}
// 政府首班
settings.HeadOfGovernment = id;
continue;
}
// foreignminister
if (keyword.Equals("foreignminister"))
{
TypeId id = ParseTypeId(lexer);
if (id == null)
{
Log.InvalidSection(LogCategory, "foreignminister", lexer);
continue;
}
// 外務大臣
settings.ForeignMinister = id;
continue;
}
// armamentminister
if (keyword.Equals("armamentminister"))
{
TypeId id = ParseTypeId(lexer);
if (id == null)
{
Log.InvalidSection(LogCategory, "armamentminister", lexer);
continue;
}
// 軍需大臣
settings.ArmamentMinister = id;
continue;
}
// ministerofsecurity
if (keyword.Equals("ministerofsecurity"))
{
TypeId id = ParseTypeId(lexer);
if (id == null)
{
Log.InvalidSection(LogCategory, "ministerofsecurity", lexer);
continue;
}
// 内務大臣
settings.MinisterOfSecurity = id;
continue;
}
// ministerofintelligence
if (keyword.Equals("ministerofintelligence"))
{
TypeId id = ParseTypeId(lexer);
if (id == null)
{
Log.InvalidSection(LogCategory, "ministerofintelligence", lexer);
continue;
}
// 情報大臣
settings.MinisterOfIntelligence = id;
continue;
}
// chiefofstaff
if (keyword.Equals("chiefofstaff"))
{
TypeId id = ParseTypeId(lexer);
if (id == null)
{
Log.InvalidSection(LogCategory, "chiefofstaff", lexer);
continue;
}
// 統合参謀総長
settings.ChiefOfStaff = id;
continue;
}
// chiefofarmy
if (keyword.Equals("chiefofarmy"))
{
TypeId id = ParseTypeId(lexer);
if (id == null)
{
Log.InvalidSection(LogCategory, "chiefofarmy", lexer);
continue;
}
// 陸軍総司令官
settings.ChiefOfArmy = id;
continue;
}
// chiefofnavy
if (keyword.Equals("chiefofnavy"))
{
TypeId id = ParseTypeId(lexer);
if (id == null)
{
Log.InvalidSection(LogCategory, "chiefofnavy", lexer);
continue;
}
// 海軍総司令官
settings.ChiefOfNavy = id;
continue;
}
// chiefofair
if (keyword.Equals("chiefofair"))
{
TypeId id = ParseTypeId(lexer);
if (id == null)
{
Log.InvalidSection(LogCategory, "chiefofair", lexer);
continue;
}
// 空軍総司令官
settings.ChiefOfAir = id;
continue;
}
// nationalidentity
if (keyword.Equals("nationalidentity"))
{
string s = ParseString(lexer);
if (s == null)
{
Log.InvalidClause(LogCategory, "nationalidentity", lexer);
continue;
}
// 国民の意識
settings.NationalIdentity = s;
continue;
}
// socialpolicy
if (keyword.Equals("socialpolicy"))
{
string s = ParseString(lexer);
if (s == null)
{
Log.InvalidClause(LogCategory, "socialpolicy", lexer);
continue;
}
// 社会政策
settings.SocialPolicy = s;
continue;
}
// nationalculture
if (keyword.Equals("nationalculture"))
{
string s = ParseString(lexer);
if (s == null)
{
Log.InvalidClause(LogCategory, "nationalculture", lexer);
continue;
}
// 国家の文化
settings.NationalCulture = s;
continue;
}
// dormant_leaders
if (keyword.Equals("dormant_leaders"))
{
IEnumerable<int> list = ParseIdList(lexer);
if (list == null)
{
Log.InvalidSection(LogCategory, "dormant_leaders", lexer);
continue;
}
// 休止指揮官
settings.DormantLeaders.AddRange(list);
continue;
}
// dormant_ministers
if (keyword.Equals("dormant_ministers"))
{
IEnumerable<int> list = ParseIdList(lexer);
if (list == null)
{
Log.InvalidSection(LogCategory, "dormant_ministers", lexer);
continue;
}
// 休止閣僚
settings.DormantMinisters.AddRange(list);
continue;
}
// dormant_teams
if (keyword.Equals("dormant_teams"))
{
IEnumerable<int> list = ParseIdList(lexer);
if (list == null)
{
Log.InvalidSection(LogCategory, "dormant_teams", lexer);
continue;
}
// 休止研究機関
settings.DormantTeams.AddRange(list);
continue;
}
// steal_leader
if (keyword.Equals("steal_leader"))
{
int? n = ParseInt(lexer);
if (!n.HasValue)
{
Log.InvalidClause(LogCategory, "steal_leader", lexer);
continue;
}
// 抽出指揮官
settings.StealLeaders.Add((int) n);
continue;
}
// allowed_divisions
if (keyword.Equals("allowed_divisions"))
{
Dictionary<UnitType, bool> divisions = ParseAllowedDivisions(lexer);
if (divisions == null)
{
Log.InvalidClause(LogCategory, "allowed_divisions", lexer);
continue;
}
// 生産可能師団
foreach (KeyValuePair<UnitType, bool> pair in divisions)
{
settings.AllowedDivisions[pair.Key] = pair.Value;
}
continue;
}
// allowed_brigades
if (keyword.Equals("allowed_brigades"))
{
Dictionary<UnitType, bool> brigades = ParseAllowedBrigades(lexer);
if (brigades == null)
{
Log.InvalidClause(LogCategory, "allowed_brigades", lexer);
continue;
}
// 生産可能旅団
foreach (KeyValuePair<UnitType, bool> pair in brigades)
{
settings.AllowedDivisions[pair.Key] = pair.Value;
}
continue;
}
// convoy
if (keyword.Equals("convoy"))
{
Convoy convoy = ParseConvoy(lexer);
if (convoy == null)
{
Log.InvalidSection(LogCategory, "convoy", lexer);
continue;
}
// 輸送船団
settings.Convoys.Add(convoy);
continue;
}
// landunit
if (keyword.Equals("landunit"))
{
Unit unit = ParseUnit(lexer, Branch.Army);
if (unit == null)
{
Log.InvalidSection(LogCategory, "landunit", lexer);
continue;
}
// 陸軍ユニット
settings.LandUnits.Add(unit);
continue;
}
// navalunit
if (keyword.Equals("navalunit"))
{
Unit unit = ParseUnit(lexer, Branch.Navy);
if (unit == null)
{
Log.InvalidSection(LogCategory, "navalunit", lexer);
continue;
}
// 海軍ユニット
settings.NavalUnits.Add(unit);
continue;
}
// airunit
if (keyword.Equals("airunit"))
{
Unit unit = ParseUnit(lexer, Branch.Airforce);
if (unit == null)
{
Log.InvalidSection(LogCategory, "airunit", lexer);
continue;
}
// 空軍ユニット
settings.AirUnits.Add(unit);
continue;
}
// division_development
if (keyword.Equals("division_development"))
{
DivisionDevelopment division = ParseDivisionDevelopment(lexer);
if (division == null)
{
Log.InvalidSection(LogCategory, "division_development", lexer);
continue;
}
// 生産中師団
settings.DivisionDevelopments.Add(division);
continue;
}
// convoy_development
if (keyword.Equals("convoy_development"))
{
ConvoyDevelopment convoy = ParseConvoyDevelopment(lexer);
if (convoy == null)
{
Log.InvalidSection(LogCategory, "convoy_development", lexer);
continue;
}
// 生産中輸送船団
settings.ConvoyDevelopments.Add(convoy);
continue;
}
// province_development
if (keyword.Equals("province_development"))
{
BuildingDevelopment building = ParseBuildingDevelopment(lexer);
if (building == null)
{
Log.InvalidSection(LogCategory, "province_development", lexer);
continue;
}
// 生産中建物
settings.BuildingDevelopments.Add(building);
continue;
}
// landdivision
if (keyword.Equals("landdivision"))
{
Division division = ParseDivision(lexer);
if (division == null)
{
Log.InvalidSection(LogCategory, "landdivision", lexer);
continue;
}
// 陸軍師団
division.Branch = Branch.Army;
settings.LandDivisions.Add(division);
continue;
}
// navaldivision
if (keyword.Equals("navaldivision"))
{
Division division = ParseDivision(lexer);
if (division == null)
{
Log.InvalidSection(LogCategory, "navaldivision", lexer);
continue;
}
// 海軍師団
division.Branch = Branch.Navy;
settings.NavalDivisions.Add(division);
continue;
}
// airdivision
if (keyword.Equals("airdivision"))
{
Division division = ParseDivision(lexer);
if (division == null)
{
Log.InvalidSection(LogCategory, "airdivision", lexer);
continue;
}
// 空軍師団
division.Branch = Branch.Airforce;
settings.AirDivisions.Add(division);
continue;
}
if (Game.Type == GameType.DarkestHour)
{
// name
if (keyword.Equals("name"))
{
string s = ParseStringOrIdentifier(lexer);
if (string.IsNullOrEmpty(s))
{
Log.InvalidClause(LogCategory, "name", lexer);
continue;
}
// 国名
settings.Name = s;
continue;
}
// flag_ext
if (keyword.Equals("flag_ext"))
{
string s = ParseStringOrIdentifier(lexer);
if (string.IsNullOrEmpty(s))
{
Log.InvalidClause(LogCategory, "flag_ext", lexer);
continue;
}
// 国旗の接尾辞
settings.FlagExt = s;
continue;
}
// ai_settings
if (keyword.Equals("ai_settings"))
{
AiSettings ai = ParseAiSettings(lexer);
if (settings == null)
{
Log.InvalidSection(LogCategory, "ai_settings", lexer);
continue;
}
// AI設定
settings.AiSettings = ai;
continue;
}
// claimedprovinces
if (keyword.Equals("claimedprovinces"))
{
IEnumerable<int> list = ParseIdList(lexer);
if (list == null)
{
Log.InvalidSection(LogCategory, "claimedprovinces", lexer);
continue;
}
// 領有権主張プロヴィンス
settings.ClaimedProvinces.AddRange(list);
continue;
}
}
// 無効なトークン
Log.InvalidToken(LogCategory, token, lexer);
lexer.SkipLine();
}
return settings;
}
/// <summary>
/// 項目値変更後の処理 - 閣僚
/// </summary>
/// <param name="control">閣僚idのコントロール</param>
/// <param name="settings">国家設定</param>
private void PostItemChangedCabinet(TextBox control, CountrySettings settings)
{
// 項目の値を更新する
UpdateItemValue(control, settings);
// 項目の色を更新する
UpdateItemColor(control, settings);
}
/// <summary>
/// 師団を複製する
/// </summary>
/// <param name="original">複製対象の師団</param>
private void CloneDivision(Division original)
{
Division division = new Division(original);
division.SetDirtyAll();
TreeNode selected = _treeView.SelectedNode;
TreeNode parent = selected.Parent;
TreeNode node;
int index = parent.Nodes.IndexOf(selected) + 1;
CountrySettings settings = Scenarios.GetCountrySettings(_country) ??
Scenarios.CreateCountrySettings(_country);
// 編集済みフラグを設定する
settings.SetDirty();
Scenarios.SetDirty();
// 陸軍/海軍/空軍/搭載師団
Unit unit = parent.Tag as Unit;
if (unit != null)
{
switch ((NodeType)parent.Parent.Tag)
{
case NodeType.Land:
case NodeType.Boarding:
node = CreateLandDivisionNode(division);
if (string.IsNullOrEmpty(division.Name))
{
node.Text = Resources.UnitTreeNewDivision;
}
parent.Nodes.Insert(index, node);
unit.Divisions.Insert(index, division);
_treeView.SelectedNode = node;
break;
case NodeType.Naval:
node = CreateNavalDivisionNode(division);
if (string.IsNullOrEmpty(division.Name))
{
node.Text = Resources.UnitTreeNewDivision;
}
parent.Nodes.Insert(index, node);
unit.Divisions.Insert(index, division);
_treeView.SelectedNode = node;
break;
case NodeType.Air:
node = CreateAirDivisionNode(division);
if (string.IsNullOrEmpty(division.Name))
{
node.Text = Resources.UnitTreeNewDivision;
}
parent.Nodes.Insert(index, node);
unit.Divisions.Insert(index, division);
_treeView.SelectedNode = node;
break;
}
return;
}
// 未配備陸軍/海軍/空軍師団
switch ((NodeType)parent.Tag)
{
case NodeType.UndeployedLand:
node = CreateLandDivisionNode(division);
if (string.IsNullOrEmpty(division.Name))
{
node.Text = Resources.UnitTreeNewDivision;
}
parent.Nodes.Insert(index, node);
settings.LandDivisions.Insert(index, division);
_treeView.SelectedNode = node;
break;
case NodeType.UndeployedNaval:
node = CreateNavalDivisionNode(division);
if (string.IsNullOrEmpty(division.Name))
{
node.Text = Resources.UnitTreeNewDivision;
}
parent.Nodes.Insert(index, node);
settings.NavalDivisions.Insert(index, division);
_treeView.SelectedNode = node;
break;
case NodeType.UndeployedAir:
node = CreateAirDivisionNode(division);
if (string.IsNullOrEmpty(division.Name))
{
node.Text = Resources.UnitTreeNewDivision;
}
parent.Nodes.Insert(index, node);
settings.AirDivisions.Insert(index, division);
_treeView.SelectedNode = node;
break;
}
}
/// <summary>
/// 政策スライダーの編集項目を更新する
/// </summary>
/// <param name="settings">国家設定</param>
private void UpdatePoliticalSliderItems(CountrySettings settings)
{
_controller.UpdateItemValue(sliderYearTextBox, settings);
_controller.UpdateItemValue(sliderMonthTextBox, settings);
_controller.UpdateItemValue(sliderDayTextBox, settings);
_controller.UpdateItemColor(sliderYearTextBox, settings);
_controller.UpdateItemColor(sliderMonthTextBox, settings);
_controller.UpdateItemColor(sliderDayTextBox, settings);
_controller.UpdateItemValue(democraticTrackBar, settings);
_controller.UpdateItemValue(politicalLeftTrackBar, settings);
_controller.UpdateItemValue(freedomTrackBar, settings);
_controller.UpdateItemValue(freeMarketTrackBar, settings);
_controller.UpdateItemValue(professionalArmyTrackBar, settings);
_controller.UpdateItemValue(defenseLobbyTrackBar, settings);
_controller.UpdateItemValue(interventionismTrackBar, settings);
}
/// <summary>
/// プロヴィンス国家情報の編集項目を更新する
/// </summary>
/// <param name="province">プロヴィンス</param>
/// <param name="settings">国家設定</param>
private void UpdateProvinceCountryItems(Province province, CountrySettings settings)
{
_controller.UpdateItemValue(capitalCheckBox, province, settings);
_controller.UpdateItemValue(coreProvinceCheckBox, province, settings);
_controller.UpdateItemValue(ownedProvinceCheckBox, province, settings);
_controller.UpdateItemValue(controlledProvinceCheckBox, province, settings);
_controller.UpdateItemValue(claimedProvinceCheckBox, province, settings);
_controller.UpdateItemColor(capitalCheckBox, province, settings);
_controller.UpdateItemColor(coreProvinceCheckBox, province, settings);
_controller.UpdateItemColor(ownedProvinceCheckBox, province, settings);
_controller.UpdateItemColor(controlledProvinceCheckBox, province, settings);
_controller.UpdateItemColor(claimedProvinceCheckBox, province, settings);
}
/// <summary>
/// 編集項目の値を更新する
/// </summary>
/// <param name="control">コントロール</param>
/// <param name="settings">国家設定</param>
public void UpdateItemValue(ComboBox control, CountrySettings settings)
{
ScenarioEditorItemId itemId = (ScenarioEditorItemId) control.Tag;
switch (itemId)
{
case ScenarioEditorItemId.CountryRegularId:
Country country = (Country) (GetItemValue(itemId, settings) ?? Country.None);
control.SelectedIndex = Array.IndexOf(Countries.Tags, country) + 1;
break;
case ScenarioEditorItemId.CabinetHeadOfState:
case ScenarioEditorItemId.CabinetHeadOfGovernment:
case ScenarioEditorItemId.CabinetForeignMinister:
case ScenarioEditorItemId.CabinetArmamentMinister:
case ScenarioEditorItemId.CabinetMinisterOfSecurity:
case ScenarioEditorItemId.CabinetMinisterOfIntelligence:
case ScenarioEditorItemId.CabinetChiefOfStaff:
case ScenarioEditorItemId.CabinetChiefOfArmy:
case ScenarioEditorItemId.CabinetChiefOfNavy:
case ScenarioEditorItemId.CabinetChiefOfAir:
List<Minister> ministers = (List<Minister>) GetListItems(itemId);
control.BeginUpdate();
control.Items.Clear();
foreach (Minister minister in ministers)
{
control.Items.Add(minister.Name);
}
control.EndUpdate();
object val = GetItemValue(itemId, settings);
if (val != null)
{
control.SelectedIndex = ministers.FindIndex(minister => minister.Id == (int) val);
}
break;
}
}
