public KillRulesController(IKillRulesView view, Plane planeTemplate)
{
Plane = planeTemplate;
_view = view;
_view.SetController(this);
_view.GetGraphics();
}
public GameBoardController(IGameBoardView view)
{
_planeTemplate = new Plane();
_view = view;
Common.GameBoardController = this;
_oponentType = "network";
_planeOrientation = "up";
}
private static void RotatePlaneMatrix(Plane plane)
{
var matrixOperation = new MatrixOperations();
plane.PlaneMatrix = matrixOperation.Rotate(plane.PlaneMatrix, plane.NumberOfRows,
plane.NumberOfColumns);
var temp = plane.NumberOfRows;
plane.NumberOfRows = plane.NumberOfColumns;
plane.NumberOfColumns = temp;
}
public void SetPlaneLeft(Plane plane)
{
plane.Orientation = "left";
for (var i = 0; i < 3; i++)
{
RotatePlaneMatrix(plane);
}
UpdateKillPoints(plane);
}
public void SetPlaneDown(Plane plane)
{
plane.Orientation = "down";
for (var i = 0; i < 2; i++)
{
RotatePlaneMatrix(plane);
}
UpdateKillPoints(plane);
}
private static void UpdateKillPoints(Plane plane)
{
plane.KillPoints.Clear();
for (var i = 0; i < plane.NumberOfRows; i++)
{
for (var j = 0; j < plane.NumberOfColumns; j++)
{
if (plane.PlaneMatrix[i, j] == 2)
plane.KillPoints.Add(new MatrixCoordinate(i, j));
}
}
}
public void SetPlaneRight(Plane plane)
{
plane.Orientation = "right";
RotatePlaneMatrix(plane);
UpdateKillPoints(plane);
}
private Plane GetPlaneRotation(MatrixCoordinate tileLocation)
{
var plane = new Plane
{
PlaneMatrix = _planeTemplate.PlaneMatrix,
KillPoints = _planeTemplate.KillPoints.ToList()
};
var planeRotator = new PlaneRotator();
switch (_planeOrientation)
{
case "up":
if (tileLocation.Row <= 6 && tileLocation.Column >= 1 && tileLocation.Column <= 8)
{
tileLocation.Column -= 1;
BuildPlane(tileLocation, plane);
}
break;
case "down":
if (tileLocation.Row >= 3 && tileLocation.Column >= 1 && tileLocation.Column <= 8)
{
tileLocation.Column -= 1;
tileLocation.Row -= 3;
planeRotator.SetPlaneDown(plane);
BuildPlane(tileLocation, plane);
}
break;
case "right":
if (tileLocation.Column >= 3 && tileLocation.Row >= 1 && tileLocation.Row <= 8)
{
tileLocation.Column -= 3;
tileLocation.Row -= 1;
planeRotator.SetPlaneRight(plane);
BuildPlane(tileLocation, plane);
}
break;
case "left":
if (tileLocation.Column <= 6 && tileLocation.Row >= 1 && tileLocation.Row <= 8)
{
tileLocation.Row -= 1;
planeRotator.SetPlaneLeft(plane);
BuildPlane(tileLocation, plane);
}
break;
}
return plane;
}
private MatrixCoordinate GetKillPoint(Plane plane)
{
return plane.KillPoints.Find(
killpoint =>
killpoint.Row == _currentAttackPoint.Row - plane.PlaneStartPosition.Row &&
killpoint.Column == _currentAttackPoint.Column - plane.PlaneStartPosition.Column);
}
private bool CheckPlaneDuplicates(MatrixCoordinate matrixCoordinate, Plane plane)
{
var row = 0;
for (var i = matrixCoordinate.Row; i < matrixCoordinate.Row + plane.NumberOfRows; i++, row++)
{
var column = 0;
for (var j = matrixCoordinate.Column;
j < matrixCoordinate.Column + plane.NumberOfColumns;
j++, column++)
{
if (_localPlayer.PlaneMatrix[i, j] == 0 ||
plane.PlaneMatrix[row, column] != 1 && plane.PlaneMatrix[row, column] != 2) continue;
MessageBox.Show(@"Planes intersecting, retry!");
return true;
}
}
return false;
}
private void BuildPlane(MatrixCoordinate matrixCoordinate, Plane plane)
{
if (CheckPlaneDuplicates(matrixCoordinate, plane)) return;
_localPlayer.PlanesAlive++;
_localPlayer.PlanesList.Add(plane);
var row = 0;
for (var i = matrixCoordinate.Row; i < matrixCoordinate.Row + plane.NumberOfRows; i++, row++)
{
var column = 0;
for (var j = matrixCoordinate.Column;
j < matrixCoordinate.Column + plane.NumberOfColumns;
j++, column++)
{
if (plane.PlaneMatrix[row, column] == 0) continue;
_playerPanelEngine.UpdateTile(i, j, Color.Blue);
_localPlayer.PlaneMatrix[i, j] = plane.PlaneMatrix[row, column];
}
}
}
private void BuildOponentPlane(MatrixCoordinate startCoordinate, string direction)
{
var plane = new Plane();
var planeRotator = new PlaneRotator();
switch (direction)
{
case "up":
break;
case "down":
planeRotator.SetPlaneDown(plane);
break;
case "right":
planeRotator.SetPlaneRight(plane);
break;
case "left":
planeRotator.SetPlaneLeft(plane);
break;
}
plane.PlaneStartPosition = startCoordinate;
BuildDestroyedPlane(plane, false);
}
private void BuildDestroyedPlane(Plane plane, bool friendlyPlane)
{
var row = 0;
for (var i = plane.PlaneStartPosition.Row;
i < plane.PlaneStartPosition.Row + plane.NumberOfRows;
i++, row++)
{
var column = 0;
for (var j = plane.PlaneStartPosition.Column;
j < plane.PlaneStartPosition.Column + plane.NumberOfColumns;
j++, column++)
{
if (plane.PlaneMatrix[row, column] != 0)
{
if (friendlyPlane)
{
_playerPanelEngine.UpdateTile(i, j, Color.Red);
}
else
{
_oponentPanelEngine.UpdateTile(i, j, Color.Red);
}
_localPlayer.PlaneMatrix[i, j] = 3;
}
}
}
}
private static bool PlaneContains(MatrixCoordinate hitpoint, Plane plane)
{
return hitpoint.Row >= plane.PlaneStartPosition.Row &&
hitpoint.Row <= plane.PlaneStartPosition.Row + plane.NumberOfRows &&
hitpoint.Column >= plane.PlaneStartPosition.Column &&
hitpoint.Column <= plane.PlaneStartPosition.Column + plane.NumberOfColumns;
}
public void SetKillRules()
{
if (_network == null) return;
if (_network.ConnectionType != ConnectionType.Server) return;
var killRulesView = new KillRulesView();
var killRulesController = new KillRulesController(killRulesView, _planeTemplate);
if (killRulesView.ShowDialog() != DialogResult.OK) return;
_planeTemplate = killRulesController.Plane;
}
