private Vector2 LongShot(Player target, int maxDist, int minDist)
{
Vector2 targetPos = target.transform.position;
int playerToTarget = BoardSpec.GetSquareDistance(main.transform.position, targetPos);
if (maxDist > playerToTarget)
{
while ((maxDist - playerToTarget) > 2)
{
maxDist--;
}
}
List <Vector2> posicoesPossiveis = CirclePos(maxDist - 1, targetPos);
List <GameObject> players = new List <GameObject>(gameObjects.FindAll(gameObject => !gameObject.GetComponent <Player>().status.isDead || gameObject.GetComponent <Player>().isAliado));
Vector2 idealPos = new Vector2();
int idealDistance = -1;
foreach (Vector2 pos in posicoesPossiveis)
{
int cont = players.FindAll(gameObject => BoardSpec.GetSquareDistance(gameObject.transform.position, pos) < minDist).Count;
if (cont == players.Count)
{
int distance = BoardSpec.GetSquareDistance(pos, main.transform.position);
int distanceTarget = BoardSpec.GetSquareDistance(pos, targetPos);
if (distanceTarget <= maxDist && (idealDistance < 0 || distance < idealDistance))
{
idealPos = pos;
idealDistance = distance;
}
}
}
if (idealDistance > 0)
{
return(idealPos);
}
foreach (Vector2 pos in posicoesPossiveis)
{
int distance = BoardSpec.GetSquareDistance(pos, main.transform.position);
if (idealDistance < 0 || distance < idealDistance)
{
idealPos = pos;
idealDistance = distance;
}
}
return(idealPos);
}
private void setOrder(List <GameObject> playerObjects)
{
gameObjects = new List <GameObject>();
BoardSpec boardSpec = BoardSpec.getInstance();
Square mainSquare = boardSpec.SquareFromWorldPoint(main.transform.position);
var items = new Dictionary <GameObject, int>();
foreach (GameObject playerObject in playerObjects)
{
Player target = playerObject.GetComponent <Player>();
Square targetSquare = boardSpec.SquareFromWorldPoint(target.transform.position);
int distancia = BoardSpec.GetDistance(mainSquare, targetSquare);
items.Add(playerObject, distancia);
}
foreach (var item in items.OrderBy(i => i.Value))
{
gameObjects.Add(item.Key);
}
}
private List <Vector2> CirclePos(int radius, Vector2 targetPos)
{
List <Vector2> posicoesPossiveis = new List <Vector2>();
int qtdPosicoes = radius * 4;
double slice = 360 / 12;
BoardSpec boardSpec = BoardSpec.getInstance();
for (int i = 0; i < qtdPosicoes; i++)
{
double angle = slice * i;
double newX = targetPos.x + radius * Math.Cos(angle * (Math.PI / 180));
double newY = targetPos.y + radius * Math.Sin(angle * (Math.PI / 180));
Vector2 p = new Vector2((int)Math.Round(newX), (int)Math.Round(newY));
if (p.x < 0 || p.y < 0 || p.x >= boardSpec.columns || p.y >= boardSpec.rows)
{
continue;
}
posicoesPossiveis.Add(p);
}
return(posicoesPossiveis);
}
public IEnumerator CalcularPossibleAttacks()
{
BoardSpec boardSpec = BoardSpec.getInstance();
foreach (GameObject gameObject in gameObjects)
{
Player target = gameObject.GetComponent <Player>();
if (target != null && target.status.isDead)
{
continue;
}
Square mainSquare = boardSpec.SquareFromWorldPoint(main.transform.position);
Square targetSquare = boardSpec.SquareFromWorldPoint(target.transform.position);
int distanciaEstimadaInimigo = BoardSpec.GetSquareDistance(mainSquare, targetSquare);
//Ataque Basico
if (target.isAliado)
{
CheckPossibleAttack(target, null, distanciaEstimadaInimigo);
}
List <Habilidade> habilidades = main.action.Habilidades.habilidades;
foreach (Habilidade habilidade in habilidades)
{
if (habilidade.custoPontoAcao > pontosDeAcao || habilidade.IsOfensiva && !target.isAliado || habilidade.custoSp > main.status.mana)
{
continue;
}
if (habilidade.minDistancia == 0 && habilidade.maxDistancia == 0 && target.name != main.name)
{
continue;
}
CheckPossibleAttack(target, habilidade, distanciaEstimadaInimigo);
}
yield return(null);
}
Pathfinding pathfinding = null;
List <Vector2> moves = null;
bool apenasMovimenta = true;
if (possibleAttacks.Count > 0)
{
apenasMovimenta = false;
Player target = null;
int cont = 0;
int totalCost = 0;
MyDictionary dict = new MyDictionary();
PossibleAttack greatestAttack = null;
foreach (PossibleAttack possibleAttack in possibleAttacks)
{
if (target == null || target.name != possibleAttack.targetName || possibleAttack.isRanged)
{
target = possibleAttack.Target;
pathfinding = new Pathfinding();
Vector2 pos = new Vector2();
if (possibleAttack.isRangedInDanger)
{
pos = RunAndGun(target, possibleAttack.minDist);
}
else if (possibleAttack.isRanged)
{
pos = LongShot(target, possibleAttack.maxDist, possibleAttack.minDist);
}
else
{
pos = target.transform.position;
}
pathfinding.FindPath(main.transform.position, pos);
yield return(new WaitUntil(() => pathfinding.ready));
moves = pathfinding.getMoveInstructions();
yield return(null);
}
// verificar se distancia no pathfinder é diferente que distanciaEstimada - 1, pois não conta o quadrado do alvo
if ((possibleAttack.distanciaEstimada - 1) != moves.Count)
{
possibleAttack.distanciaEstimada = pathfinding.minSize;
possibleAttack.CalcularCustoPontoAcaoEstimado();
if (possibleAttack.actionPointCost <= pontosDeAcao)
{
possibleAttack.CalcularCusto(dificuldade);
}
else
{
cont++;
continue;
}
}
possibleAttack.moves = moves;
dict.Add(cont, totalCost + 1, totalCost + possibleAttack.cost, possibleAttack, possibleAttack.cost);
totalCost += possibleAttack.cost;
cont++;
if (greatestAttack == null || greatestAttack.cost < possibleAttack.cost)
{
greatestAttack = possibleAttack;
}
}
if (dict.Count != 0 && totalCost > 0)
{
yield return(null);
if (dificuldade.Equals(Dificuldade.MEDIO))
{
bool continueLoop = true;
int cost = 60;
while (continueLoop)
{
var listPossibleAttack = dict.Where(myval => myval.Value.cost >= cost);
if (listPossibleAttack != null && listPossibleAttack.Count() > 0)
{
continueLoop = false;
dict = new MyDictionary();
cont = 0;
int newTotalCost = 0;
foreach (KeyValuePair <int, MyValue> item in listPossibleAttack.ToList())
{
dict.Add(cont, newTotalCost + 1, newTotalCost + item.Value.cost, item.Value.possibleAttack, item.Value.cost);
newTotalCost = item.Value.cost;
cont++;
}
totalCost = newTotalCost;
}
else
{
cost -= 10;
}
}
}
if (!dificuldade.Equals(Dificuldade.DIFICIL))
{
int random = Random.Range(1, totalCost);
try {
// Pega lista
IEnumerable <KeyValuePair <int, MyValue> > asd = dict.Where(myval => myval.Value.pos1 <= random && myval.Value.pos2 >= random);
var itens = asd.ToList();
// Pega primeiro item da lista, pois a lista possui apenas 1 item
ataqueEscolhido = itens[0].Value.possibleAttack;
} catch (Exception e) {
Debug.Log(e);
Debug.Log(e.Message);
Debug.Log(e.Data);
yield break;
}
}
else
{
ataqueEscolhido = greatestAttack;
}
if (ataqueEscolhido == null)
{
apenasMovimenta = true;
}
else
{
foreach (Vector2 position in ataqueEscolhido.moves)
{
main.move.NpcMove((int)position.x, (int)position.y);
}
main.move.Move();
yield return(null);
if (ataqueEscolhido.isBasicAttack)
{
main.action.Attack(ataqueEscolhido.targetName);
}
else
{
main.action.Ability(ataqueEscolhido.habilidade.nome, ataqueEscolhido.targetName);
}
yield return(null);
}
}
else
{
apenasMovimenta = true;
}
}
if (apenasMovimenta)
{
int qtyMoves = -1;
foreach (GameObject gameObject in gameObjects)
{
Player target = gameObject.GetComponent <Player>();
if (target != null && (target.status.isDead || !target.isAliado))
{
continue;
}
pathfinding = new Pathfinding();
pathfinding.FindPath(main.transform.position, target.transform.position);
yield return(new WaitUntil(() => pathfinding.ready));
if (qtyMoves == -1 || qtyMoves > pathfinding.minSize)
{
qtyMoves = pathfinding.minSize;
moves = pathfinding.getMoveInstructions();
}
yield return(null);
}
if (moves != null)
{
foreach (Vector2 position in moves)
{
main.move.NpcMove((int)position.x, (int)position.y);
}
main.move.Move();
}
}
yield break;
}
public void PrepareInstances(List <ShapeInstance> Instances, BoardSpec BS, bool showtext = true)
{
Colors[LayerSpec.ParseLayer("PADS", BS.Layers, LayerType.Copper)] = PADColor;
Colors[LayerSpec.ParseLayer("1", BS.Layers)] = CopperColor;
Colors[LayerSpec.ParseLayer("TOPCOPPER", BS.Layers, LayerType.Copper)] = CopperColor;
Colors[LayerSpec.ParseLayer("BOTHCOPPER", BS.Layers, LayerType.Copper)] = CopperColor;
Colors[LayerSpec.ParseLayer("BOTTOMCOPPER", BS.Layers, LayerType.Copper)] = CopperColor;
Colors[LayerSpec.ParseLayer("DRILL", BS.Layers)] = DrillColor;
Colors[LayerSpec.ParseLayer("DRILLS", BS.Layers)] = DrillColor;
/*Colors[LayerSpec.ParseLayer("16", BS.Layers)] = CopperColor;
* Colors[LayerSpec.ParseLayer("21", BS.Layers)] = SilkColor;
* Colors[LayerSpec.ParseLayer("51", BS.Layers)] = DocuColor;
* Colors[LayerSpec.ParseLayer("52", BS.Layers)] = DocuColor;
* Colors[LayerSpec.ParseLayer("22", BS.Layers)] = SilkColor;
* Colors[LayerSpec.ParseLayer("25", BS.Layers)] = SilkColor;
* Colors[LayerSpec.ParseLayer("26", BS.Layers)] = SilkColor;
* Colors[LayerSpec.ParseLayer("27", BS.Layers)] = SilkColor;
* Colors[LayerSpec.ParseLayer("28", BS.Layers)] = SilkColor;
* Colors[LayerSpec.ParseLayer("94", BS.Layers)] = SymbolsColor;*/
foreach (var a in BS.Layers)
{
switch (a.type)
{
case LayerType.Copper: Colors[a] = CopperColor; break;
case LayerType.Silk: Colors[a] = SilkColor; break;
case LayerType.Docu: Colors[a] = DocuColor; break;
case LayerType.Drill: Colors[a] = DrillColor; break;
}
}
LayerPriority[LayerSpec.ParseLayer("21", BS.Layers)] = 100;
LayerPriority[LayerSpec.ParseLayer("22", BS.Layers)] = 100;
LayerPriority[LayerSpec.ParseLayer("25", BS.Layers)] = 100;
LayerPriority[LayerSpec.ParseLayer("26", BS.Layers)] = 100;
LayerPriority[LayerSpec.ParseLayer("27", BS.Layers)] = 100;
LayerPriority[LayerSpec.ParseLayer("28", BS.Layers)] = 100;
LayerPriority[LayerSpec.ParseLayer("51", BS.Layers)] = 101;
LayerPriority[LayerSpec.ParseLayer("52", BS.Layers)] = 101;
LayerPriority[LayerSpec.ParseLayer("DRILL", BS.Layers)] = 200;
LayerPriority[LayerSpec.ParseLayer("DRILLS", BS.Layers)] = 200;
LayerPriority[LayerSpec.ParseLayer("TOPCOPPER", BS.Layers, LayerType.Copper)] = 90;
LayerPriority[LayerSpec.ParseLayer("BOTTOMCOPPER", BS.Layers, LayerType.Copper)] = 90;
LayerPriority[LayerSpec.ParseLayer("BOTHCOPPER", BS.Layers, LayerType.Copper)] = 90;
int count = 0;
int vertexcount = 0;
foreach (var I in Instances)
{
if (I.Bounds == null)
{
I.Bounds = GetInstanceBounds(I);
}
var ThePackage = I.TheShape;
foreach (var a in ThePackage.Shapes)
{
LayerSpec layer = a.GetLayer();
if (Layers.ContainsKey(layer) == false)
{
Layers[layer] = 1;
if (LayerPriority.ContainsKey(layer))
{
Layers[layer] = LayerPriority[layer];
}
ShapeLists[layer] = new List <List <Tuple <SchematicNet, List <PointF> > > >();
count++;
}
}
Matrix R = new Matrix();
R.Translate((float)I.Position.X, (float)I.Position.Y);
if (I.TopSide == false)
{
R.Scale(-1, 1);
}
R.Rotate((float)I.Rotation);
foreach (var a in ThePackage.Shapes)
{
SchematicNet ShapeSignal = null;
if (I.Placement != null && I.Placement.Pins.ContainsKey(a.Name))
{
ShapeSignal = I.Placement.Pins[a.Name].signal;
}
var DBP = a.GetDebugPoints().ToArray();
var PolySet = new List <Tuple <SchematicNet, List <PointF> > >();
bool process = true;
if (a as TextShape != null && showtext == false)
{
process = false;
}
if (process)
{
foreach (var Ps in a.GetPolygons())
{
double minx = 0;
double miny = 0;
double maxx = 0;
double maxy = 0;;
var P = Ps.ToArray();
for (int i = 0; i < P.Count(); i++)
{
PointF[] rotP = { new PointF(P[i].X, P[i].Y) };
R.TransformPoints(rotP);
P[i].X = rotP[0].X;
P[i].Y = rotP[0].Y;
Bounds.FitPoint(P[i].X, P[i].Y);
if (vertexcount == 0)
{
minx = maxx = P[i].X;
miny = maxy = P[i].Y;
}
else
{
if (P[i].X < minx)
{
minx = P[i].X;
}
else if (P[i].X > maxx)
{
maxx = P[i].X;
}
if (P[i].Y < miny)
{
miny = P[i].Y;
}
else if (P[i].Y > maxy)
{
maxy = P[i].Y;
}
}
vertexcount++;
}
I.Centroid = new PointF((float)(minx + maxx) / 2, (float)(miny + maxy) / 2);
PolySet.Add(new Tuple <SchematicNet, List <PointF> >(ShapeSignal, P.ToList()));
}
}
if (StringsPerLayer.ContainsKey(a.GetLayer()) == false)
{
StringsPerLayer[a.GetLayer()] = new List <DisplayString>();
}
foreach (var ds in a.DisplayStrings)
{
StringsPerLayer[a.GetLayer()].Add(new DisplayString()
{
alignment = ds.alignment, size = ds.size, x = ds.x + I.Position.X, Text = ds.Text, y = ds.y + I.Position.Y
});
}
ShapeLists[a.GetLayer()].Add(PolySet);
for (int i = 0; i < DBP.Count(); i++)
{
DBP[i].X += I.Position.X;
DBP[i].Y += I.Position.Y;
}
debugpoints.AddRange(DBP.ToList());
}
}
if (count == 0)
{
return;
}
foreach (var l in ShapeLists.Values)
{
foreach (var k in l)
{
foreach (var q in k)
{
foreach (var p in q.Item2)
{
Bounds.FitPoint(p.X, p.Y);
}
}
}
}
}
