private List <Move> GetAllCurrentTurnMoves(List <Figure> figuresOnBoard, Vector2Int previousMoveFinalPosition, TurnState currentTurnState)
{
List <Move> possibleMoves = new List <Move>();
var myFigures = figuresOnBoard.Where(figure => figure.Data.isWhite == IsWhiteTurn).ToArray();
foreach (var figure in myFigures)
{
for (int z = 0; z < 8; z++)
{
for (int x = 0; x < 8; x++)
{
Vector2Int finalPosition = new Vector2Int(x, z);
if (IsAbleToMove(figure, figuresOnBoard, previousMoveFinalPosition, finalPosition, currentTurnState))
{
var figureToCapture = figuresOnBoard.FirstOrDefault(figure => figure.Data.position == finalPosition);
List <Figure> boardCopy = new List <Figure>(figuresOnBoard);
if (figureToCapture != null)
{
boardCopy.Remove(figureToCapture);
}
int indexOfFigure = boardCopy.IndexOf(figure);
FigureData figureDataBackUp = boardCopy[indexOfFigure].Data;
boardCopy[indexOfFigure].Data.position = finalPosition;
if (!IsCheck(boardCopy, previousMoveFinalPosition, currentTurnState))
{
possibleMoves.Add(new Move(figure, finalPosition));
}
boardCopy[indexOfFigure].Data = figureDataBackUp;
}
}
}
}
return(possibleMoves);
}
private void GenerateFigure(GameObject figurePrefab, FigureData data)
{
var figureGameObject = Instantiate(figurePrefab, new Vector3(data.position.x, 0, data.position.y), Quaternion.identity);
figureGameObject.GetComponent <Figure>().Data = data;
FiguresOnBoard.Add(figureGameObject.GetComponent <Figure>());
}
public override void OnInspectorGUI()
{
base.OnInspectorGUI();
data = (FigureData)target;
GUILayout.Label("ID GG Shet");
GUILayout.Space(20);
GUILayout.BeginHorizontal();
ID = EditorGUILayout.TextField("ID: ", ID);
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal();
sheetName = EditorGUILayout.TextField("SheetName: ", sheetName);
GUILayout.EndHorizontal();
GUILayout.Space(20);
GUILayout.BeginHorizontal();
if (GUILayout.Button("Retrieving"))
{
RetrievingData();
}
GUILayout.EndHorizontal();
}
public void saveFigureToFile(List <Vector2> _figureDotsList, string _fileName)
{
FigureData _figureData = new FigureData();
_figureData.figureDots = _figureDotsList;
saveFigureToFile(_figureData, _fileName);
}
/// <summary>
/// Позволяет задать всю необходимую для начала битвы информацию
/// </summary>
/// <param name="cellBaseFightingFor"></param>
/// <param name="firstFigure"></param>
/// <param name="secondFigure"></param>
public void SetAllInitialInfo(FigureData firstFigure, FigureData secondFigure, CellBase cellBaseFightingFor)
{
Clear();
_firstFigure = firstFigure;
_secondFigure = secondFigure;
_cellFightingFor = cellBaseFightingFor;
}
public GameObject Init(FigureData figureData)
{
_figureData = figureData;
GetComponent <MeshFilter>().mesh = figureData.Mesh;
return(Instantiate(prefab, new Vector3(_position.x, 0, _position.y), Quaternion.identity));
}
/// <summary>
/// Очищает всю старую информацию
/// </summary>
private void Clear()
{
_firstFigure = null;
_secondFigure = null;
_cellFightingFor = null;
_winner = null;
Loser = null;
}
public Transform Push(FigureData figureData)
{
GameObject figure = new GameObject("Figure");
figure.transform.SetParent(figuresParent);
figure.AddComponent <FigurePolygon>();
figure.AddComponent <FigureDataComponent>();
figure.AddComponent <Rigidbody2D>();
figure.AddComponent <PolygonCollider2D>();
figure.AddComponent <MeshFilter>();
figure.AddComponent <MeshRenderer>();
FigurePolygon polygon = figure.GetComponent <FigurePolygon>();
polygon.SetPoints(figureData.Points, borders.Left.transform.localScale.z);
FigureDataComponent figureDataStorage = figure.GetComponent <FigureDataComponent>();
figureDataStorage.Data = figureData;
Rigidbody2D rigidbody2D = figure.GetComponent <Rigidbody2D>();
rigidbody2D.gravityScale = kGravityScale;
PolygonCollider2D collider = figure.GetComponent <PolygonCollider2D>();
collider.points = polygon.GetPoints();
Mesh mesh = polygon.GetMesh();
MeshFilter meshFilter = figure.GetComponent <MeshFilter>();
meshFilter.mesh = mesh;
MeshRenderer renderer = figure.GetComponent <MeshRenderer>();
renderer.material.color = figureData.Color;
SetPosition(figure.transform);
// Check if the figure will collide with other figures at the start position. If so, we can't place it
Collider2D[] results = new Collider2D[100];
int numColliders = rigidbody2D.OverlapCollider(new ContactFilter2D(), results);
if (numColliders > 0)
{
for (int i = 0; i < numColliders; i++)
{
if (results[i].transform != borders.Top)
{
Object.Destroy(figure.gameObject);
return(null);
}
}
}
return(figure.transform);
}
//Method for UI that calls when pawn achieves the end of the board
public void TransformPawnToNewFigure(string enumName)
{
Figure pawnInTheEnd = FiguresOnBoard.Find(figure => figure.Data.position == PreviousMoveFinalPosition);
FigureData backUpData = pawnInTheEnd.Data;
Enum.TryParse(enumName, out Kind figureKind);
backUpData.kind = figureKind;
FiguresOnBoard.Remove(pawnInTheEnd);
Destroy(pawnInTheEnd.gameObject);
GenerateFigure(modelMatcher.KindModelPairs[Tuple.Create(backUpData.kind, backUpData.isWhite)], backUpData);
OnPause = false;
}
public void DrawFigure(FigureData figureData, int index = 0)
{
if (this.figureDataList.ContainsKey(index))
{
this.figureDataList[index].Add(figureData);
}
else
{
this.figureDataList.Add(index, new List <FigureData>()
{
figureData
});
}
}
public virtual void Initialize(FigureContainer container, FigureData data)
{
this.container = container;
jumpUpHeight = data.jumpUpHeight;
jumpDownHeight = data.jumpDownHeight;
angle = data.jumpingAngle * Mathf.Deg2Rad;
pathFinder = new DijkstraPathFinder(jumpUpHeight, jumpDownHeight);
body = GetComponent<Rigidbody>();
Height = r.bounds.size.y;
DefineStartHex(0.5f * r.bounds.size.y);
container.OnFigureCreated((Figure)this);
}
private IEnumerator turnCoroutine()
{
_currentFigure = FigureSaveLoadManager.Current.loadRandomFigure();
_figurePreviev.updateFigure(FigureAnalyzer.Vector2ToVector3(_currentFigure.figureDots));
float _timer = currentTimer;
currentTimer *= timerStepCoef;
while (_timer > 0f)
{
yield return(new WaitForEndOfFrame());
_timer -= Time.deltaTime;
_timerText.text = _timer.ToString("0.0");
}
gameOver();
}
public void saveFigureToFile(FigureData _figureData, string _fileName)
{
try
{
string jsonData = JsonUtility.ToJson(_figureData);
// Debug.Log(jsonData);
FileStream file = File.Create(Application.dataPath + "/Resources/Figures/" + _fileName + ".json");
using (StreamWriter writer = new StreamWriter(file))
{
writer.Write(jsonData);
}
file.Close();
}
catch (Exception e)
{
Debug.Log(e);
}
}
private ArrowHead GetArrowHead()
{
var lastPathFigureData = FigureData.Last();
var cubics = lastPathFigureData.CubicTriples.ToList();
Point head, source;
if (cubics.Any())
{
var lastCubic = cubics.Last().ToList();
if (lastPathFigureData.EndPoint != null)
{
head = lastPathFigureData.EndPoint;
source = lastCubic[2];
}
else
{
head = lastCubic[2];
source = lastCubic[0];
}
}
else
{
if (lastPathFigureData.EndPoint != null)
{
head = lastPathFigureData.EndPoint;
source = lastPathFigureData.MainPoint;
}
else
{
if (lastPathFigureData.StartPoint == null)
{
throw new NotImplementedException();
}
head = lastPathFigureData.MainPoint;
source = lastPathFigureData.StartPoint;
}
}
return(new ArrowHead(head, source));
}
private void NextFigure()
{
FigureData newFigureData;
if (nextFigure == null)
{
newFigureData = figureCreator.GenerateFigure();
}
else
{
// take figure data from the next figure
FigureDataComponent figureDataStorage = nextFigure.GetComponent <FigureDataComponent>();
newFigureData = figureDataStorage.Data;
}
currentFigure = figurePusher.Push(newFigureData); // returns null if can't push figure
if (currentFigure)
{
FigurePolygon polygon = currentFigure.GetComponent <FigurePolygon>();
polygon.AddListener(this);
}
else
{
// can't push figure, so the game is over
GameOver();
}
if (nextFigure)
{
Destroy(nextFigure.gameObject); // remove previous figure from next figure area
nextFigure = null;
}
// generate next figure for displaying
FigureData nextFigureData = figureCreator.GenerateFigure();
nextFigure = nextFigurePusher.Push(nextFigureData);
}
public Transform Push(FigureData figureData)
{
GameObject figure = new GameObject("Next figure");
figure.AddComponent <FigurePolygon>();
figure.AddComponent <FigureDataComponent>();
figure.AddComponent <MeshFilter>();
figure.AddComponent <MeshRenderer>();
figure.AddComponent <FigureRotatorY>();
FigurePolygon polygon = figure.GetComponent <FigurePolygon>();
polygon.SetPoints(figureData.Points, nextFigureArea.Left.transform.localScale.z);
FigureDataComponent figureDataStorage = figure.GetComponent <FigureDataComponent>();
figureDataStorage.Data = figureData;
Mesh mesh = polygon.GetMesh();
MeshFilter meshFilter = figure.GetComponent <MeshFilter>();
meshFilter.mesh = mesh;
MeshRenderer renderer = figure.GetComponent <MeshRenderer>();
renderer.material.color = figureData.Color;
SetPosition(figure);
FigureRotatorY rotator = figure.GetComponent <FigureRotatorY>();
Vector2 size = polygon.CalculateSize();
Vector3 center = new Vector3(size.x / 2, size.y / 2, 0);
rotator.SetCenter(figure.transform.position + center);
return(figure.transform);
}
private ArrowHead GetArrowTail()
{
var firstPathFigureData = FigureData.First();
var cubics = firstPathFigureData.CubicTriples.ToList();
Point head, source;
if (firstPathFigureData.StartPoint != null)
{
head = firstPathFigureData.StartPoint;
source = firstPathFigureData.MainPoint;
}
else if (cubics.Any())
{
var firstCubic = cubics.First().ToList();
head = firstPathFigureData.MainPoint;
source = firstCubic[0];
}
else
{
throw new NotImplementedException();
}
return(new ArrowHead(head, source));
}
public void UpdateInfo(FigureData figure)
{
_currentFigure = figure;
UpdateInfo();
}
public override void Initialize(FigureContainer container, FigureData data)
{
base.Initialize(container, data);
Owner = Player.GetByIndex(data.owner);
//*!Crutch
r.material = Resources.Load<Material>("Models/Materials/whiteMat");
r.material.mainTexture = Resources.Load<Texture>("Models/whiteMat");
r.material.color = data.color;
//_
InitStats(data);
InitFight();
}
protected virtual void InitStats(FigureData data)
{
reds = statHolder.Add(StatType.Red, 0, false);
greens = statHolder.Add(StatType.Green, 0, false);
blues = statHolder.Add(StatType.Blue, 0, false);
mass = statHolder.Add(StatType.Mass, 10, false);
hp = (DynamicStat)statHolder.Add(StatType.HealthPoints, data.baseHP, true);
ap = (DynamicStat)statHolder.Add(StatType.ActionPoints, data.actionPoints, true); ;
maxDamage = statHolder.Add(StatType.MaxDamage, data.damage, false);
minDamage = statHolder.Add(StatType.MinDamage, 0, false);
initiative = statHolder.Add(StatType.Initiative, data.initiative, false);
statHolder.InitializeDependencies();
RDamage = new Range(() => minDamage.Value, () => maxDamage);
}
protected override void NeedToAwake()
{
data = GetComponent<FigureData>();
action = GetComponent<FigureAction>();
if(this.GetComponent<PlayerMove>())
playerMove = GetComponent<PlayerMove> ();
}
void Start()
{
figureData = GetComponent<FigureData>();
}
protected override void NeedToAwake()
{
figureData = GetComponent<FigureData>();
if(gameObject.GetComponents<FigureMove>() != null)
figureMove = GetComponent<FigureMove>();
if(gameObject.GetComponent<PlayerJump>() != null)
playerJump = GetComponent<PlayerJump>();
SecNeedToAwake ();
}
public Rectungle(FigureData data)
: base(data)
{
}
public void Create(GameObject baseObject, FigureData data)
{
var figure = baseObject.AddComponent<Figure>();
figure.Initialize(container, data);
}
public ActionResult Index(FigureData formData)
{
string dims = formData.Dimensions;
double result = 0;
try
{
if (formData.Dimensions.Contains("."))
{
dims = formData.Dimensions.Replace('.', ',');
}
string[] sizesArray = dims.Split(new Char[] { ';' });
switch (formData.Shape)
{
case Shapes.Koło:
Circle circle = new Circle();
circle.DimR = Convert.ToDouble(sizesArray[0].Trim());
result = Math.Round(circle.CalculateArea(), 2);
break;
case Shapes.Kwadrat:
Square square = new Square();
square.DimA = Convert.ToDouble(sizesArray[0].Trim());
result = Math.Round(square.CalculateArea(), 2);
break;
case Shapes.Prostokąt:
Rectangle rectangle = new Rectangle();
rectangle.DimA = Convert.ToDouble(sizesArray[0].Trim());
rectangle.DimB = Convert.ToDouble(sizesArray[1].Trim());
result = Math.Round(rectangle.CalculateArea(), 2);
break;
case Shapes.Romb:
Rhombus rhombus = new Rhombus();
rhombus.DimA = Convert.ToDouble(sizesArray[0].Trim());
rhombus.DimH = Convert.ToDouble(sizesArray[1].Trim());
result = Math.Round(rhombus.CalculateArea(), 2);
break;
case Shapes.Równoległobok:
Parallelogram parallelogram = new Parallelogram();
parallelogram.DimA = Convert.ToDouble(sizesArray[0].Trim());
parallelogram.DimH = Convert.ToDouble(sizesArray[1].Trim());
result = Math.Round(parallelogram.CalculateArea(), 2);
break;
case Shapes.Trapez:
Trapezoid trapezoid = new Trapezoid();
trapezoid.DimA = Convert.ToDouble(sizesArray[0].Trim());
trapezoid.DimB = Convert.ToDouble(sizesArray[1].Trim());
trapezoid.DimH = Convert.ToDouble(sizesArray[2].Trim());
result = Math.Round(trapezoid.CalculateArea(), 2);
break;
case Shapes.Trójkąt:
Triangle triangle = new Triangle();
triangle.DimA = Convert.ToDouble(sizesArray[0].Trim());
triangle.DimH = Convert.ToDouble(sizesArray[1].Trim());
result = Math.Round(triangle.CalculateArea(), 2);
break;
}
formData.ResultNotification = string.Format("Pole powierzchni figury {0} dla podanych wymiarów wynosi: {1}.", formData.Shape, result);
}
catch (NullReferenceException)
{
formData.ResultNotification = "Podaj wymiary figury";
}
catch (FormatException)
{
formData.ResultNotification = "Podaj prawidłowe dane";
}
catch (IndexOutOfRangeException)
{
formData.ResultNotification = "Podaj wszystkie wymagane wymiary w formacie podanym w instrukcji";
}
return(View(formData));
}
public BoardData()
{
FillBoardData();
figureData = new FigureData(this);
}
public void SetTalent(FigureData figure, Talent talent)
{
figure.BattleFieldFigurePrefub.Talent = talent;
}
public void InitialPicker(FigureData data,FigureAction action)
{
pickerData = data;
pickerAction = action;
}
public void SetSkill(FigureData figure, Skill skill)
{
figure.BattleFieldFigurePrefub.Skill = skill;
}
public BoardData()
{
FillBoardData();
figureData = new FigureData(BoardSize, this);
SetBoardScore();
}
