// 直线射线在地图上的终点
Vector3 GetLineEnd(Vector3 start, Vector3 direction)
{
float distance = 100;
direction.Normalize();
RaycastHit2D[] lineTest = Physics2D.RaycastAll(start, direction, distance);
foreach (var hit in lineTest)
{
// if(hit.collider == null) continue;
if (hit.collider.gameObject.CompareTag("Obstacle"))
{
ObstacleBase obstacle = hit.collider.gameObject.GetComponent <ObstacleBase>();
if (obstacle.Type == ObstacleBase.ObstacleType.Glass)
{
continue;
}
else
{
return(hit.point);
}
}
}
return(start + direction * 3);
}
private void CreateObstacles()
{
for (int i = 0; i < obstaclesData.MaxObstaclePerPlatform; i++)
{
ObstacleBase obstacle = obstaclesData.ObstacleFactory.GetInstance();
obstacle.transform.SetParent(holder);
obstaclePool.SetInstance(obstacle);
}
}
void OnObstacleEnd(ObstacleBase obstacle)
{
m_obstacles.Remove(obstacle);
obstacle.DestroyAfterFrames(8);
if (m_obstacles.Count == 0)
{
OnStageComplete();
}
}
public void AddObstacle(ObstacleBase newObstacle)
{
if (newObstacle == null)
{
Debug.LogError("Please feed default obstacle for spawning action");
return;
}
GameObject go = Instantiate(newObstacle, m_ObstacleContainer).gameObject;
}
public override void Enable()
{
for (int i = 0; i < Random.Range(obstaclesData.MinObstaclePerPlatform, obstaclesData.MaxObstaclePerPlatform); i++)
{
ObstacleBase currObstacle = obstaclePool.GetInctance();
currObstacle.transform.localPosition = new Vector3(LanePos[Random.Range(0, LanePos.Count)].x, currObstacle.transform.position.y, Random.Range(-4, 5));
currObstacle.gameObject.SetActive(true);
activeObstacleHolder.Add(currObstacle);
}
}
private void OnCollisionEnter2D(Collision2D collision)
{
// if collided object is an obstacle
ObstacleBase obstacle = collision.transform.GetComponent <ObstacleBase>();
if (obstacle != null)
{
obstacle.Interact(collision.relativeVelocity.magnitude);
}
}
IEnumerator CreatObstacle(GameVector2[] _roleGrid)
{
dic_preObstacles = new Dictionary <string, GameObject> ();
GameObject[] preObstacle = Resources.LoadAll <GameObject> ("BattleScene/Obstacle");
foreach (var item in preObstacle)
{
dic_preObstacles [item.name] = item;
}
yield return(new WaitForEndOfFrame());
bool[,] mapGrid = new bool[BattleData.mapRow, BattleData.mapColumn];
foreach (var item in _roleGrid)
{
mapGrid [item.x, item.y] = true;
}
int _creatNum = 0;
for (int i = 0; i < BattleData.mapRow; i++)
{
for (int j = 0; j < BattleData.mapColumn; j++)
{
if (mapGrid [i, j])
{
continue;
}
else
{
obstacleID++;
GameObject _base = Instantiate(dic_preObstacles["ObstacleBase"], obstacleParent);
string _modleStr = "ObsModel";
Instantiate(dic_preObstacles[_modleStr], _base.transform);
GameVector2 _pos = BattleData.Instance.GetMapGridCenterPosition(i, j);
ObstacleBase _obstacle = _base.GetComponent <ObstacleBase> ();
_obstacle.InitData(obstacleID, _pos, 1);
dic_obstacles [obstacleID] = _obstacle;
}
_creatNum++;
if (_creatNum % 3 == 0)
{
yield return(new WaitForEndOfFrame());
}
}
}
initFinish = true;
}
public void Logic_Destory()
{
if (list_brokenObs.Count > 0)
{
for (int i = 0; i < list_brokenObs.Count; i++)
{
ObstacleBase _obs = list_brokenObs [0];
dic_obstacles.Remove(_obs.objShape.ObjUid.objectID);
_obs.DestorySelf();
}
list_brokenObs.Clear();
}
}
private void OnGUI()
{
m_LevelTemplate = EditorGUILayout.ObjectField("Level Template", m_LevelTemplate, typeof(Level), true) as Level;
if (GUILayout.Button("Setup Level"))
{
SetupLevel();
}
GUILayout.Space(10);
m_ObstacleTemplate = EditorGUILayout.ObjectField("Obstacle Template", m_ObstacleTemplate, typeof(ObstacleBase), true) as ObstacleBase;
if (GUILayout.Button("Create Obstacle"))
{
AddObstacle();
}
GUILayout.Space(10);
if (GUILayout.Button("Create EntranceExit Pair"))
{
AddEntranceExitPointPair();
}
}
private void UpdateNoSpawnZone()
{
// highlight blocks in no-spawn zone
if (enemyPrefab != null)
{
EnemyBase enemyBase = enemyPrefab.GetComponentInChildren <EnemyBase>();
float bs = level.blockSize;
float hs = level.blockSize / 2;
float targetY = hs + 0.2f;
// find blocks inside the no spawn zone and add its corners to the list
List <Vector3> noSpawnBlocks = new List <Vector3>(); // TODO maybe replace with set
for (int i = 0; i < level.world.GetLength(0); i++)
{
for (int u = 0; u < level.world.GetLength(1); u++)
{
Transform block = level.world[i, u].transform;
if (InNoSpawnZone(enemyBase, block.position))
{
noSpawnBlocks.Add(block.position);
}
}
}
// filter for blocks that are in the middle and add corners
List <Vector3> noSpawnCorners = new List <Vector3>();
Vector3 minLevel = level.world[0, 0].transform.position;
Vector3 maxLevel = level.world[level.rows - 1, level.lines - 1].transform.position;
for (int i = 0; i < noSpawnBlocks.Count; i++)
{
Vector3 pos = noSpawnBlocks[i];
// get surrounding blocks
bool leftInZone = pos.x > minLevel.x && InNoSpawnZone(enemyBase, pos + new Vector3(-bs, 0, 0));
bool rightInZone = pos.x < maxLevel.x && InNoSpawnZone(enemyBase, pos + new Vector3(+bs, 0, 0));
bool upInZone = pos.z < maxLevel.z && InNoSpawnZone(enemyBase, pos + new Vector3(0, 0, +bs));
bool downInZone = pos.z > minLevel.z && InNoSpawnZone(enemyBase, pos + new Vector3(0, 0, -bs));
// exclude blocks in the middle
if (leftInZone && rightInZone && upInZone && downInZone)
{
continue;
}
// add outer corners
if (!leftInZone)
{
noSpawnCorners.Add(pos + new Vector3(-hs, -pos.y + targetY, +hs));
noSpawnCorners.Add(pos + new Vector3(-hs, -pos.y + targetY, -hs));
}
if (!rightInZone)
{
noSpawnCorners.Add(pos + new Vector3(+hs, -pos.y + targetY, +hs));
noSpawnCorners.Add(pos + new Vector3(+hs, -pos.y + targetY, -hs));
}
if (!upInZone)
{
noSpawnCorners.Add(pos + new Vector3(+hs, -pos.y + targetY, +hs));
noSpawnCorners.Add(pos + new Vector3(-hs, -pos.y + targetY, +hs));
}
if (!downInZone)
{
noSpawnCorners.Add(pos + new Vector3(+hs, -pos.y + targetY, -hs));
noSpawnCorners.Add(pos + new Vector3(-hs, -pos.y + targetY, -hs));
}
}
noSpawnCorners = noSpawnCorners.Distinct().ToList();
// sort them to connect only adjacent corners
List <Vector3> sorted = new List <Vector3>();
sorted.Add(noSpawnCorners[0]);
noSpawnCorners.RemoveAt(0);
int initialCount = noSpawnCorners.Count;
for (int i = 0; i < initialCount; i++)
{
Vector3 last = sorted.Last();
Vector3 platformPos = platform.transform.position;
// find adjacent corners
Vector3?next = noSpawnCorners
.Where(v => (v - last).sqrMagnitude == bs * bs)
.OrderBy(v => (platformPos - v).sqrMagnitude)
.Select(v => new Vector3?(v))
.FirstOrDefault();
if (!next.HasValue)
{
// FIXME this should not happen
//Debug.Log("nope" + last);
continue;
}
if (!sorted.Exists(v => (next.Value - v).sqrMagnitude <= 0.1))
{
sorted.Add(next.Value);
}
noSpawnCorners.Remove(next.Value);
}
// finish circle
sorted.Add(sorted[0]);
// pass corners to line renderer
Vector3[] vertices = sorted.ToArray();
var lr = noSpawnZone.GetComponent <LineRenderer>();
lr.positionCount = vertices.Length;
lr.SetPositions(vertices);
}
// highlight no spawn zone of obstacles
if (obstaclePrefab != null)
{
ObstacleBase ob = obstaclePrefab.GetComponentInChildren <ObstacleBase>();
for (int i = 0; i < level.numPassedRails + ob.minPlatformSpawnDist; i++)
{
level.rail[i].GetChild(1).GetComponent <Renderer>().sharedMaterial = obstacleNoSpawnZoneMaterial;
}
for (int i = level.numPassedRails + ob.minPlatformSpawnDist; i < level.rail.Count; i++)
{
level.rail[i].GetChild(1).GetComponent <Renderer>().sharedMaterial = defaultRailMaterial;
}
}
}
private void CreateObstacleOn(Transform rail)
{
// index of the rail that was clicked
int clickedIndex = level.rail.FindIndex(t => t.position.x == rail.position.x && t.position.z == rail.position.z);
// dont put obstacles behind or inside the platform
if (clickedIndex <= level.numPassedRails)
{
SpawnError("Cannot place behind platform!");
return;
}
// dont put obstacles on already existing obstacles
if (placedObstacles.ContainsKey(clickedIndex))
{
GameObject obstacle = placedObstacles[clickedIndex];
if (obstacle == null)
{
placedObstacles.Remove(clickedIndex); // stored obstacle has been destroyed
}
else
{
SpawnError("Cannot place on obstacle!");
return;
}
}
// get direction between rail blocks
Vector3 currentPosition = level.rail[clickedIndex].transform.position;
Vector3 lastPosition = level.rail[clickedIndex - 1].transform.position;
Quaternion platformDirection = Quaternion.LookRotation(currentPosition - lastPosition);
if (obstaclePrefab == null)
{
SpawnError("No obstacle selected");
return;
}
// get obstacle base
ObstacleBase obstacleBase = obstaclePrefab.GetComponent <ObstacleBase>();
Debug.Assert(obstacleBase != null);
// check if too close to platform
if ((clickedIndex - level.numPassedRails) < obstacleBase.minPlatformSpawnDist)
{
SpawnError("Too close!");
return;
}
// buy obstacle
float cost = obstacleBase.placingCost;
if (spawnResource.SafeChangeValue(-cost))
{
GameObject placed = Instantiate(obstaclePrefab, rail.position, platformDirection);
placedObstacles.Add(clickedIndex, placed);
}
else
{
SpawnError("Not enough money!");
}
}
