public void AutoSplitPlayerCell(PlayerCell cell)
{
var minSplit = Settings.playerMaxSize * Settings.playerMaxSize;
var cellsLeft = 1 * Settings.playerMaxCells - cell.owner.ownedCells.Count;
var overflow = (float)Math.Ceiling(cell.SquareSize / minSplit);
if (overflow == 1 || cellsLeft <= 0)
{
return;
}
var splitTimes = (int)Math.Min(overflow, cellsLeft);
var splitSize = (float)Math.Min(Math.Sqrt(cell.SquareSize / splitTimes), Settings.playerMaxSize);
var random = new Random();
for (int i = 1; i < splitTimes; i++)
{
var angle = (float)(random.NextDouble() * 2 * Math.PI);
LaunchPlayerCell(cell, splitSize, new Boost
{
dx = (float)Math.Sin(angle),
dy = (float)Math.Cos(angle),
d = Settings.playerSplitBoost
});
}
cell.Size = splitSize;
}
private void HandlePlayer(Point currentPoint, Color dotColor, Color[] colorData, Level level)
{
Point position = GetCenterPoint(currentPoint, dotColor, colorData);
PlayerCell player = new PlayerCell(PlayWindow, PointToPosition(position));
level.SetPlayer(player);
}
// Layout interface
public void LayoutInterface(int newPlayer)
{
// Set interface
playerIndex = newPlayer;
// Get player
GamePlayer player = null;
if (playerIndex >= 0 && GameManager.instance.players != null && playerIndex < GameManager.instance.players.Count)
{
player = GameManager.instance.players[playerIndex];
}
// Get character
GameCharacter character = null;
if (player != null && player.characterIndex >= 0 && player.characterIndex < GameManager.instance.gameData.characters.Length)
{
character = GameManager.instance.gameData.characters[player.characterIndex];
}
// Set character icon & tints
characterName.text = character == null ? "???" : character.characterName;
PlayerCell.SetCharacterIcon(characterIcon, character == null ? null : character.characterIconTexture);
foreach (Image t in characterTintables)
{
t.color = GameManager.instance.GetPlayerColor(playerIndex);
}
// Set Default Score
LayoutScore();
// Set animation items
playerPosition = _rect.anchoredPosition;
Animate(true);
}
private void CurrentTurn_LoadPlayerPositionEvent(PlayerCell playerCell)
{
Cell lastPosition = PlayerCell.LastTurnPosition;
PlayerCell = playerCell;
PlayerCell.LastTurnPosition = lastPosition;
PlayerCell.DetermineFacing();
}
private void LoadLevel(String file)
{
World.Clear();
GoodCellList.Clear();
VirusList.Clear();
_level = _levelParser.Parse(Texture2D.FromStream(Game1.graphics.GraphicsDevice, new FileStream(file, FileMode.Open)));
_wallList = _level.GetWalls();
foreach (var item in _level.GetFriendlies())
{
GoodCellList.Add((GoodCell)item);
}
foreach (var item in _level.GetEnemies())
{
VirusList.Add((Virus)item);
}
_objectList = _level.GetFriendlies();
_objectList.AddRange(_level.GetEnemies());
_player = _level.Player;
}
public static Line[] VerLines(FieldContext gameProcess, PlayerCell flag)
{
Line[] ArrVer = new Line[(gameProcess.QuanRows) * (gameProcess.QuanCols)];
int N = 1;
for (int j = 0; j < gameProcess.QuanCols; j++)
{
Line a = EmptyLine;
a.length = 0;
a.y_coor = j;
for (int i = 0; i < gameProcess.QuanRows; i++)
{
PlayerCell d = gameProcess.Field[i, j];
if (d == flag)
{
if (a.length == 0)
{
a.x_coor = i;
}
a.length++;
}
if ((d != flag || i == 2 * gameProcess.N - 2) && a.length != 0)
{
ArrVer[N++] = a;
a.length = 0;
}
}
}
ArrVer[0].length = N;
return(ArrVer);
}
public void MakeStep(int col, FieldContext gameProcess, PlayerCell first)
{
int k = 0;
for (int i = 0; i < 2 * gameProcess.N - 1; i++)
{
k += gameProcess.FreePositions[i];
}
if (k == 1)
{
if (gameProcess.Field[0, gameProcess.N] == PlayerCell.Hero)
{
gameProcess.Field[gameProcess.FreePositions[gameProcess.N - 1], gameProcess.N - 1] = PlayerCell.Antagonist;
gameProcess.FreePositions[gameProcess.N - 1]++;
}
else
{
gameProcess.Field[gameProcess.FreePositions[gameProcess.N], gameProcess.N] = PlayerCell.Antagonist;
gameProcess.FreePositions[gameProcess.N]++;
}
}
else
{
Win a = new Win(0);
StepScore s = Minimax(gameProcess, first, PlayerCell.Antagonist, 0, -1, a);
col = s.Step;
gameProcess.FillField(col, PlayerCell.Antagonist);
}
k++;
}
// Reload cell
private void ReloadCell(int playerIndex)
{
Transform child = playerTable.GetChild(playerIndex);
PlayerCell cell = child.GetComponent <PlayerCell>();
cell.SetPlayer(playerIndex);
}
public void SpawnPlayer(Player player, PointF pos, float size)
{
var playerCell = new PlayerCell(player, pos.X, pos.Y, size);
AddCell(playerCell);
player.UpdateState(PlayerState.Alive);
}
public bool CheckSupportee(PlayerCell cell)
{
if (Vector3.SqrMagnitude(cell.transform.position - this.transform.position) < tetherRange * tetherRange)
{
return(true);
}
return(false);
}
static public void LoadContent(GraphicsDevice graphicsDevice)
{
PlayerCell.LoadContent(graphicsDevice);
GoodCell.LoadContent(graphicsDevice);
Virus.LoadContent(graphicsDevice);
BackgroundObjectsHandler.LoadContet();
Wall.LoadContent();
}
/// <summary>
/// Checks for collision between enemies and player cells
/// </summary>
/// <param name="enemy">Enemy cell to be checked</param>
/// <param name="player">Nearest Player Cell</param>
public void CheckCollide(EnemyCell enemy, PlayerCell player)
{
if (Vector3.SqrMagnitude(enemy.transform.position - player.transform.position) <= enemy.GetComponent <CircleCollider2D>().radius / 20)
{
Debug.Log(Vector3.SqrMagnitude(enemy.transform.position - player.transform.position));
enemy.isStopped = true;
player.isStopped = true;
player.SetKillTimer(enemy.type);
}
}
/// <summary>
/// Default Constructor
/// </summary>
public Sensor()
{
CurrentTurn = new World();
CurrentTurn.LoadOpponentPositionEvent += new LoadOpponentPositionEventHandler(CurrentTurn_LoadOpponentPositionEvent);
CurrentTurn.LoadPlayerPositionEvent += new LoadPlayerPositionEventHandler(CurrentTurn_LoadPlayerPositionEvent);
LastTurn = new World();
LastTurn.LoadOpponentPositionEvent += new LoadOpponentPositionEventHandler(LastTurn_LoadOpponentPositionEvent);
LastTurn.LoadPlayerPositionEvent += new LoadPlayerPositionEventHandler(LastTurn_LoadPlayerPositionEvent);
PlayerCell = new PlayerCell();
OpponentCell = new OpponentCell();
}
private static long HeuristicLineAntagonist(Line[] arr, int n, PlayerCell first, PlayerCell flag)
{
long sum = 0;
for (int i = 1; i < arr[0].length; i++)
{
sum += factorial(arr[i].length + 2);
}
return(sum);
}
public void GetFromConsoleUserStep(FieldContext gameProcess, PlayerCell first)
{
string a = Console.ReadLine();
int col = 0;
for (int i = 0; i < a.Length; i++)
{
col *= 10;
int c = a[i] - '0';
col += c;
}
MakeStep(col, gameProcess, first);
}
public void LaunchPlayerCell(PlayerCell cell, float size, Boost boost)
{
cell.SquareSize -= size * size;
var X = cell.X + 20 * boost.dx;
var Y = cell.Y + 20 * boost.dy;
var newCell = new PlayerCell(cell.owner, X, Y, size);
newCell.boost.dx = boost.dx;
newCell.boost.dy = boost.dy;
newCell.boost.d = boost.d;
AddCell(newCell);
SetCellAsBoosting(newCell);
}
// Update is called once per frame
new void Update()
{
base.Update();
checktimer -= Time.deltaTime;
if (aiMode)
{
if (target == null)
{
target = FindNearestPlayer();
}
}
}
/// <summary>
/// Creates a new player cell
/// </summary>
public void NewPlayer(int cellType)
{
// this is the bottom of the bone
Vector3 startPos = new Vector3(7.3f, -1.5f, 0.001f);//Camera.main.ScreenToWorldPoint(Input.mousePosition);
//tempPos.z = 0;
GameObject tempP = GameObject.Instantiate(playerCellPrefabs[cellType], startPos, Quaternion.identity);
PlayerCell script = tempP.GetComponent <PlayerCell>();
//script.aiMode = true;
script.position = startPos;
//tempP.gameObject.transform.localScale = new Vector3((7/100), (7/100)); //it didnt like floats
playerCells.Add(script);
stats[1]++;
}
// Refresh interface
protected virtual void SetInterface(int playerIndex)
{
// Set player
GamePlayer player = GameManager.instance.GetPlayer(playerIndex);
playerLabel.text = "P" + (playerIndex + 1);
// Set character
GameCharacter character = GameManager.instance.gameData.characters[player.characterIndex];
characterLabel.text = character.characterName.ToUpper();
PlayerCell.SetCharacterIcon(characterIcon, character.characterIconTexture);
// Set tints
Color tint = GameManager.instance.GetPlayerColor(playerIndex);
foreach (Graphic t in tintables)
{
t.color = tint;
}
// Set borders
Texture2D texture = GameManager.instance.GetPlayerBorder(playerIndex);
foreach (RawImage border in borders)
{
border.texture = texture;
if (texture != null)
{
border.color = Color.white;
border.uvRect = new Rect(0f, 0f, border.rectTransform.rect.width / (float)texture.width, border.rectTransform.rect.height / (float)texture.height);
}
else
{
border.color = Color.black;
border.uvRect = new Rect(0f, 0f, 1f, 1f);
}
}
// Set text outline
tint.r *= playerBorderTint;
tint.g *= playerBorderTint;
tint.b *= playerBorderTint;
playerLabel.fontMaterial.SetColor("_OutlineColor", tint);
// Set match button
_player = GameManager.instance.lastWinner;
SetInputButton(2);
}
/// <summary>
/// Builds the world from the input given as a string
/// </summary>
/// <param name="newWorld"></param>
/// <returns></returns>
public bool BuildWorld(string[] newWorld)
{
bool builtWorld = false;
if (newWorld.Length > 0) {
OpponentCell opponent = null;
PlayerCell player = null;
for (var i = 0; i < newWorld.Length; i++) {
string[] line = newWorld[i].Split(' ');
int x = int.Parse(line[0]);
int y = int.Parse(line[1]);
if (!Cells.ContainsKey(x)) {
Cells.Add(x, new Dictionary<int, Cell>());
}
if (!Cells[x].ContainsKey(y)) {
CellContent content = Cell.GetWorldState(line[2]);
switch (content) {
case CellContent.Opponent:
opponent = new OpponentCell() { X = x, Y = y, Content = content, Value = 0 };
Cells[x].Add(y, opponent);
break;
case CellContent.You:
player = new PlayerCell() { X = x, Y = y, Content = content, Value = 0 };
Cells[x].Add(y, player);
break;
case CellContent.OpponentWall:
Cells[x].Add(y, new Cell() { X = x, Y = y, Content = content, Value = 0 });
break;
case CellContent.YourWall:
Cells[x].Add(y, new Cell() { X = x, Y = y, Content = content, Value = 0 });
break;
case CellContent.Clear:
Cells[x].Add(y, new Cell() { X = x, Y = y, Content = content, Value = 1 });
break;
}
}
builtWorld = true;
}
if (LoadOpponentPositionEvent != null) {
LoadPositions(opponent);
LoadOpponentPositionEvent(opponent);
}
if (LoadOpponentPositionEvent != null) {
LoadPositions(player);
LoadPlayerPositionEvent(player);
}
}
return builtWorld;
}
public void PopPlayerCell(PlayerCell cell)
{
var splits = DistributeCellMass(cell);
var random = new Random();
for (int i = 0, l = splits.Count; i < l; i++)
{
var angle = (float)random.NextDouble() * 2 * Math.PI;
LaunchPlayerCell(cell, (float)Math.Sqrt(splits[i] * 100), new Boost
{
dx = (float)Math.Sin(angle),
dy = (float)Math.Cos(angle),
d = Settings.playerSplitBoost
});
}
}
private static long HeuristicLineHero(Line[] arr, int n, PlayerCell first, PlayerCell flag)
{
long sum = 0;
for (int i = 1; i < arr[0].length; i++)
{
if (arr[i].length == n)
{
return((long)1e12);
}
sum += factorial(arr[i].length + 2);
}
return(sum);
}
// Player hit okay
private void PlayerClick(int playerIndex)
{
if (playerIndex == 0)
{
Transform child = playerTable.GetChild(playerIndex);
PlayerCell cell = child.GetComponent <PlayerCell>();
if (cell.inputButton == PlayerCell.PlayerInputButton.Home)
{
GoToTitle();
}
else if (cell.inputButton == PlayerCell.PlayerInputButton.Start)
{
GoToGame();
}
}
}
public static long heuristic(FieldContext gameProcess, PlayerCell first, PlayerCell flag)
{
long score = 0;
score = HeuristicHero(gameProcess, first, flag);
if (Math.Abs(score) >= 1e12)
{
return(score);
}
long oppositeScore = 0;
oppositeScore = heuristicAntagonist(gameProcess, first, gameProcess.GetOppositePlayer(flag)); //при этой и нижней строке одинаковый результат
// oppositeScore = heuristicUser(n, field, first, getOppositeFlag(flag));
score += oppositeScore;
return(score);
}
public int EndOfTheGame(PlayerCell flag)
{
Line[] arr1 = LinesCounter.HorLines(this, flag);
for (int i = 1; i < arr1[0].length; i++)
{
if (arr1[i].length >= N)
{
return(1);
}
}
Line[] arr2 = LinesCounter.VerLines(this, flag);
for (int i = 1; i < arr2[0].length; i++)
{
if (arr2[i].length >= N)
{
return(1);
}
}
Line[] arr3 = LinesCounter.DiagLeft(this, flag);
for (int i = 1; i < arr3[0].length; i++)
{
if (arr3[i].length >= N)
{
return(1);
}
}
Line[] arr4 = LinesCounter.DiagRight(this, flag);
for (int i = 1; i < arr4[0].length; i++)
{
if (arr4[i].length >= N)
{
return(1);
}
}
bool c = Overflow(Field);
if (c)
{
return(0);
}
return(-1);
}
public void Trigger <T>(T param)
{
//casteos estaticos y dinamicos para cambiar tipos de datos
//estaticos cuando estoy segura de que va a ser ese tipo de dato
//si no es lo que dije se guarda como null
PlayerCell player = param as PlayerCell;
if (_isBig)
{
//player do something
//afecta a los fantasmas
EventController.TriggerEvent(_bigPelletEvent);
}
else
{
//agrega score al player
player.UpdateScore(_scoreMultiplier);
}
}
public static Line[] DiagRight(FieldContext gameProcess, PlayerCell flag)
{
Line[] ArrDiag = new Line[(gameProcess.QuanCols) * (gameProcess.QuanRows)];
int N = 1;
bool[,] check = new bool[gameProcess.QuanRows, gameProcess.QuanCols];
for (int i = 0; i < gameProcess.QuanRows; i++)
{
Line a = EmptyLine;
a.length = 0;
a.x_coor = i;
for (int j = 0; j < gameProcess.QuanCols; j++)
{
a.y_coor = j;
if (check[i, j] == false && gameProcess.Field[i, j] == flag)
{
a.length = 0;
for (int k = 0; (k + j < gameProcess.QuanCols) && (k + i < gameProcess.QuanRows); k++)
{
PlayerCell d = gameProcess.Field[k + i, k + j];
if (d == flag)
{
a.length++;
check[k + i, k + j] = true;
}
if ((d != flag || i + k == 2 * gameProcess.N - 2 || j + k == 2 * gameProcess.N - 1) && a.length != 0)
{
ArrDiag[N++] = a;
a.length = 0;
break;
}
}
}
}
}
ArrDiag[0].length = N;
return(ArrDiag);
}
private void Update()
{
// Should disable
bool shouldDisable = !IsEveryoneReady();
if (startButton.isDisabled != shouldDisable)
{
SetDisabled(shouldDisable);
}
// Get child
if (playerTable.childCount > 0)
{
Transform child = playerTable.GetChild(0);
PlayerCell cell = child.GetComponent <PlayerCell>();
if (_btnType != cell.inputButton)
{
_btnType = cell.inputButton;
homeButton.SetInputPlayer(_btnType == PlayerCell.PlayerInputButton.Home ? 0 : -1);
startButton.SetInputPlayer(_btnType == PlayerCell.PlayerInputButton.Start ? 0 : -1);
}
}
}
public void MovePlayerCell(PlayerCell cell)
{
var router = cell.owner.router;
if (router.disconnected)
{
return;
}
var dx = router.mouseX - cell.X;
var dy = router.mouseY - cell.Y;
var d = (float)Math.Sqrt(dx * dx + dy * dy);
if (d < 1)
{
return;
}
dx /= d;
dy /= d;
var m = Math.Min(cell.MoveSpeed, d) * handle.stepMult;
cell.X += dx * m;
cell.Y += dy * m;
}
public void Trigger <T>(T param)
{
if (!(param is PlayerCell))
{
return;
}
PlayerCell player = param as PlayerCell;
switch (dotType)
{
case DotType.Big:
EventController.TriggerEvent(dotBigEvent);
break;
case DotType.Small:
player.UpdateScore(scoreMultiplier);
break;
default:
break;
}
}
private static long heuristicAntagonist(FieldContext gameProcess, PlayerCell first, PlayerCell flag)
{
long score = 0;
Line[] arr = LinesCounter.DiagLeft(gameProcess, flag);
score += HeuristicLineAntagonist(arr, gameProcess.N, first, flag);
arr = LinesCounter.DiagRight(gameProcess, flag);
score += HeuristicLineAntagonist(arr, gameProcess.N, first, flag);
arr = LinesCounter.HorLines(gameProcess, flag);
score += HeuristicLineAntagonist(arr, gameProcess.N, first, flag);
arr = LinesCounter.VerLines(gameProcess, flag);
score += HeuristicLineAntagonist(arr, gameProcess.N, first, flag);
if (flag == PlayerCell.Antagonist)//bot
{
score = (-1) * score;
}
return(score);
}
private void TestInit()
{
World = new World(Vector2.Zero);
_objectList = new List <ActiveGameObject>();
_player = new PlayerCell(this, new Vector2(0));
GoodCell goodCell = new GoodCell(this, new Vector2(300, 100));
GoodCellList.Add(goodCell);
_objectList.Add(goodCell);
_objectList.Add(new Virus(this, new Vector2(200, -200)));
//Vertices vertices = new Vertices();
//vertices.Add(new Vector2(-300, -200));
//vertices.Add(new Vector2(-200, -150));
//vertices.Add(new Vector2(-100, -200));
//vertices.Add(new Vector2(-160, -300));
//vertices.Add(new Vector2(-240, -300));
//_wallList.Add(new Wall(vertices, Wall.WallType.Outer, this));
Vertices vertices = new Vertices();
vertices.Add(new Vector2(-200, 200));
vertices.Add(new Vector2(-150, 225));
vertices.Add(new Vector2(-100, 200));
vertices.Add(new Vector2(-125, 250));
vertices.Add(new Vector2(-100, 300));
vertices.Add(new Vector2(-150, 275));
vertices.Add(new Vector2(-200, 300));
vertices.Add(new Vector2(-175, 250));
_wallList.Add(new Wall(vertices, Wall.WallType.Outer, this));
}
public void SetPlayer(PlayerCell player)
{
Player = player;
}
/// <summary>
/// Event which is fired when the players last position is loaded
/// </summary>
/// <param name="playerCell">Player last turn position</param>
private void LastTurn_LoadPlayerPositionEvent(PlayerCell playerCell)
{
PlayerCell.LastTurnPosition = playerCell;
}
