public Aspect NaturalAspect()
{
Vector3 cameraPos = this.surfaceBillboardRef.RelativeCameraPosition();
WalkerDirection lookedDir = this.LookedDirectionFromRelativePosition(cameraPos);
return(AspectByLookedDirectionAndWalkerDirection[lookedDir][(WalkerDirection)this.data.direction]);
}
public void Turn(WalkerDirection dir)
{
this.data.direction = (int)dir;
Aspect asp = this.NaturalAspect();
this.ChangeAspect(asp);
}
public void RotateLeft()
{
this.axis.y = 1.0f;
switch (DirectionUtil.RelativeDirection(this.transform.position, this.target.transform.position))
{
case Direction.South: this.destination = Direction.West; break;
case Direction.East: this.destination = Direction.South; break;
case Direction.North: this.destination = Direction.East; break;
case Direction.West: this.destination = Direction.North; break;
}
}
private void UpdateWalkVector()
{
if (this.walkDirectionQueue.Count == 0)
{
return;
}
if (this.IsWalking())
{
return;
}
this.walkFrom = this.transform.position;
Map map = MapLoader.CurrentMap();
DirectionUtil.Direction nextDirection = this.walkDirectionQueue[0];
this.walkDirectionQueue.RemoveAt(0);
Map currentMap = MapLoader.CurrentMap();
switch (nextDirection)
{
case DirectionUtil.Direction.South: this.walkVector = new Vector3(0.0f, 0.0f, -WalkDistanceUnit); break;
case DirectionUtil.Direction.North: this.walkVector = new Vector3(0.0f, 0.0f, WalkDistanceUnit); break;
case DirectionUtil.Direction.East: this.walkVector = new Vector3(WalkDistanceUnit, 0.0f, 0.0f); break;
case DirectionUtil.Direction.West: this.walkVector = new Vector3(-WalkDistanceUnit, 0.0f, 0.0f); break;
default: return;
}
this.data.direction = (int)nextDirection;
this.data.address = DirectionUtil.GetNeighborAddress(this.data.address, nextDirection, currentMap.width, currentMap.height);
}
public void RefreshDistance()
{
DirectionUtil.Direction currentDirection = this.GetCalcuratedDirection();
if (currentDirection == DirectionUtil.Direction.None)
{
currentDirection = DirectionUtil.Direction.South;
}
Vector3 baseDistance = this.baseSouthDistance;
Vector3 newDistance = baseDistance;
switch (currentDirection)
{
case DirectionUtil.Direction.North:
{
newDistance.x = -baseDistance.x;
newDistance.z = -baseDistance.z;
break;
}
case DirectionUtil.Direction.East:
{
newDistance.x = -baseDistance.z;
newDistance.z = baseDistance.x;
break;
}
case DirectionUtil.Direction.West:
{
newDistance.x = baseDistance.z;
newDistance.z = -baseDistance.x;
break;
}
}
this.SetDistance(newDistance);
}
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);
}
private void Update()
{
if (this.target == null)
{
return;
}
if (this.destination == Direction.None)
{
return;
}
Vector3 lastRel = this.target.transform.position - this.transform.position;
this.transform.RotateAround(this.target.position, this.axis, Time.deltaTime * this.speed);
Vector3 rel = this.target.transform.position - this.transform.position;
switch (this.destination)
{
case Direction.South:
{
if ((lastRel.x > 0.0f && rel.x <= 0.0f) || (lastRel.x < 0.0f && rel.x >= 0.0f))
{
this.destination = Direction.None;
}
break;
}
case Direction.North:
{
if ((lastRel.x > 0.0f && rel.x <= 0.0f) || (lastRel.x < 0.0f && rel.x >= 0.0f))
{
this.destination = Direction.None;
}
break;
}
case Direction.East:
{
if ((lastRel.z > 0.0f && rel.z <= 0.0f) || (lastRel.z < 0.0f && rel.z >= 0.0f))
{
this.destination = Direction.None;
}
break;
}
case Direction.West:
{
if ((lastRel.z > 0.0f && rel.z <= 0.0f) || (lastRel.z < 0.0f && rel.z >= 0.0f))
{
this.destination = Direction.None;
}
break;
}
}
this.transform.LookAt(this.target.position);
if (this.destination == Direction.None)
{
this.axis.y = 0.0f;
this.OnRotateFinished?.Invoke();
}
}
