protected virtual void CreateMap(DeathmatchMap Map)
{
DicTile3D.Clear();
for (int X = Map.MapSize.X - 1; X >= 0; --X)
{
for (int Y = Map.MapSize.Y - 1; Y >= 0; --Y)
{
Map.GetTerrain(X, Y, Map.ActiveLayerIndex).Position.Z = Random.Next(2) * 32;
float Z = Map.GetTerrain(X, Y, Map.ActiveLayerIndex).Position.Z;
Vector3[] ArrayVertexPosition = new Vector3[4];
ArrayVertexPosition[0] = new Vector3(X * Map.TileSize.X, Z, Y * Map.TileSize.Y);
ArrayVertexPosition[1] = new Vector3(X * Map.TileSize.X + Map.TileSize.X, Z, Y * Map.TileSize.Y);
ArrayVertexPosition[2] = new Vector3(X * Map.TileSize.X, Z, Y * Map.TileSize.Y + Map.TileSize.Y);
ArrayVertexPosition[3] = new Vector3(X * Map.TileSize.X + Map.TileSize.X, Z, Y * Map.TileSize.Y + Map.TileSize.Y);
Map2D GroundLayer = Map.ListLayer[0].OriginalLayerGrid;
DrawableTile ActiveTerrain = GroundLayer.GetTile(X, Y);
Texture2D ActiveTileset = Map.ListTileSet[ActiveTerrain.Tileset];
if (!DicTile3D.ContainsKey(ActiveTileset))
{
DicTile3D.Add(ActiveTileset, new List <Tile3D>());
}
DicTile3D[ActiveTileset].Add(CreateTile3D(Map, ArrayVertexPosition, ActiveTerrain.Origin.X, ActiveTerrain.Origin.Y, X, Y, ActiveTileset.Width, ActiveTileset.Height, Radius));
//Create slope right
if (X + 1 < Map.MapSize.X)
{
float ZRight = Map.GetTerrain(X + 1, Y, Map.ActiveLayerIndex).Position.Z;
if (Z != ZRight)
{
Vector3[] ArrayVertexPositionRight = new Vector3[4];
ArrayVertexPositionRight[0] = new Vector3(X * Map.TileSize.X + Map.TileSize.X, Z, Y * Map.TileSize.Y);
ArrayVertexPositionRight[2] = new Vector3(X * Map.TileSize.X + Map.TileSize.X, Z, Y * Map.TileSize.Y + Map.TileSize.Y);
ArrayVertexPositionRight[1] = new Vector3((X + 1) * Map.TileSize.X, ZRight, Y * Map.TileSize.Y);
ArrayVertexPositionRight[3] = new Vector3((X + 1) * Map.TileSize.X, ZRight, Y * Map.TileSize.Y + Map.TileSize.Y);
DicTile3D[ActiveTileset].Add(CreateTile3D(Map, ArrayVertexPositionRight, ActiveTerrain.Origin.X, ActiveTerrain.Origin.Y, X, Y, ActiveTileset.Width, ActiveTileset.Height, Radius));
}
}
//Create slope down
if (Y + 1 < Map.MapSize.Y)
{
float ZDown = Map.GetTerrain(X, Y + 1, Map.ActiveLayerIndex).Position.Z;
if (Z != ZDown)
{
Vector3[] ArrayVertexPositionDown = new Vector3[4];
ArrayVertexPositionDown[0] = new Vector3(X * Map.TileSize.X, Z, Y * Map.TileSize.Y + Map.TileSize.Y);
ArrayVertexPositionDown[1] = new Vector3(X * Map.TileSize.X + Map.TileSize.X, Z, Y * Map.TileSize.Y + Map.TileSize.Y);
ArrayVertexPositionDown[2] = new Vector3(X * Map.TileSize.X, ZDown, (Y + 1) * Map.TileSize.Y);
ArrayVertexPositionDown[3] = new Vector3(X * Map.TileSize.X + Map.TileSize.X, ZDown, (Y + 1) * Map.TileSize.Y);
DicTile3D[ActiveTileset].Add(CreateTile3D(Map, ArrayVertexPositionDown, ActiveTerrain.Origin.X, ActiveTerrain.Origin.Y, X, Y, ActiveTileset.Width, ActiveTileset.Height, Radius));
}
}
}
}
}
private void CreateFlatElevation(DeathmatchMap Map, Texture2D TileSet, Tile3D ActiveTile, int X, int Y)
{
Vector3 A = ActiveTile.ArrayVertex[0].Position;
Vector3 B = ActiveTile.ArrayVertex[1].Position;
Vector3 C = ActiveTile.ArrayVertex[2].Position;
Vector3 D = ActiveTile.ArrayVertex[3].Position;
Vector3 Normal = Vector3.Cross(C - B, B - A);
Normal.Normalize();
float Z = Map.GetTerrain(X, Y, Map.ActiveLayerIndex).Position.Z;
for (int V = ActiveTile.ArrayVertex.Length - 1; V >= 0; --V)
{
ActiveTile.ArrayVertex[V].Position += Normal * Z;
}
//Create slope right
if (X + 1 < Map.MapSize.X)
{
float ZRight = Map.GetTerrain(X + 1, Y, Map.ActiveLayerIndex).Position.Z;
if (Z != ZRight)
{
Vector3[] ArrayVertexPositionRight = new Vector3[4];
ArrayVertexPositionRight[0] = ActiveTile.ArrayVertex[1].Position;
ArrayVertexPositionRight[2] = ActiveTile.ArrayVertex[3].Position;
ArrayVertexPositionRight[1] = B + Normal * ZRight;
ArrayVertexPositionRight[3] = D + Normal * ZRight;
Tile3D NewTile = CreateTile(Map, TileSet, ArrayVertexPositionRight, X, Y);
CreateCubicTile(Map, TileSet, NewTile);
}
}
//Create slope down
if (Y + 1 < Map.MapSize.Y)
{
float ZDown = Map.GetTerrain(X, Y + 1, Map.ActiveLayerIndex).Position.Z;
if (Z != ZDown)
{
Vector3[] ArrayVertexPositionDown = new Vector3[4];
ArrayVertexPositionDown[0] = ActiveTile.ArrayVertex[2].Position;
ArrayVertexPositionDown[1] = ActiveTile.ArrayVertex[3].Position;
ArrayVertexPositionDown[2] = C + Normal * ZDown;
ArrayVertexPositionDown[3] = D + Normal * ZDown;
Tile3D NewTile = CreateTile(Map, TileSet, ArrayVertexPositionDown, X, Y);
CreateCubicTile(Map, TileSet, NewTile);
}
}
}
public override MovementAlgorithmTile GetTile(float PosX, float PosY, int LayerIndex)
{
if (PosX < 0 || PosY < 0 || PosX >= Map.MapSize.X || PosY >= Map.MapSize.Y)
{
return(null);
}
return(Map.GetTerrain(PosX, PosY, LayerIndex));
}
private static Tile3D CreateCursor(DeathmatchMap Map, float X, float Y, int TextureWidth, int TextureHeight, float Radius)
{
float Z = Map.GetTerrain(Math.Max(0, X), Math.Max(0, Y), Map.ActiveLayerIndex).Position.Z;
Vector3[] ArrayVertexPosition = new Vector3[4];
ArrayVertexPosition[0] = new Vector3(X * Map.TileSize.X, Z, Y * Map.TileSize.Y);
ArrayVertexPosition[1] = new Vector3(X * Map.TileSize.X + Map.TileSize.X, Z, Y * Map.TileSize.Y);
ArrayVertexPosition[2] = new Vector3(X * Map.TileSize.X, Z, Y * Map.TileSize.Y + Map.TileSize.Y);
ArrayVertexPosition[3] = new Vector3(X * Map.TileSize.X + Map.TileSize.X, Z, Y * Map.TileSize.Y + Map.TileSize.Y);
return(CreateTile3D(Map, ArrayVertexPosition, 0, 0, X, Y, TextureWidth, TextureHeight, Radius));
}
public void ComputeAttackTargets()
{
ListAllAttackTerrain.Clear();
ListRefusedAttackTerrain.Clear();
ListUsableAttackTerrain.Clear();
MovementAlgorithmTile ActiveTerrain = Map.GetTerrain(ActiveSquad.Position.X, ActiveSquad.Position.Y, (int)ActiveSquad.Position.Z);
ListAllAttackTerrain.Add(Map.GetTerrain(ActiveSquad.Position.X, ActiveSquad.Position.Y, (int)ActiveSquad.Position.Z));
ActiveTerrain.LayerIndex = (int)ActiveTerrain.Position.Z;
//Start Right, go downward
Vector2 TestedFinalPos = new Vector2(Map.MapSize.X, ActiveSquad.Position.Y);
do
{
for (int L = 0; L < Map.LayerManager.ListLayer.Count; ++L)
{
ProcessLine(ActiveTerrain, TestedFinalPos, L);
}
}while (++TestedFinalPos.Y < Map.MapSize.Y);
//Start bottom right, go bottom left
do
{
for (int L = 0; L < Map.LayerManager.ListLayer.Count; ++L)
{
ProcessLine(ActiveTerrain, TestedFinalPos, L);
}
}while (--TestedFinalPos.X >= 0);
//Start bottom left, go upper left
do
{
for (int L = 0; L < Map.LayerManager.ListLayer.Count; ++L)
{
ProcessLine(ActiveTerrain, TestedFinalPos, L);
}
}while (--TestedFinalPos.Y >= 0);
//Start upper left, go upper right
do
{
for (int L = 0; L < Map.LayerManager.ListLayer.Count; ++L)
{
ProcessLine(ActiveTerrain, TestedFinalPos, L);
}
}while (++TestedFinalPos.X < Map.MapSize.X);
//Start upper right, go back to start
do
{
for (int L = 0; L < Map.LayerManager.ListLayer.Count; ++L)
{
ProcessLine(ActiveTerrain, TestedFinalPos, L);
}
}while (++TestedFinalPos.Y < ActiveSquad.Position.Y);
//Aim for the ceiling
for (int X = 0; X < Map.MapSize.X; ++X)
{
for (int Y = 0; Y < Map.MapSize.Y; ++Y)
{
ProcessLine(ActiveTerrain, new Vector2(X, Y), Map.LayerManager.ListLayer.Count - 1);
}
}
}
public Terrain GetTerrain(int X, int Y, int LayerIndex)
{
return(ActiveMap.GetTerrain(X, Y, LayerIndex));
}
public override void Update(GameTime gameTime)
{
#region Toggle Spirit
//Add or remove the EN needed to the pilot.
if (InputHelper.InputCommand1Pressed())
{
if (ActiveSpirit == null || !ActiveSpirit.IsUnlocked)
{
return;
}
if (ActiveSpirit.CanActivate)
{
if (PilotSpiritActivation[ActiveUnitIndex][PilotIndex].Contains(ActiveSpirit))//Deactivate Skill
{
ListSelectedSpirit.Remove(ActiveSpirit);
PilotSpiritActivation[ActiveUnitIndex][PilotIndex].Remove(ActiveSpirit);
Map.sndSelection.Play();
}
else if (GetPilotRemainingSP() - ActiveSpirit.SPCost >= 0)//Activate Skill
{
if (ListSelectedSpirit.Count == 0 || (!ActiveSpirit.Target.MustBeUsedAlone && !ListSelectedSpirit.Last().Target.MustBeUsedAlone))
{
ListSelectedSpirit.Add(ActiveSpirit);
PilotSpiritActivation[ActiveUnitIndex][PilotIndex].Add(ActiveSpirit);
Map.sndSelection.Play();
}
}
else
{
Map.sndDeny.Play();
}
}
else
{
Map.sndDeny.Play();
}
}
#endregion
else if (InputHelper.InputConfirmPressed())
{
if (ActiveSpirit == null || !ActiveSpirit.IsUnlocked)
{
return;
}
if (ListSelectedSpirit.Count == 0)
{
if (ActiveSpirit.CanActivate && GetPilotRemainingSP() - ActiveSpirit.SPCost >= 0)
{
ListSelectedSpirit.Add(ActiveSpirit);
PilotSpiritActivation[ActiveUnitIndex][PilotIndex].Add(ActiveSpirit);
}
else
{
return;
}
}
if (ListSelectedSpirit[0].Range > 0)
{
List <Vector3> ListMVChoice = Map.ComputeRange(ActiveSquad.Position, 0, ListSelectedSpirit[0].Range);
List <MovementAlgorithmTile> ListTerrainChoice = new List <MovementAlgorithmTile>();
foreach (Vector3 ActiveTerrain in ListMVChoice)
{
ListTerrainChoice.Add(Map.GetTerrain(ActiveTerrain.X, ActiveTerrain.Y, (int)ActiveTerrain.Z));
}
Map.LayerManager.AddDrawablePoints(ListTerrainChoice, Color.FromNonPremultiplied(0, 128, 0, 190));
}
for (int U = 0; U < ActiveSquad.UnitsAliveInSquad; U++)
{
for (int C = 0; C < ActiveSquad[U].ArrayCharacterActive.Length; C++)
{
for (int S = 0; S < PilotSpiritActivation[U][C].Count; ++S)
{
Map.GlobalDeathmatchContext.SetContext(ActiveSquad, ActiveSquad[U], ActiveSquad[U].ArrayCharacterActive[C], null, null, null, Map.ActiveParser);
ManualSkill SpiritToActivate = PilotSpiritActivation[U][C][S];
//Consume SP and activate skills.
SpiritToActivate.ActiveSkillFromMenu(ActiveSquad[U].ArrayCharacterActive[C], ActiveSquad);
//Update skills activation to disable those who can't be used anymore.
SpiritToActivate.UpdateSkillActivation();
ListSelectedSpirit.Remove(SpiritToActivate);
PilotSpiritActivation[U][C].Remove(SpiritToActivate);
}
}
}
for (int P = 0; P < Map.ListPlayer.Count; ++P)
{
for (int S = 0; S < Map.ListPlayer[P].ListSquad.Count; ++S)
{
for (int U = 0; U < Map.ListPlayer[P].ListSquad[S].UnitsAliveInSquad; ++U)
{
Map.ActivateAutomaticSkills(Map.ListPlayer[P].ListSquad[S], Map.ListPlayer[P].ListSquad[S][U], string.Empty, Map.ListPlayer[P].ListSquad[S], Map.ListPlayer[P].ListSquad[S][U]);
}
}
}
Map.GlobalDeathmatchContext.SetContext(null, null, null, null, null, null, Map.ActiveParser);
Map.sndConfirm.Play();
}
else if (InputHelper.InputCancelPressed())
{
Map.CursorPosition = ActiveSquad.Position;
Map.CursorPositionVisible = Map.CursorPosition;
Map.sndCancel.Play();
RemoveScreen(this);
}
#region Move the Spirit Menu cursor
else if (InputHelper.InputUpPressed())
{//Move Spirit cursor down.
if (CursorIndex - 1 >= 0)
{
CursorIndex--;
Map.sndSelection.Play();
}
//End of Spirit list, move to last pilot.
else if (PilotIndex - 1 >= 0)
{
PilotIndex--;
CursorIndex = ActiveSquad[ActiveUnitIndex].ArrayCharacterActive[PilotIndex].ArrayPilotSpirit.Length - 1;
Map.sndSelection.Play();
}
}
else if (InputHelper.InputDownPressed())
{//Move Spirit cursor up.
if (CursorIndex + 1 < ActiveSquad[ActiveUnitIndex].ArrayCharacterActive[PilotIndex].ArrayPilotSpirit.Length)
{
CursorIndex++;
Map.sndSelection.Play();
}
//End of Spirit list, move to next pilot.
else if (PilotIndex + 1 < ActiveSquad[ActiveUnitIndex].ArrayCharacterActive.Length)
{
PilotIndex++;
CursorIndex = 0;
Map.sndSelection.Play();
}
}
else if (InputHelper.InputRightPressed())
{
if (ActiveUnitIndex < ActiveSquad.UnitsAliveInSquad - 1)
{
ActiveUnitIndex++;
PilotIndex = 0;
CursorIndex = 0;
}
}
else if (InputHelper.InputLeftPressed())
{
if (ActiveUnitIndex > 0)
{
ActiveUnitIndex--;
PilotIndex = 0;
CursorIndex = 0;
}
}
#endregion
}
