public UnitConfigurationSelectionOption(
string ClassName,
string DetailsClassName,
string OverlayClassName,
UnitConfigurationLink UnitConfigurationLink,
Faction Faction,
UnitConfigurationRenderer Renderer,
bool DisplayCount)
: base(ClassName)
{
this.UnitConfigurationLink = UnitConfigurationLink;
StackView = new UnitConfigurationStackView(
UnitConfigurationLink.UnitConfiguration,
Faction,
Renderer,
Class.GetAttributeWithDefault("unit-scale", 0),
OverlayClassName,
DisplayCount);
StackView.Position = .5f * StackView.Size + new Vector2f(12, 12);
StackView.Parent = this;
Value = StackView;
_PointText = new Button(DetailsClassName);
_PointText.Position = new Vector2f(12, StackView.Size.Y + 16);
_PointText.Parent = this;
_PointText.DisplayedString =
UnitConfigurationLink.UnitConfiguration.GetPointValue(Faction.HalfPriceTrucks).ToString();
}
public void SetScenario(
Scenario Scenario, UnitConfigurationRenderer UnitRenderer, FactionRenderer FactionRenderer)
{
_ScenarioDisplay.Clear();
foreach (ArmyConfiguration army in Scenario.ArmyConfigurations)
{
_ScenarioDisplay.Add(
new Button("scenario-army-header")
{
DisplayedString = ObjectDescriber.Describe(army.Faction)
});
var factionMount = new GuiContainer <GuiItem>("scenario-faction-mount");
Vector2f size = factionMount.Size - factionMount.LeftPadding * 2;
var faction = new FactionView(army.Faction, FactionRenderer, Math.Min(size.X, size.Y));
faction.Position = .5f * (factionMount.Size - faction.Size) - factionMount.LeftPadding;
factionMount.Add(faction);
_ScenarioDisplay.Add(factionMount);
foreach (DeploymentConfiguration deployment in army.DeploymentConfigurations)
{
_ScenarioDisplay.Add(new DeploymentRow(deployment, army.Faction, UnitRenderer));
}
foreach (ObjectiveSuccessTrigger trigger in army.VictoryCondition.Triggers)
{
_ScenarioDisplay.Add(new VictoryConditionRow(trigger));
}
}
_DetailDisplay.Clear();
AddDetail("Environment", ObjectDescriber.Describe(Scenario.Environment));
AddDetail("Turns", Scenario.TurnConfiguration.Turns.ToString());
AddSequence("Deploy Order", Scenario.TurnConfiguration.DeploymentOrder, Scenario.ArmyConfigurations.ToArray());
AddSequence("Turn Order", Scenario.TurnConfiguration.TurnOrder, Scenario.ArmyConfigurations.ToArray());
AddDetail("Strength", Scenario.ArmyConfigurations.Select(i => DescribeStrength(i)).ToArray());
}
public override Pod SetupState(ProgramContext ProgramContext, ProgramStateContext ProgramStateContext)
{
_Context = ProgramStateContext;
var context = (ScenarioBuilderContext)_Context;
var builder = context.ScenarioBuilder.Armies.First(i => !i.Validate());
var renderer =
new UnitConfigurationRenderer(
GameData.UnitConfigurationLinks.Values
.Where(builder.Parameters.Matches)
.Select(i => i.UnitConfiguration),
GameData.UnitRenderDetails,
128,
1024,
ClassLibrary.Instance.GetFont("compacta"));
var screen =
new ArmyBuilderScreen(
ProgramContext.ScreenResolution,
GameData.UnitConfigurationLinks.Values,
builder.Parameters,
renderer);
screen.OnMainMenuButtonClicked += HandleBack;
_Controller = new ArmyBuilderController(builder, screen, renderer);
_Controller.OnFinished += HandleFinished;
return(screen);
}
public override DeploymentPage MakePage(DeploymentPane Pane, UnitConfigurationRenderer Renderer)
{
_DeploymentPage = new ConvoyDeploymentPage(_Deployment, Renderer, Pane);
_DeploymentPage.OnLoadAction += HandleLoad;
_DeploymentPage.OnUnloadAction += HandleUnload;
return(_DeploymentPage);
}
public ArmyBuilderController(
ArmyBuilder ArmyBuilder, ArmyBuilderScreen Screen, UnitConfigurationRenderer Renderer)
{
_ArmyBuilder = ArmyBuilder;
_Screen = Screen;
_Screen.OnFinished += HandleFinished;
_Screen.OnUnitConfigurationRightClicked += HandleUnitConfigurationRightClicked;
_Renderer = Renderer;
}
public SingularUnitSelectionOption(string ClassName, Unit Unit, UnitConfigurationRenderer Renderer)
: base(ClassName)
{
this.Unit = Unit;
_StackView.Add(new UnitView(Unit, Renderer, UNIT_VIEW_SCALE, false));
_StackView.Position = Size / 2;
_StackView.Parent = this;
Value = _StackView;
}
public GroupedUnitSelectionOption(
string ClassName, string OverlayClassName, IEnumerable <Unit> Units, UnitConfigurationRenderer Renderer)
: base(ClassName)
{
UnitConfiguration = Units.First().Configuration;
_StackView = new HomogenousStackView(
Units, Renderer, Class.GetAttributeWithDefault("unit-scale", 0), OverlayClassName);
_StackView.Position = Size / 2;
_StackView.Parent = this;
Value = _StackView;
}
public MatchScreen(
Vector2f WindowSize,
Match Match,
IEnumerable <Army> FollowedArmies,
TileRenderer TileRenderer,
UnitConfigurationRenderer UnitRenderer,
FactionRenderer FactionRenderer)
: base(WindowSize, Match.Map, TileRenderer)
{
Match.OnStartPhase += _EventBuffer.Hook <StartTurnComponentEventArgs>(HandleNewTurn).Invoke;
Match.OnExecuteOrder += _EventBuffer.Hook <ExecuteOrderEventArgs>(HandleOrderExecuted).Invoke;
this.UnitRenderer = UnitRenderer;
this.FactionRenderer = FactionRenderer;
_FollowedArmies = new HashSet <Army>(FollowedArmies);
_FogOfWar = Match.Scenario.Rules.FogOfWar;
_FogOfWarHandler = _EventBuffer.Hook <SightUpdatedEventArgs>(HandleSightUpdated);
EventHandler <NewUnitEventArgs> addUnitHandler = _EventBuffer.Hook <NewUnitEventArgs>(AddUnit).Invoke;
foreach (Army a in Match.Armies)
{
a.OnUnitAdded += addUnitHandler;
foreach (Unit u in a.Units)
{
AddUnit(u);
}
}
for (int i = 0; i < Match.Scenario.TurnConfiguration.Turns; ++i)
{
_TurnCounter.Add(new Checkbox("overlay-turn-counter-box")
{
Enabled = false
});
}
_FinishButton.Position = Size - _FinishButton.Size - new Vector2f(32, 32);
_FinishButton.OnClick += HandleFinishClicked;
_InfoDisplay.Position = _FinishButton.Position - new Vector2f(0, _InfoDisplay.Size.Y + 16);
_VictoryConditionDisplay.Position =
_InfoDisplay.Position - new Vector2f(0, _VictoryConditionDisplay.Size.Y + 16);
_ActionDisplay.Position = new Vector2f(WindowSize.X - _ActionDisplay.Size.X - 16, 16);
_TransformedItems.Add(_StackLayer);
_Items.Add(_FinishButton);
_Items.Add(_InfoDisplay);
_Items.Add(_VictoryConditionDisplay);
_Items.Add(_TurnCounter);
_Items.Add(_ActionDisplay);
}
public DeploymentRow(DeploymentConfiguration Deployment, Faction Faction, UnitConfigurationRenderer Renderer)
: base("scenario-deployment-row")
{
Add(new Button("scenario-deployment-header")
{
DisplayedString = Deployment.UnitGroup.Name
});
Add(new Button("scenario-deployment")
{
DisplayedString = DeploymentDescriber.Describe(Deployment)
});
Add(new UnitGroupView(Deployment.UnitGroup, Faction, Renderer));
}
public UnitView(Unit Unit, UnitConfigurationRenderer Renderer, float Scale, bool Reactive)
{
this.Unit = Unit;
this.Reactive = Reactive;
_Renderer = Renderer;
_UnitConfigurationView = new UnitConfigurationView(
Unit.Configuration, Unit.Army.Configuration.Faction, Renderer, Scale);
Unit.OnConfigurationChange +=
_UnitConfigurationChangedBuffer.Hook <EventArgs>(UpdateConfigurationView).Invoke;
Vector2f tl = new Vector2f(-.5f, -.15f) * Scale;
Vector2f tr = new Vector2f(.5f, -.15f) * Scale;
Vector2f br = new Vector2f(.5f, .15f) * Scale;
Vector2f bl = new Vector2f(-.5f, .15f) * Scale;
if (MOVED_DISPLAY == null)
{
MOVED_DISPLAY = new Button("overlay-moved-box")
{
DisplayedString = "MOVED"
};
MOVED_DISPLAY.Position = -.5f * new Vector2f(64, MOVED_DISPLAY.Size.Y);
}
if (FIRED_DISPLAY == null)
{
FIRED_DISPLAY = new Button("overlay-fired-box")
{
DisplayedString = "FIRED"
};
FIRED_DISPLAY.Position = -.5f * new Vector2f(64, FIRED_DISPLAY.Size.Y);
}
if (MOVING_DISPLAY == null)
{
MOVING_DISPLAY = new Button("overlay-moving-box")
{
DisplayedString = "MOVING"
};
MOVING_DISPLAY.Position = -.5f * new Vector2f(64, MOVING_DISPLAY.Size.Y);
}
if (WORKING_DISPLAY == null)
{
WORKING_DISPLAY = new Button("overlay-working-box")
{
DisplayedString = "WORKING"
};
WORKING_DISPLAY.Position = -.5f * new Vector2f(64, WORKING_DISPLAY.Size.Y);
}
}
public HomogenousStackView(
IEnumerable <Unit> Units, UnitConfigurationRenderer Renderer, int UnitScale, string OverlayClassName)
{
_Text = new Button(OverlayClassName);
_Text.Position = -.5f * new Vector2f(UnitScale, _Text.Size.Y);
_Text.Parent = this;
_UnitScale = UnitScale;
_Renderer = Renderer;
_UnitViews = new Stack <UnitView>(Units.Select(i => new UnitView(i, Renderer, _UnitScale, false)));
foreach (UnitView u in _UnitViews)
{
u.Parent = this;
}
}
public UnitConfigurationTable(
string ClassName,
string RowClassName,
string CellClassName,
Faction Faction,
UnitConfigurationRenderer Renderer,
bool StackDuplicates)
: base(ClassName)
{
_Renderer = Renderer;
_Faction = Faction;
_RowClassName = RowClassName;
_CellClassName = CellClassName;
_ItemWidth = _Class.GetAttributeWithDefault("item-width", 1);
_StackDuplicates = StackDuplicates;
}
public UnitInfoPane(Unit Unit, UnitConfigurationRenderer Renderer)
: base(Unit.Configuration, Unit.Army.Configuration.Faction, Renderer)
{
_Info.Add(new Button("unit-info-header")
{
DisplayedString = ObjectDescriber.Describe(Unit)
});
AddBasicAttributes();
AddComposition();
AddCombatCapabilities();
AddSightCapabilities();
AddTransportCapabilities();
AddMovementAttributes();
AddMountedInfantryAttributes();
}
public UnitConfigurationStackView(
UnitConfiguration UnitConfiguration,
Faction Faction,
UnitConfigurationRenderer Renderer,
int UnitScale,
string OverlayClassName,
bool DisplayCount)
{
_DisplayCount = DisplayCount;
_UnitConfigurationView = new UnitConfigurationView(UnitConfiguration, Faction, Renderer, UnitScale);
if (_DisplayCount)
{
_Text = new Button(OverlayClassName);
_Text.Position = -.5f * new Vector2f(UnitScale, _Text.Size.Y);
_Text.Parent = this;
}
}
protected UnitInfoPaneBase(
UnitConfiguration UnitConfiguration, Faction Faction, UnitConfigurationRenderer Renderer)
: base("unit-info-pane")
{
_UnitConfiguration = UnitConfiguration;
_Faction = Faction;
_CloseButton.Position = new Vector2f(Size.X - _CloseButton.Size.X - LeftPadding.X * 2, 0);
_CloseButton.OnClick += HandleClose;
_UnitConfigurationView = new UnitConfigurationView(UnitConfiguration, Faction, Renderer, 192);
_UnitConfigurationView.Position = new Vector2f(144, 96);
Add(_CloseButton);
Add(_UnitConfigurationView);
Add(_Info);
}
public ConvoyDeploymentPage(
ConvoyDeployment Deployment, UnitConfigurationRenderer Renderer, DeploymentPane Pane)
{
_Deployment = Deployment;
_Renderer = Renderer;
_MoveUpButton.OnClick += HandleMoveUp;
_MoveDownButton.OnClick += HandleMoveDown;
_LoadButton.OnClick += HandleLoadButton;
_UnloadButton.OnClick += HandleUnloadButton;
_Selection = new ValuedScrollCollection <SingularUnitSelectionOption, StackView>("deployment-select");
var units = Deployment.Units.ToList();
units.Sort(new FluentComparator <Unit>(i => i.Configuration.IsVehicle)
.ThenCompare(i => i.Configuration.IsArmored)
.ThenCompare(i => i.Configuration.UnitClass != UnitClass.TRANSPORT)
.ThenCompare(i => i.Configuration.Movement)
.Invert());
foreach (Unit u in units)
{
u.OnLoad += HandleLoad;
u.OnUnload += HandleUnload;
var option = new SingularUnitSelectionOption("deployment-selection-option", u, _Renderer);
_Selection.Add(option);
}
_Selection.Position = new Vector2f(0, 48);
_LoadButton.Position = new Vector2f(0, Pane.Size.Y - _LoadButton.Size.Y - 32);
_UnloadButton.Position = new Vector2f(_LoadButton.Size.X + 8, Pane.Size.Y - _UnloadButton.Size.Y - 32);
_MoveUpButton.Position = new Vector2f(0, Pane.Size.Y - _LoadButton.Size.Y - _MoveUpButton.Size.Y - 36);
_MoveDownButton.Position = new Vector2f(
_MoveUpButton.Size.X + 8, Pane.Size.Y - _UnloadButton.Size.Y - _MoveDownButton.Size.Y - 36);
Add(_Selection);
Add(_LoadButton);
Add(_UnloadButton);
Add(_MoveUpButton);
Add(_MoveDownButton);
}
public override Pod SetupState(ProgramContext ProgramContext, ProgramStateContext ProgramStateContext)
{
_Context = (MatchContext)ProgramStateContext;
_MatchEndBuffer = new EventBuffer <EventArgs>();
var renderer = new UnitConfigurationRenderer(
_Context.Match.Scenario,
GameData.UnitRenderDetails,
128,
1024,
ClassLibrary.Instance.GetFont("compacta"));
var factionRenderer =
new FactionRenderer(_Context.Match.Scenario, GameData.FactionRenderDetails, 512, 1024);
var armies = new HashSet <Army>(_Context.GetPlayerControlledArmies());
var screen = new MatchScreen(
ProgramContext.ScreenResolution,
_Context.Match,
armies,
GameData.TileRenderers[_Context.Match.Scenario.Environment.UniqueKey],
renderer,
factionRenderer);
var controller =
new HumanMatchPlayerController(
_Context.MakeMatchAdapter(), armies, renderer, screen, ProgramContext.KeyController);
var playerControllers = new Dictionary <Army, MatchPlayerController>();
foreach (Army a in _Context.Match.Armies)
{
// var controller = new AIMatchPlayerController(_Context.MakeMatchAdapter(), a);
var overrideController = _Context.GetOverridePlayerController(a);
playerControllers.Add(a, overrideController ?? controller);
}
_MatchController = new MatchController(_Context.Match, playerControllers);
screen.OnPulse += HandlePulse;
_Context.Match.OnMatchEnded += _MatchEndBuffer.Hook <EventArgs>(HandleMatchEnd).Invoke;
_Context.Match.Start();
return(screen);
}
public ScenarioSelectScreen(Vector2f WindowSize, IEnumerable <Scenario> Scenarios)
: base(WindowSize)
{
_Renderer =
new UnitConfigurationRenderer(
Scenarios.SelectMany(i => i.UnitConfigurations).Distinct(),
GameData.UnitRenderDetails,
128,
1024,
ClassLibrary.Instance.GetFont("compacta"));
_FactionRenderer =
new FactionRenderer(
Scenarios.SelectMany(i => i.ArmyConfigurations.Select(j => j.Faction)).Distinct(),
GameData.FactionRenderDetails,
512,
1024);
foreach (Scenario s in Scenarios)
{
var option = new SelectionOption <Scenario>("scenario-selection-option")
{
DisplayedString = s.Name,
Value = s
};
_ScenarioSelect.Add(option);
}
_ScenarioSelect.OnChange += HandleSelect;
_ScenarioView.Position = new Vector2f(_ScenarioSelect.Size.X + 16, 0);
_StartButton.OnClick += HandleStart;
_StartButton.Position = new Vector2f(0, _Display.Size.Y - _StartButton.Size.Y - 32);
_Display.Position = .5f * (WindowSize - _Display.Size);
_Display.Add(_ScenarioSelect);
_Display.Add(_ScenarioView);
_Display.Add(_StartButton);
_Items.Add(_Display);
}
public UnitGroupView(UnitGroup UnitGroup, Faction Faction, UnitConfigurationRenderer Renderer)
: base("scenario-deployment-units")
{
var offset = Math.Min(68, (Size.X - LeftPadding.X * 2 - 64) / (UnitGroup.UnitCounts.Count() - 1));
int i = 0;
foreach (UnitCount count in UnitGroup.UnitCounts)
{
Add(
new UnitConfigurationStackView(
count.UnitConfiguration,
Faction,
Renderer,
64,
"scenario-deployment-units-overlay",
true)
{
Count = count.Count,
Position = new Vector2f(offset * i + 32, 32)
});
++i;
}
}
public PositionalDeploymentPage(PositionalDeployment Deployment, UnitConfigurationRenderer Renderer)
{
_Deployment = Deployment;
_Renderer = Renderer;
_Selection =
new ValuedScrollCollection <GroupedUnitSelectionOption, HomogenousStackView>("deployment-select");
_Selection.OnChange +=
(sender, e) => { if (OnSelectedStack != null)
{
OnSelectedStack(this, EventArgs.Empty);
}
};
foreach (var g in Deployment.Units.Where(i => i.Position == null).GroupBy(i => i.Configuration))
{
_Selection.Add(
new GroupedUnitSelectionOption(
"deployment-selection-option", "deployment-selection-option-overlay", g, _Renderer));
}
_Selection.Position = new Vector2f(0, 48);
Add(_Selection);
}
public UnitConfigurationView(
UnitConfiguration UnitConfiguration, Faction Faction, UnitConfigurationRenderer Renderer, float Scale)
{
this.Scale = Scale;
Color[] colors = UnitConfiguration.UnitClass == UnitClass.BLOCK ||
UnitConfiguration.UnitClass == UnitClass.MINEFIELD
? new Color[] { Color.White } : Faction.Colors;
if (!UnitConfiguration.IsVehicle)
{
colors = colors.ToArray();
for (int i = 0; i < colors.Length; ++i)
{
var f = new FloatingColor(colors[i]);
f = f.MakeHSL();
f.B = Math.Min(1, f.B + .1f);
colors[i] = f.MakeRGB().ConvertToColor();
}
}
_Vertices = new Vertex[colors.Length * 4];
float barHeight = 1f / colors.Length;
var backgroundRenderInfo = Renderer.GetRenderInfo(null);
_BackgroundTexture = backgroundRenderInfo.Item1;
var v = backgroundRenderInfo.Item2;
for (int i = 0; i < colors.Length; ++i)
{
float yT = v[0].Y + ((float)i / colors.Length) * (v[0].Y + v[2].Y);
float yB = v[0].Y + ((float)(i + 1) / colors.Length) * (v[0].Y + v[2].Y);
_Vertices[i * 4] =
new Vertex(new Vector2f(-.5f, i * barHeight - .5f), colors[i], new Vector2f(v[0].X, yT));
_Vertices[i * 4 + 1] =
new Vertex(new Vector2f(.5f, i * barHeight - .5f), colors[i], new Vector2f(v[2].X, yT));
_Vertices[i * 4 + 2] =
new Vertex(new Vector2f(.5f, (i + 1) * barHeight - .5f), colors[i], new Vector2f(v[2].X, yB));
_Vertices[i * 4 + 3] =
new Vertex(new Vector2f(-.5f, (i + 1) * barHeight - .5f), colors[i], new Vector2f(v[0].X, yB));
}
var renderInfo = Renderer.GetRenderInfo(UnitConfiguration);
_Texture = renderInfo.Item1;
_ImageVertices = new Vertex[4];
Color c = Renderer.RenderDetails[UnitConfiguration.UniqueKey].OverrideColor;
if (c.R == 0 && c.G == 0 && c.B == 0)
{
c = colors.ArgMax(i => new FloatingColor(i).Luminosity());
}
var tl = new Vector2f(-.5f, -.5f);
var tr = new Vector2f(.5f, -.5f);
var br = new Vector2f(.5f, .5f);
var bl = new Vector2f(-.5f, .5f);
_ImageVertices[0] = new Vertex(tl, c, renderInfo.Item2[0]);
_ImageVertices[1] = new Vertex(tr, c, renderInfo.Item2[1]);
_ImageVertices[2] = new Vertex(br, c, renderInfo.Item2[2]);
_ImageVertices[3] = new Vertex(bl, c, renderInfo.Item2[3]);
_Bounds = new Rectangle(new Vector2f(-.5f, -.5f) * Scale, new Vector2f(1, 1) * Scale);
}
public ArmyBuilderScreen(
Vector2f WindowSize,
IEnumerable <UnitConfigurationLink> UnitConfigurations,
ArmyParameters Parameters,
UnitConfigurationRenderer Renderer)
: base(WindowSize)
{
_Parameters = Parameters;
_Links = UnitConfigurations;
_Pane.Position = .5f * (WindowSize - _Pane.Size);
var header = new Button("army-builder-header")
{
DisplayedString =
string.Format(
"{0} - {1} - {2}",
ObjectDescriber.Describe(Parameters.Faction),
ObjectDescriber.Describe(Parameters.Parameters.Setting.Front),
Parameters.Parameters.Year)
};
_UnitClassSelect.Position = new Vector2f(0, header.Size.Y);
_AvailableUnits = new UnitConfigurationTable(
"army-builder-table",
"army-builder-table-row",
"army-builder-table-cell",
_Parameters.Faction,
Renderer,
false);
_AvailableUnits.Position = new Vector2f(0, _UnitClassSelect.Position.Y + _UnitClassSelect.Size.Y + 16);
_AvailableUnits.OnUnitClicked += HandleAddUnit;
_AvailableUnits.OnUnitRightClicked += HandleUnitInfoRequested;
_PointTotalButton = new Button("army-builder-point-total");
_PointTotalButton.Position = new Vector2f(_AvailableUnits.Size.X + 16, header.Size.Y);
SetPointTotal(0);
_SelectedUnits = new UnitConfigurationTable(
"army-builder-table",
"army-builder-table-row",
"army-builder-table-cell",
_Parameters.Faction,
Renderer,
true);
_SelectedUnits.Position =
new Vector2f(_AvailableUnits.Size.X + 16, _PointTotalButton.Position.Y + _PointTotalButton.Size.Y + 16);
_SelectedUnits.OnUnitRightClicked += HandleRemoveUnit;
foreach (UnitClass c in Enum.GetValues(typeof(UnitClass)))
{
_UnitClassSelect.Add(
new SelectionOption <UnitClass>("army-builder-select-option")
{
DisplayedString = ObjectDescriber.Describe(c),
Value = c
});
}
_UnitClassSelect.OnChange += FilterUnits;
FilterUnits();
var finishedButton = new Button("army-builder-large-button")
{
DisplayedString = "Finished"
};
finishedButton.Position = _Pane.Size - finishedButton.Size - new Vector2f(32, 32);
finishedButton.OnClick += HandleFinished;
_Pane.Add(header);
_Pane.Add(_AvailableUnits);
_Pane.Add(_SelectedUnits);
_Pane.Add(_PointTotalButton);
_Pane.Add(_UnitClassSelect);
_Pane.Add(finishedButton);
_Items.Add(_Pane);
}
public HumanMatchPlayerController(
MatchAdapter Match,
IEnumerable <Army> AllowedArmies,
UnitConfigurationRenderer UnitConfigurationRenderer,
MatchScreen MatchScreen,
KeyController KeyController)
{
_NewUnitBuffer = new EventBuffer <ValuedEventArgs <UnitView> >();
this.Match = Match;
this.AllowedArmies = new HashSet <Army>(AllowedArmies);
this.UnitConfigurationRenderer = UnitConfigurationRenderer;
_MatchScreen = MatchScreen;
_MatchScreen.OnFinishClicked += EndTurn;
_MatchScreen.OnUnitAdded += _NewUnitBuffer.Hook <ValuedEventArgs <UnitView> >(AddUnit).Invoke;
_MatchScreen.OnPulse += (sender, e) => _NewUnitBuffer.DispatchEvents();
_Controllers = new Dictionary <TurnComponent, Subcontroller>
{
{ TurnComponent.DEPLOYMENT, new DeploymentController(this) },
{ TurnComponent.AIRCRAFT, new AircraftController(this) },
{ TurnComponent.ANTI_AIRCRAFT, new AntiAircraftController(this) },
{ TurnComponent.ARTILLERY, new ArtilleryController(this) },
{ TurnComponent.ATTACK, new AttackController(this) },
{ TurnComponent.VEHICLE_COMBAT_MOVEMENT, new OverrunController(this) },
{ TurnComponent.VEHICLE_MOVEMENT, new MovementController(this, true) },
{ TurnComponent.CLOSE_ASSAULT, new CloseAssaultController(this) },
{ TurnComponent.NON_VEHICLE_MOVEMENT, new MovementController(this, false) },
{ TurnComponent.RESET, new NoOpController(this) },
{ TurnComponent.WAIT, new NoOpController(this) },
{ TurnComponent.SPECTATE, new NoOpController(this) }
};
foreach (TileView t in MatchScreen.MapView.TilesEnumerable)
{
t.OnClick += OnTileClick;
t.OnRightClick += OnTileRightClick;
}
foreach (UnitView u in _MatchScreen.UnitViews)
{
AddUnit(u);
}
_KeyController = KeyController;
KeyController.OnKeyPressed += OnKeyPressed;
MatchScreen.LoadButton.OnClick +=
(sender, e) => LoadUnit(_CurrentTurn.TurnComponent != TurnComponent.DEPLOYMENT);
MatchScreen.UnloadButton.OnClick += (sender, e) => UnloadUnit();
MatchScreen.FortifyButton.OnClick += (sender, e) => FortifyUnit();
MatchScreen.AbandonButton.OnClick += (sender, e) => AbandonUnit();
MatchScreen.DismountButton.OnClick += (sender, e) => Dismount();
MatchScreen.MountButton.OnClick += (sender, e) => Mount();
MatchScreen.EvacuateButton.OnClick += (sender, e) => Evacuate();
MatchScreen.ReconButton.OnClick += (sender, e) => Recon();
MatchScreen.ClearMinefieldButton.OnClick += (sender, e) => ClearMinefield();
MatchScreen.EmplaceButton.OnClick += (sender, e) => Emplace();
_AllowedActions = new Dictionary <Button, Func <bool> >
{
{ MatchScreen.LoadButton, () => _Controllers[_CurrentTurn.TurnComponent].CanLoad() },
{ MatchScreen.UnloadButton, () => _Controllers[_CurrentTurn.TurnComponent].CanUnload() },
{ MatchScreen.FortifyButton, () => _Controllers[_CurrentTurn.TurnComponent].CanFortify() },
{ MatchScreen.AbandonButton, () => _Controllers[_CurrentTurn.TurnComponent].CanAbandon() },
{ MatchScreen.DismountButton, () => _Controllers[_CurrentTurn.TurnComponent].CanDismount() },
{ MatchScreen.MountButton, () => _Controllers[_CurrentTurn.TurnComponent].CanMount() },
{ MatchScreen.EvacuateButton, () => _Controllers[_CurrentTurn.TurnComponent].CanEvacuate() },
{ MatchScreen.ReconButton, () => _Controllers[_CurrentTurn.TurnComponent].CanRecon() },
{
MatchScreen.ClearMinefieldButton,
() => _Controllers[_CurrentTurn.TurnComponent].CanClearMinefield()
},
{ MatchScreen.EmplaceButton, () => _Controllers[_CurrentTurn.TurnComponent].CanEmplace() }
};
}
public override DeploymentPage MakePage(DeploymentPane Pane, UnitConfigurationRenderer Renderer)
{
_DeploymentPage = new PositionalDeploymentPage(_Deployment, Renderer);
_DeploymentPage.OnSelectedStack += HighlightDeploymentArea;
return(_DeploymentPage);
}
public ScenarioView(Scenario Scenario, UnitConfigurationRenderer UnitRenderer, FactionRenderer FactionRenderer)
: this()
{
SetScenario(Scenario, UnitRenderer, FactionRenderer);
}
