public void StruckedByLightning()
{
if (!IsEnabled)
{
return;
}
Setup();
Debug.Log("Grass has been hit by Lightning!");
GrassMaterial.color = Color.red;
CurrentColor = Color.red;
FieldTile.ChangeState("Fire");
isDefultEnableState = IsEnabled;
}
public void RainedOn()
{
if (!IsEnabled)
{
return;
}
Setup();
Debug.Log("Grass has been hit by Water!");
GrassMaterial.color = Color.blue;
CurrentColor = Color.blue;
FieldTile.ChangeState("Water");
isDefultEnableState = IsEnabled;
}
public ConnectionModule GetBestConnection(Module module, List <ConnectionModule> connectionModules, FieldTile[,] field)
{
FieldTile tile = GetClosestTileToModule(GetAdjacentTilesOfType(field, FieldTile.eTileType.Connection));
foreach (ConnectionModule cm in connectionModules)
{
if (cm.Position.Equals(tile.Position))
{
return(cm);
}
}
return(null);
}
//TODO: Make gamefield observable for change
public GameFieldTest()
{
placeableObjectMock = Substitute.For <PlaceableObject>();
fieldTileFactoryMock = Substitute.For <FieldTileFactory>();
tileMock = Substitute.For <FieldTile>();
FieldTile[] tiles = new FieldTile[fieldSize];
for (int i = 0; i < tiles.Length; i++)
{
tiles[i] = tileMock;
}
fieldTileFactoryMock.CreateTileList(fieldSize).Returns(tiles);
testee = new ArrayTiledGameField(fieldSize, fieldTileFactoryMock);
}
public void StruckedByLightning()
{
if (!IsEnabled)
{
return;
}
Setup();
//If Fire is stuck by Lightning it should do nothing for now, unless it was hit by water first, then take it back to fire
Debug.Log("Fire has been hit by Lightning!");
FireMaterial.color = StartingColor;
CurrentColor = StartingColor;
FieldTile.ChangeState("Fire");
isDefultEnableState = IsEnabled;
}
public void RainedOn()
{
if (!IsEnabled)
{
return;
}
Setup();
//If Water has been hit by water then do nothing, unless it has been hit by Lightning first, then take it back to water
Debug.Log("Water has been hit by Water!");
WaterMaterial.color = StartingColor;
CurrentColor = StartingColor;
FieldTile.ChangeState("Water");
isDefultEnableState = IsEnabled;
}
public FieldTile GetClosestTileToModule(List <FieldTile> tiles)
{
float distance = float.MaxValue;
FieldTile best = null;
foreach (FieldTile tile in tiles)
{
if (tile.GetDistanceToCenterOfModule(this) < distance)
{
distance = tile.GetDistanceToCenterOfModule(this);
best = tile;
}
}
return(best);
}
protected override void OnLoad()
{
TmxMap map = new TmxMap("Resources/farm.tmx");
Size = new Vector2D(map.Width, map.Height);
TmxTileset tileset = map.Tilesets[0];
foreach (var layer in map.Layers)
{
int zIndex = int.Parse(layer.Properties["ZIndex"]);
Tile[] tiles = layer.Tiles.Where(x => x.Gid > 0).Select(x => GetTile(x, tileset)).ToArray();
AddTileLayer(new TileLayer(zIndex, tiles));
}
foreach (var field in map.ObjectGroups[0].Objects.Where(x => x.Name == "Field Block"))
{
int width = (int)field.Width / map.TileWidth;
int height = (int)field.Height / map.TileHeight;
int x = (int)field.X / map.TileWidth;
int y = (int)field.Y / map.TileHeight;
for (int i = 0; i < width; i++)
{
for (int j = 0; j < height; j++)
{
FieldTile tile = new FieldTile();
tile.Position = new Vector2D(x + i, y + j);
AddGameObject(tile);
}
}
}
var spawn = map.ObjectGroups[0].Objects["Spawn"];
Farmer player = new Farmer();
player.Position = new Vector2D((int)(spawn.X / map.TileWidth), (int)(spawn.Y / map.TileHeight));
AddGameObject(player);
AddGameObject(new MouseController());
AddGameObject(new CameraController());
Game.CenterViewTo(player.Position);
}
private FieldTile CreateXMove(Sequence sq, float xDiff, FieldTile tile)
{
if (Math.Abs(Mathf.Abs(xDiff) - 1) < float.Epsilon)
{
return(tile);
}
var targetTile = xDiff < 0 ? tile.LeftNeighbor : tile.RightNeighbor;
if (targetTile.HasEnemy)
{
return(tile);
}
sq.Append(this.transform.DOMove(targetTile.transform.position.ClearZ() + this.transform.position.OnlyZ(),
this.MoveTime));
return(targetTile);
}
private void CreateMovement(FieldTile target)
{
var tempPos = this.PositionTile;
tempPos.HasEnemy = false;
var mv = DOTween.Sequence();
mv.PrependInterval(0.1f);
var targetPos = target.transform.position;
var distance = Mathf.Abs(targetPos.x - this.transform.position.x) + Mathf.Abs(targetPos.y - this
.transform
.position.y);
var distanceWalkable = this.movement;
while (distanceWalkable > 0 && distance > this.MaxDistance + 1)
{
var toMove = target.transform.position.ClearZ() - tempPos.transform.position.ClearZ();
//if (Mathf.Abs(toMove.x) >= Mathf.Abs(toMove.y))
if (Random.Range(0f, 1f) <= 0.5f)
{
if (Mathf.Abs(toMove.x) > float.Epsilon)
{
tempPos = this.CreateXMove(mv, toMove.x, tempPos);
}
}
else
{
if (Mathf.Abs(toMove.y) > float.Epsilon)
{
tempPos = this.CreateYMove(mv, toMove.y, tempPos);
}
}
distanceWalkable--;
}
mv.OnComplete(() => { GameManager.Instance.Battlefield.EnemyCanMove = true; });
this.PositionTile = tempPos;
tempPos.HasEnemy = true;
}
public void Attack(FieldTile tile)
{
var mv = DOTween.Sequence();
var pos = this.transform.position;
var dir = tile.transform.position - pos;
dir.Normalize();
var target = GameManager.Instance.Battlefield.Enemies.Find(e => e.PositionTile == tile);
mv.Append(this.transform.DOMove(pos + 0.5f * dir, this.AttackTime))
.Append(this.transform.DOMove(pos, this.AttackTime))
.OnComplete(() =>
{
GameManager.Instance.BattleState =
BattleState.EnemiesMoving;
GameManager.Instance.Battlefield
.Enemies.Shuffle();
GameManager.Instance.Battlefield
.PlayerAttackable.Clear();
var sq = DOTween.Sequence().AppendInterval(this.MoveTime * 2)
.AppendCallback(() =>
{
GameManager.Instance.Battlefield.EnemyCanMove = true;
});
});
var moveEnemy = DOTween.Sequence();
if (target == null)
{
return;
}
var tarPos = target.transform.position;
moveEnemy.AppendInterval(this.AttackTime)
.AppendCallback(() => this.DealDamage(target))
.Append(target.transform.DOMove(tarPos + 0.25f * dir, this.AttackTime))
.Append(target.transform.DOMove(tarPos, this.AttackTime));
}
/// <summary>
/// Drop Rain on the current object we are clicking.
/// Using RayCasting for point of click
/// Using Interface to control behavior
/// </summary>
private void DropRain()
{
//Use Ray Casting to check for hit
//Create ray
Ray rayOrigin = Camera.main.ScreenPointToRay(Input.mousePosition);
//Create hit info
RaycastHit hitInfo;
//Did we hit anything?
if (Physics.Raycast(rayOrigin, out hitInfo))
{
//Grab the IDousable Interface ofthe object we hit
FieldTile obj = hitInfo.collider.GetComponent <FieldTile>();
//We hit a "Dousable" object
if (obj != null)
{
obj.RainedOn();
}
}
}
/// <summary>
/// Fire Lighting on the current object we are clicking.
/// Using RayCasting for point of click
/// Using Interface to control behavior
/// </summary>
private void FireLightning()
{
//Use Ray Casting to check for hit
//Create ray
Ray rayOrigin = Camera.main.ScreenPointToRay(Input.mousePosition);
//Create hit info
RaycastHit hitInfo;
//Did we hit anything?
if (Physics.Raycast(rayOrigin, out hitInfo))
{
//Grab the IDousable Interface ofthe object we hit
FieldTile obj = hitInfo.collider.GetComponent <FieldTile>();
Debug.Log($"hitInfo.collider.name: {hitInfo.collider.name}");
Debug.Log($"obj: {obj}");
//We hit a "Attackable" object
if (obj != null)
{
obj.StruckedByLightning();
}
}
}
public FieldTileTest()
{
objectToPlaceOnTile = Substitute.For <PlaceableObject>();
testee = new BasicFieldTile();
}
private static GameObject InstantiateFields(
GameObject mapRoot,
MeshFilter tilePool,
FieldTile fieldPrototype,
FieldTile verticalPrototype,
FieldCollider fieldColliderPrototype,
Action <Map, MeshFilter, int, int> onEachTile
)
{
Map map = MapLoader.currentMap;
mapRoot.isStatic = true;
int fieldAspects = 4;
int width = map.width;
int floors = (map.fields.Length > map.verticalFields.Length)
? map.fields.Length
: map.verticalFields.Length;
Dictionary <int, List <MeshFilter> > meshFilterDictionary = new Dictionary <int, List <MeshFilter> >();
Dictionary <int, List <MeshFilter> > verticalMeshFilterDictionary = new Dictionary <int, List <MeshFilter> >();
// TODO: reduce draw call, RT? Mesh Combine?
for (int floor = 0; floor < floors; floor++)
{
int[] floorField = (map.fields.Length > floor)
? map.fields[floor]
: new int[] { };
int[][] floorVerticalField = (map.verticalFields.Length > floor)
? map.verticalFields[floor]
: new int[][] { };
int indexes = (floorField.Length >= floorVerticalField.Length)
? floorField.Length
: floorVerticalField.Length;
for (int i = 0; i < indexes; i++)
{
int col = i % width;
int row = (int)Mathf.Floor(i / width);
do // collect MeshFilters of horizontal fields by same appearance
{
if (floorField.Length <= i)
{
break;
}
int fieldId = floorField[i];
if (fieldId == MapLoader.EmptyField)
{
break;
}
MeshFilter filter = GameObject.Instantiate <MeshFilter>(tilePool);
filter.transform.parent = mapRoot.transform.transform;
filter.transform.rotation = MapLoader.SurfaceUp;
filter.transform.position = new Vector3(col * FieldUnit.x + FieldUnit.x * 0.5f, (float)floor * FieldUnit.y, -row * FieldUnit.z - FieldUnit.z * 0.5f);
if (!meshFilterDictionary.ContainsKey(fieldId))
{
meshFilterDictionary.Add(fieldId, new List <MeshFilter> {
});
}
List <MeshFilter> filters = meshFilterDictionary[fieldId];
filters.Add(filter);
onEachTile?.Invoke(MapLoader.currentMap, filter, col, row);
} while (false);
do // collect MeshFilters of vertical fields by same appearance
{
if (floorVerticalField.Length <= i)
{
break;
}
int[] verticalFieldDirections = floorVerticalField[i];
if (verticalFieldDirections.Length != fieldAspects)
{
break;
}
for (int directionNumber = 0; directionNumber < verticalFieldDirections.Length; directionNumber++)
{
int verticalFieldId = verticalFieldDirections[directionNumber];
if (verticalFieldId == MapLoader.EmptyField)
{
continue;
}
DirectionUtil.Direction direction = (DirectionUtil.Direction)directionNumber;
MeshFilter verticalFilter = GameObject.Instantiate <MeshFilter>(tilePool);
verticalFilter.transform.parent = mapRoot.transform.transform;
verticalFilter.transform.rotation = MapLoader.SurfaceDirection[direction];
verticalFilter.transform.position = new Vector3(col * FieldUnit.x + 0.5f, ((float)floor + 0.5f) * FieldUnit.y, -row * FieldUnit.z - 0.5f) + MapLoader.SurfaceOffset[direction];
if (!verticalMeshFilterDictionary.ContainsKey(verticalFieldId))
{
verticalMeshFilterDictionary.Add(verticalFieldId, new List <MeshFilter> {
});
}
List <MeshFilter> verticalFilters = verticalMeshFilterDictionary[verticalFieldId];
verticalFilters.Add(verticalFilter);
}
} while (false);
}
FieldCollider fieldCollider = GameObject.Instantiate <FieldCollider>(fieldColliderPrototype);
float height = Mathf.Floor(map.fields[0].Length / width) + 1;
fieldCollider.Init(width, height, floor);
fieldCollider.transform.parent = mapRoot.transform;
// TODO:
fieldCollider.gameObject.SetActive(floor == 0);
}
// combine meshes
{
foreach (KeyValuePair <int, List <MeshFilter> > kv in meshFilterDictionary)
{
List <MeshFilter> filters = kv.Value;
CombineInstance[] combine = new CombineInstance[filters.Count];
for (int i = 0; i < filters.Count; i++)
{
combine[i].mesh = filters[i].sharedMesh;
combine[i].transform = filters[i].transform.localToWorldMatrix;
combine[i].subMeshIndex = 0;
GameObject.Destroy(filters[i].gameObject);
}
FieldTile tile = GameObject.Instantiate <FieldTile>(fieldPrototype);
tile.InitCombinedFloor(combine, kv.Key - 1);
tile.transform.parent = mapRoot.transform;
}
foreach (KeyValuePair <int, List <MeshFilter> > kv in verticalMeshFilterDictionary)
{
List <MeshFilter> filters = kv.Value;
CombineInstance[] combine = new CombineInstance[filters.Count];
for (int i = 0; i < filters.Count; i++)
{
combine[i].mesh = filters[i].sharedMesh;
combine[i].transform = filters[i].transform.localToWorldMatrix;
combine[i].subMeshIndex = 0;
GameObject.Destroy(filters[i].gameObject);
}
FieldTile tile = GameObject.Instantiate <FieldTile>(verticalPrototype);
tile.InitCombinedFloor(combine, kv.Key - 1);
tile.gameObject.AddComponent <Terrain>();
tile.transform.parent = mapRoot.transform;
// skip this if scene allows penetrate path finding raycast
MeshCollider collider = tile.GetComponent <MeshCollider>();
collider.sharedMesh = tile.GetComponent <MeshFilter>().sharedMesh;
/*
* CombineInstance[] rcombine = new CombineInstance[filters.Count];
* for (int i = 0; i < filters.Count; i++)
* {
* Vector3 euler = rcombine[i].transform.rotation.eulerAngles;
* rcombine[i].mesh = filters[i].sharedMesh;
* filters[i].transform.rotation = Quaternion.Euler(new Vector3(euler.x, euler.y + 180.0f, euler.z));
* rcombine[i].transform = filters[i].transform.localToWorldMatrix;
* rcombine[i].subMeshIndex = 0;
* GameObject.Destroy(filters[i].gameObject);
* }
*
* FieldTile rtile = GameObject.Instantiate<FieldTile>(verticalPrototype);
* rtile.InitCombinedFloor(rcombine, kv.Key - 1);
* rtile.gameObject.AddComponent<Terrain>();
* rtile.transform.parent = mapRoot.transform;
*
* // skip this if scene allows penetrate path finding raycast
* MeshCollider rcollider = rtile.GetComponent<MeshCollider>();
* rcollider.sharedMesh = rtile.GetComponent<MeshFilter>().sharedMesh;
*/
}
}
return(mapRoot);
}
