void Update()
{
if (battle == null)
{
battle = Object.FindObjectOfType <BattleGrid>();
}
if (whileUnitMove || whileUnitAction || whileAIControl)
{
ResetWandToUnit();
}
if (whileUnitMove && !battle.isMovingUnit)
{
OnMoveFinish();
}
if (whileUnitAction && !battle.isActingUnit)
{
OnActionFinish();
}
if (whileAIControl && !battle.isControllingUnit)
{
PassUnit();
}
KeyInputs();
UpdateUI();
}
public MoveAction(BattleSoldier soldier, BattleGrid grid, Tuple <int, int> newLocation, ConcurrentBag <MoveResolution> resultList)
{
_soldier = soldier;
_grid = grid;
_newLocation = newLocation;
_resultList = resultList;
}
public override HashSet <TileNode> GetSelectionTiles(BattleUnit user, BattleGrid battle)
{
HashSet <TileNode> set = new HashSet <TileNode>();
set.Add(battle.GetTile(user.GetPosKey()));
return(set);
}
//create cell dictionary
public NavmeshLayserSerializer(Dictionary <GeneralXZData, Graph> chunkData, Dictionary <XZPosInt, YRangeInt> chunkRangeData, AgentProperties properties)
{
int cellCounter = 0, bgpCounter = 0;
//creating cell dictionary cause connections are lead outside chunk
foreach (var graph in chunkData.Values)
{
if (graph.empty || graph.properties != properties)
{
continue;
}
targetGraphs.Add(graph);
foreach (var cell in graph.cells)
{
cells.Add(cell, cellCounter++);
}
BattleGrid bg = graph.battleGrid;
if (bg != null)
{
foreach (var p in bg.points)
{
bgIDs.Add(p, bgpCounter++);
}
}
}
}
//**************
//角色移动、入场
//**************
/// <summary>
/// 单位移动到某位置，返回目标位置坐标
/// </summary>
/// <returns>The move to.</returns>
public Vector2 UnitMoveTo(Vector2Int start, Vector2Int end)
{
mapGrids[start.x][start.y].Occupied = false;
mapGrids[end.x][end.y].Occupied = true;
standingGrid = mapGrids[end.x][end.y];
return(MapView.GetCellPosition(end.x, end.y));
}
///**************
//角色进入回合时的可行走状态
///**************
public void StartRound(BattleUnit unit)
{
standingGrid = mapGrids[unit.Position.x][unit.Position.y];
targetGrid = standingGrid;
//重置一下可到达状态
if (walkableRange != null)
{
for (int i = 0; i < walkableRange.Count; i++)
{
GetBattleGridByPos(walkableRange[i].Position).Reachable = false;
}
}
walkableRange = CircleTargets(unit.Steps);
//改变可到达状态
for (int i = 0; i < walkableRange.Count; i++)
{
GetBattleGridByPos(walkableRange[i].Position).Reachable = true;
//参数传递过程中，新建了BattleGrid
//walkableRange[i].Reachable = true;
//Debug.Log(walkableRange[i].Position + " Reachable = true");
//Debug.Log(GetBattleGridByPos(walkableRange[i].Position).Position + " Reachable = " + GetBattleGridByPos(walkableRange[i].Position).Reachable);
}
MapView.SetWalkingState(standingGrid, walkableRange);
}
List <BattleGrid> GetFanNeighbour(BattleGrid grid, List <GridDirection> directions)
{
List <BattleGrid> grids = new List <BattleGrid>();
if (directions.Contains(GridDirection.LeftUp))
{
GetGridByDirection(grid, GridDirection.LeftUp);
}
if (directions.Contains(GridDirection.LeftDown))
{
GetGridByDirection(grid, GridDirection.LeftDown);
}
if (directions.Contains(GridDirection.RightUp))
{
GetGridByDirection(grid, GridDirection.RightUp);
}
if (directions.Contains(GridDirection.RightDown))
{
GetGridByDirection(grid, GridDirection.RightDown);
}
if (directions.Contains(GridDirection.Up))
{
GetGridByDirection(grid, GridDirection.Up);
}
if (directions.Contains(GridDirection.Down))
{
GetGridByDirection(grid, GridDirection.Down);
}
return(grids);
}
//**************
//初始化地图
//**************
public void InitBattleMap()
{
if (!isExist)
{
mapGrids = new BattleGrid[DefaultConfigs.BattleMapSize.x][];
for (int i = 0; i < mapGrids.Length; i++)
{
mapGrids[i] = new BattleGrid[DefaultConfigs.BattleMapSize.y];
for (int j = 0; j < mapGrids[i].Length; j++)
{
mapGrids[i][j] = new BattleGrid(i, j);
}
}
MapView.InitBattleMapView();
isExist = true;
}
else
{
for (int i = 0; i < mapGrids.Length; i++)
{
for (int j = 0; j < mapGrids[i].Length; j++)
{
mapGrids[i][j].Occupied = false;
mapGrids[i][j].Reachable = false;
}
}
}
//standingGrid = mapGrids[0][0];
//targetGrid = mapGrids[0][0];
}
/// <summary>
/// Sets up the game resources.
/// </summary>
public void CreateGame()
{
_shotCount = 0;
_ships.Clear();
_grid = _factory.CreateGrid(_gridSize);
}
/// <summary>
/// 找到离目标最近的移动点
/// </summary>
public Vector2Int GetMovingTargetPos(BattleUnit unit, Vector2Int targetPos)
{
standingGrid = mapGrids[unit.Position.x][unit.Position.y];
targetGrid = standingGrid;
walkableRange = CircleTargets(unit.Steps);
int distance = 0;
int temp;
int index = 0;
bool isStraight;
bool tempStraight;
distance = MathCalculator.GetBattleGridDistance(targetPos, walkableRange[0].Position, out isStraight);
Debug.Log("Total range = " + walkableRange.Count + "," + walkableRange[0].Position + "," + distance + "," + isStraight);
for (int i = 1; i < walkableRange.Count; i++)
{
Debug.Log(walkableRange[i].Position + "," + walkableRange[i].Walkable);
if (!walkableRange[i].Walkable)
{
continue;
}
temp = MathCalculator.GetBattleGridDistance(targetPos, walkableRange[i].Position, out tempStraight);
Debug.Log(walkableRange[i].Position + "," + distance + "," + isStraight);
if (temp < distance || (!isStraight && tempStraight))
{
distance = temp;
isStraight = tempStraight;
index = i;
}
}
return(walkableRange[index].Position);
}
void Start()
{
grid = FindObjectOfType <BattleGrid>();
PlayerStatsControl stats = FindObjectOfType <PlayerStatsControl>();
if (stats.nzona == 0)
{
SpriteRenderer campoBattaglia = GameObject.Find("CampoBattaglia").GetComponent <SpriteRenderer>();
campoBattaglia.sprite = campiBattaglia[0];
}
if (stats.nzona == 1)
{
SpriteRenderer campoBattaglia = GameObject.Find("CampoBattaglia").GetComponent <SpriteRenderer>();
campoBattaglia.sprite = campiBattaglia[1];
}
if (stats.nzona == 2)
{
SpriteRenderer campoBattaglia = GameObject.Find("CampoBattaglia").GetComponent <SpriteRenderer>();
campoBattaglia.sprite = campiBattaglia[2];
}
if (stats.nzona == 3)
{
SpriteRenderer campoBattaglia = GameObject.Find("CampoBattaglia").GetComponent <SpriteRenderer>();
campoBattaglia.sprite = campiBattaglia[3];
}
if (stats.nzona == 4)
{
SpriteRenderer campoBattaglia = GameObject.Find("CampoBattaglia").GetComponent <SpriteRenderer>();
campoBattaglia.sprite = campiBattaglia[4];
}
}
//static void MakeAttackZone(Hero hero, Hero initialTarget, out List<Hero> targets, List<Hero> enemyList)
//{
// targets = new List<Hero>();
// int place;
// if (initialTarget != null)
// {
// place = Mathf.Clamp(initialTarget.mySlot.myPlace, 1, 3);
// } else {
// place = Mathf.Clamp(enemyList[0].mySlot.myPlace, 1, 3); //default behaviour, change later to attack lowest max HP target
// }
// //make into square-shape target function
// TryAddTarget(AIenemies.GetSlotByCoord(1, place));
// TryAddTarget(AIenemies.GetSlotByCoord(2, place));
// ++place;
// TryAddTarget(AIenemies.GetSlotByCoord(1, place));
// TryAddTarget(AIenemies.GetSlotByCoord(2, place));
//}
//static void MakeBuffZone(Hero hero, Hero initialTarget, out List<Hero> targets)
//{
// targets = new List<Hero>();
// int place = 0;
// if (initialTarget != null)
// {
// place = Mathf.Clamp(initialTarget.mySlot.myPlace, 1, 3);
// }
// else
// {
// Debug.LogError("unintended AI solution");
// return;
// }
// //make into square-shape target function
//}
static void CubicalTarget(BattleGrid grid, Hero initialTarget, out List <Hero> targets)
{
targets = new List <Hero>();
int place = 0;
if (initialTarget != null)
{
place = Mathf.Clamp(initialTarget.mySlot.myPlace, 1, 3);
}
else
{
Debug.LogError("unintended AI solution");
return;
}
List <Slot> slots = new List <Slot>();
slots.Add(grid.GetSlotByCoord(1, place));
slots.Add(grid.GetSlotByCoord(2, place));
place++;
slots.Add(grid.GetSlotByCoord(1, place));
slots.Add(grid.GetSlotByCoord(2, place));
ExtractSlotHeroes(slots, out targets);
}
//func about how to spawn characters based on array of IDs
void SpawnChars(int[] IDsArray, BattleGrid currentGrid, out List <Hero> list)
{
list = new List <Hero>();
int currentHeroID;
heroSpawnRotation = CharPrefab.transform.rotation;
for (int index = 0; index < IDsArray.Length; index++)
{
if (IDsArray[index] > 0)
{
currentHeroID = IDsArray[index];
CharPrefab = elementDict[currentHeroID];
GameObject character = Instantiate(
CharPrefab,
new Vector3(currentGrid.Slots[index].XworldPos, 4f, currentGrid.Slots[index].ZworldPos),
heroSpawnRotation
);
Hero currentHero = character.GetComponent <Hero>();
currentHero.HeroID = currentHeroID;
currentHero.Initiate();
currentHero.mySlot = currentGrid.Slots[index];
currentGrid.Slots[index].myHero = currentHero;
list.Add(currentHero);
turnList.Add(currentHero);
}
}
}
public void Init(int x, int y, BattleGrid grid, BattleGrid.pieceType type)
{
this.x = x;
this.y = y;
this.grid = grid;
this.type = type;
this.clearType = (int)ClearTypeEnum.NONE;
}
public override HashSet <TileNode> GetSelectionTiles(BattleUnit user, BattleGrid battle)
{
TileNode center = battle.GetTile(user.GetPosKey());
return(new HashSet <TileNode>()
{
center
});
}
public void SetSelectingState(BattleGrid standingPoint, List <BattleGrid> selectingRange)
{
//Debug.Log("Set Targeting State");
temp = selectingRange;
for (int i = 0; i < selectingRange.Count; i++)
{
GetCellImageByBattleUnit(selectingRange[i]).sprite = selecting;
}
}
void Update()
{
if (battle == null)
{
battle = Object.FindObjectOfType <BattleGrid>();
}
MoveWand();
}
public override void ApplyAction(TileNode target, BattleGrid battle)
{
BattleUnit bu = battle.GetUnit(target.GetPos());
if (bu != null)
{
bu.unit.ApplyDamage(20);
}
}
public void Initiate()
{
myGrid = new BattleGrid(side, gridPlaces, gridRows);
gridWidth = upperRuler.transform.position.x - lowerRuler.transform.position.x;
gridHeight = upperRuler.transform.position.z - lowerRuler.transform.position.z;
slotHalfWidth = (gridWidth / myGrid.rows) / 2;
slotHalfHeight = (gridHeight / myGrid.placesInRows) / 2;
}
// Use this for initialization
void Start()
{
pos = transform.position;
tr = transform;
music = GetComponent <AudioSource>();
bg = GameObject.FindGameObjectWithTag("BattleArea").GetComponent <BattleGrid>();
shoot = Resources.Load("Music/shoot1") as AudioClip;
damage = Resources.Load("Music/Hit1") as AudioClip;
battleChip = GetComponent <BattleChip>();
}
public override void QStart(BattleManager manager)
{
m_Grid = manager.grid;
BattleActor actor = m_Grid[m_Source.x, m_Source.y].Actor;
m_Actor = actor.transform;
// set animation
actor.Agent.Direction = Mathf.Atan2(-m_Direction.x, -m_Direction.y) * 180f / Mathf.PI;
actor.Sprite.Animation = "walk";
}
public SerializedBattleGrid(NavmeshLayserSerializer ns, BattleGrid bg)
{
lengthX = bg.lengthX;
lengthZ = bg.lengthZ;
points = new List <SerializedBattleGridPoint>();
foreach (var p in bg.points)
{
points.Add(new SerializedBattleGridPoint(ns, p));
}
}
public void Awake()
{
if (instance == null)
{
instance = this;
}
else
{
Destroy(gameObject);
}
}
List <BattleGrid> GetNeighbour(BattleGrid grid)
{
return(new List <BattleGrid>
{
GetGridByDirection(grid, GridDirection.LeftUp),
GetGridByDirection(grid, GridDirection.LeftDown),
GetGridByDirection(grid, GridDirection.RightUp),
GetGridByDirection(grid, GridDirection.RightDown),
GetGridByDirection(grid, GridDirection.Up),
GetGridByDirection(grid, GridDirection.Down)
});
}
/* --------------------------------------------------------------------- */
#region Construction
#endregion
/* --------------------------------------------------------------------- */
#region Unity Methods
// Use this for initialization
void Start()
{
_livingUnits = FindObjectsOfType <BattleUnit>().ToList();;
_turnOrder = new Queue <Turn>();
_waitTurnOrder = new Queue <Turn>();
_battleGrid = FindObjectOfType <BattleGrid>();
_battleTurnGui = new BattleTurnGUI(_turnPanel);
GenerateTurnOrder();
}
public void GivenNewGridCalledWhenSizeIsZeroThenCellsCountCorrect()
{
// Arrange
var sut = new BattleGrid(0);
// Act
var result = sut.Cells;
// Assert
Assert.NotNull(result);
Assert.Empty(result);
}
public BattleGridControl()
{
InitializeComponent();
int i;
for (i = 0; i < BattleGrid.ROWS; i++)
{
layout.RowDefinitions.Add(new RowDefinition()
{
Height = new GridLength(20)
});
}
for (i = 0; i < BattleGrid.COLS; i++)
{
layout.ColumnDefinitions.Add(new ColumnDefinition()
{
Width = new GridLength(20)
});
}
for (i = 0; i < BattleGrid.ROWS; i++)
{
for (int j = 0; j < BattleGrid.COLS; j++)
{
Rectangle r = new Rectangle()
{
HorizontalAlignment = System.Windows.HorizontalAlignment.Stretch, VerticalAlignment = System.Windows.VerticalAlignment.Stretch, Stroke = Brushes.White, StrokeThickness = 1, Fill = Brushes.Blue
};
layout.Children.Add(r);
Grid.SetRow(r, i);
Grid.SetColumn(r, j);
}
}
BattleGrid g = new BattleGrid();
// Ajout de bateaux
g.NewGrid();
// Tirs
for (i = 0; i < 10; i++)
{
g.Shoot(2, i);
g.Shoot(3, i);
}
g.Shoot(6, 2);
g.Shoot(1, 1);
g.Shoot(4, 1);
g.Shoot(1, 4);
// Draw
this.Draw(g);
}
/// <summary>
/// 设置进入回合行走时格子的状态
/// </summary>
public void SetWalkingState(BattleGrid standingPoint, List <BattleGrid> walkableRange)
{
temp = walkableRange;
for (int i = 0; i < walkableRange.Count; i++)
{
if (!walkableRange[i].Occupied)
{
GetCellImageByBattleUnit(walkableRange[i]).sprite = walkable;
}
}
GetCellImageByBattleUnit(standingPoint).sprite = standard;
}
public void GivenNewGridCalledWhenSizeIsValidThenCellsCountCorrect()
{
// Arrange
var sut = new BattleGrid(10);
// Act
var result = sut.Cells;
// Assert
Assert.NotNull(result);
Assert.Equal(100, result.Length);
}
void writeGrid(Affiliation x, BattleGrid grid)
{
switch (x)
{
case Affiliation.Ally:
TurnComponent.Instance.TeamOneGrid = grid;
break;
case Affiliation.Enemy:
TurnComponent.Instance.TeamTwoGrid = grid;
break;
}
}
