public Obstacle FindClosestObstacleForMissile(Vector3 startPosition, LevelObjectType type)
{
Obstacle closest = null;
if (IsCurrentlyActive)
{
int total_count = transform.childCount;
for (int i = 0; i < total_count; i++)
{
ObstacleBlock block = transform.GetChild(i).GetComponent <ObstacleBlock>();
if (block != null)
{
int total_obstacles = block.obstacles.Length;
for (int j = 0; j < total_obstacles; j++)
{
if (block.obstacles[j].gameObject.activeSelf && block.obstacles[j].TypeOfObstacle == type && !SkillsHandler.CheckIfTargetExists(block.obstacles[j].UniqueID))
{
closest = block.obstacles[j];
}
}
}
}
}
return(closest);
}
private static void ApplyDefaultValues(Entity entity, LevelObjectType entityType)
{
if (defaultValueDict.ContainsKey(entityType) == false)
{
Log.Warning("Unable to apply default values for entityType '" + entityType + "'. EntityType not found in database.");
return;
}
Dictionary <string, string> values = defaultValueDict[entityType];
entity.ArmorPoints = short.Parse(values["ArmorPoints"], CultureInfo.InvariantCulture);
entity.AttackRange = double.Parse(values["AttackRange"], CultureInfo.InvariantCulture);
entity.AttackSpeed = double.Parse(values["AttackSpeed"], CultureInfo.InvariantCulture);
entity.AggroRange = double.Parse(values["AggroRange"], CultureInfo.InvariantCulture);
entity.DecayRate = short.Parse(values["DecayRate"], CultureInfo.InvariantCulture);
entity.GoldCost = short.Parse(values["GoldCost"], CultureInfo.InvariantCulture);
entity.IconIndex = int.Parse(values["IconIndex"], CultureInfo.InvariantCulture);
entity.LumberCost = short.Parse(values["LumberCost"], CultureInfo.InvariantCulture);
entity.MaxHitPoints = short.Parse(values["MaxHitPoints"], CultureInfo.InvariantCulture);
entity.MaxMana = short.Parse(values["MaxMana"], CultureInfo.InvariantCulture);
entity.MinDamage = byte.Parse(values["MinDamage"], CultureInfo.InvariantCulture);
entity.RandomDamage = byte.Parse(values["RandomDamage"], CultureInfo.InvariantCulture);
entity.TimeToBuild = short.Parse(values["TimeToBuild"], CultureInfo.InvariantCulture);
entity.VisibleRange = double.Parse(values["VisibleRange"], CultureInfo.InvariantCulture);
entity.WalkSpeed = double.Parse(values["WalkSpeed"], CultureInfo.InvariantCulture);
entity.HitPoints = entity.MaxHitPoints;
entity.Mana = entity.MaxMana;
}
public GameObject GetRandomLevelObject(LevelObjectType levelObjectType)
{
try
{
Theme theme = LevelManager.Instance.CurrentTheme;
for (int i = 0; i < ThemeDatas.Count; i++)
{
if (theme == ThemeDatas[i].Theme)
{
for (int j = 0; j < ThemeDatas[i].LevelObjectDatas.Count; j++)
{
if (ThemeDatas[i].LevelObjectDatas[j].LevelObjectType == levelObjectType)
{
return(ThemeDatas[i].LevelObjectDatas[j]
.ObjectsToCreate[Random.Range(0, ThemeDatas[i]
.LevelObjectDatas[j].ObjectsToCreate.Count)]);
}
}
}
}
Debug.LogError("Theme Level Object is null");
return(null);
}
catch (System.Exception ex)
{
Debug.LogError("Can't find the theme level object " + ex.ToString());
return(null);
}
}
internal bool CreateEntity(int x, int y, LevelObjectType entityType, BasePlayer owner)
{
Log.Write(LogType.Generic, LogSeverity.Debug, "Pathfinder at [" + x + "," + y + "]: " + Pathfinder[x, y]);
Log.Write(LogType.Generic, LogSeverity.Debug, "levelPassable at [" + x + "," + y + "]: " + levelPassable.passableData[x, y]);
if (Pathfinder[x, y] != 0)
{
return(false);
}
Entity newEnt = Entity.CreateEntityFromType(entityType, this);
newEnt.SetPosition(x, y);
entities.Add(newEnt);
if (owner != null)
{
// Neutral entities may not have an owner
owner.ClaimeOwnership(newEnt);
}
newEnt.DidSpawn();
// Add to Pathfinder
Pathfinder.SetFieldsBlocked(x, y, newEnt.TileSizeX, newEnt.TileSizeY);
return(true);
}
public static void AddScore(LevelObjectType type, LevelObjectDifficulty difficulty, int obstacleBlockID)
{
if (type == LevelObjectType.GOOD_BLOCK)
{
currentScore += Mathf.RoundToInt(GetScoreBasedOnID(obstacleBlockID) * comboMultiplier);
}
Debug.Log("Current Score : " + currentScore);
}
/**
* @return Can be null
*/
public ObjectLevelSettings GetObjectSettings(
LevelObjectType objectType)
{
ObjectLevelSettings result = null;
objectSettings.TryGetValue((int)objectType, out result);
return(result);
}
private List <SpawnsInfo> GetSpawnsInfos(
LevelSettings levelSettings,
EnvTypeInfo envTypeInfo,
bool spawnPlayer,
PlayerView player = null)
{
Profiler.BeginSample("LevelGenerator.GetSpawnsInfos()");
LevelObjectType[] objectTypes =
envTypeInfo.SpawnMap.ObjectTypes;
Array.Sort(objectTypes, objectTypeComparer);
spawnsInfosBuffer.Clear();
int objectTypesCount = objectTypes.Length;
for (int i = 0; i < objectTypesCount; ++i)
{
LevelObjectType objectType = objectTypes[i];
ObjectTypeInfo objectTypeInfo =
objectTypeInfoStorage.Get(objectType);
ObjectLevelSettings objectLevelSettings =
levelSettings.GetObjectSettings(objectType);
int spawnsCount = 0;
if (objectType == playerObjectType)
{
spawnsCount = spawnPlayer ? 1 : 0;
spawnPlayer = false;
}
else if (objectLevelSettings != null &&
UnityEngine.Random.value <=
objectLevelSettings.SpawnChance)
{
LevelObjectView objectProto = objectTypeInfo.ProtoInfo.View;
spawnsCount = UnityEngine.Random.Range(
objectLevelSettings.MinSpawnsPerArea,
objectLevelSettings.MaxSpawnsPerArea + 1);
var bonus = objectProto.GetComponent <BonusView>();
if (bonus != null)
{
if (player == null ||
!bonusSpawnResolver.IsTimeToSpawn(
bonus, player))
{
spawnsCount = 0;
}
else
{
bonusSpawnResolver.ActiveBonusObjects +=
spawnsCount;
}
}
}
spawnsInfosBuffer.Add(new SpawnsInfo(objectType, spawnsCount));
}
return(spawnsInfosBuffer);
}
public static Vector2 GetLevelObjectEditorNodeGridSize(LevelObjectType levelObjectType)
{
GenerateableLevelObjectNode levelEditorLevelObjectEditorNode = GetNode(levelObjectType);
Vector2 nodeSize = levelEditorLevelObjectEditorNode.Prefab.transform.localScale;
Vector2 unroundedGridSize = Vector2.one + (nodeSize / LevelEditorGridNodeSizeLibrary.Instance.NodeSize);
Vector2 gridSize = VectorHelper.Floor(unroundedGridSize);
return(gridSize);
}
private void CreateChildSpawners(LevelObjectType type, Level mum, Level dad)
{
SpawnerGroup dadSpawners = dad.GetSpawners(type);
SpawnerGroup mumSpawners = mum.GetSpawners(type);
SpawnerGroup newSpawners = new SpawnerGroup(mumSpawners);
newSpawners.BuildFromParents(mumSpawners, dadSpawners);
m_spawners[(int)type] = newSpawners;
}
public void SetLevelObject(LevelObjectType levelObjectType)
{
this.levelObjectType = levelObjectType;
GenerateableLevelObjectNode levelObjectEditorNode = GenerateableLevelObjectLibrary.GetNode(levelObjectType);
SpriteRenderer levelObjectEditorNodeSpriteRenderer = levelObjectEditorNode.Prefab.GetComponentInChildren <SpriteRenderer>();
GetButton().image.sprite = levelObjectEditorNodeSpriteRenderer.sprite;
GetButton().image.color = levelObjectEditorNodeSpriteRenderer.color;
}
protected override void Execute()
{
LevelObjectType levelObjectType = selectedLevelObjectRef.Get().LevelObjectType;
GenerateableLevelObjectNode generateableLevelObjectNode = GenerateableLevelObjectLibrary.GetNode(levelObjectType);
if (generateableLevelObjectNode.CanCollideWithLevelObjects)
{
Abort();
}
}
public void AddLocalLevelObject(LevelObjectType objectType, Vector3 position)
{
if (objectType == LevelObjectType.Wall)
{
_levelEditorViewModel.wallTilemap.SetTile(VectorUtil.ToVector3Int(position), _levelEditorViewModel.wallRuleTile);
}
else
{
_levelEditorViewModel.localObjects.Add(position, CreateGameObject(objectType, position));
}
}
public void PlaceLevelObjectAndUpdateMaze(BrushType brush, Vector3 position)
{
Vector2Int positionV2Int = VectorUtil.ToVector2Int(position);
if (!_levelEditorViewModel.IsPositionValid(positionV2Int))
{
return;
}
switch (brush)
{
case BrushType.Wall:
{
_levelEditorViewModel.wallTilemap.SetTile(_levelEditorViewModel.mouseTilesetPosition, _levelEditorViewModel.wallRuleTile);
_levelEditorViewModel.currentWorkingLevel.AddLevelObject(LevelObjectType.Wall, positionV2Int);
break;
}
case BrushType.PacMan:
{
_levelEditorViewModel.currentWorkingLevel.pacManPosition = positionV2Int;
_levelEditorViewModel.pacManTransform.position = position;
break;
}
case BrushType.GhostHouse:
{
_levelEditorViewModel.currentWorkingLevel.ghostHousePosition = positionV2Int;
_levelEditorViewModel.ghostHouseTransform.position = position;
break;
}
case BrushType.GhostDoor:
{
_levelEditorViewModel.currentWorkingLevel.ghostDoorPosition = positionV2Int;
_levelEditorViewModel.ghostDoor.position = position;
break;
}
default:
{
if (brush == BrushType.Pellet)
{
_levelEditorViewModel.currentWorkingLevel.pelletCount++;
}
LevelObjectType brushToLevelObjectType = LevelEditorViewModel.BrushToLevelObjectType(brush);
_levelEditorViewModel.currentWorkingLevel.AddLevelObject(brushToLevelObjectType, positionV2Int);
_levelEditorViewModel.localObjects.Add(position, CreateGameObject(brushToLevelObjectType, position));
break;
}
}
}
private void SpawnLevelObjects(List <LevelObjectSaveData> levelObjectsSaveData)
{
foreach (LevelObjectSaveData levelObjectSaveData in levelObjectsSaveData)
{
LevelObjectType levelObjectType = levelObjectSaveData.LevelObjectType;
GenerateableLevelObjectNode levelEditorLevelObjectEditorNode = GenerateableLevelObjectLibrary.GetNode(levelObjectType);
GameObject prefab = levelEditorLevelObjectEditorNode.Prefab;
Vector2 position = levelObjectSaveData.Position;
GameObject levelObjectGameObject = Object.Instantiate(prefab, position, new Quaternion(), levelContainerStatus.LevelContainer);
levelObjectGameObject.transform.localScale = levelObjectSaveData.Size;
}
}
private GameObject LevelObjectTypeToPrefab(LevelObjectType objectType)
{
return(objectType switch
{
LevelObjectType.Blinky => _levelEditorViewModel.blinkyMarkerPrefab,
LevelObjectType.Pinky => _levelEditorViewModel.pinkyMarkerPrefab,
LevelObjectType.Inky => _levelEditorViewModel.inkyMarkerPrefab,
LevelObjectType.Clyde => _levelEditorViewModel.clydeMarkerPrefab,
LevelObjectType.Pellet => _levelEditorViewModel.pelletMarkerPrefab,
LevelObjectType.PowerPellet => _levelEditorViewModel.powerMarkerPrefab,
LevelObjectType.Wall => null,
_ => throw new ArgumentOutOfRangeException(nameof(objectType), objectType, null)
});
private void SpawnLevelObjects(List <LevelObjectSaveData> levelObjectsSaveData)
{
foreach (LevelObjectSaveData levelObjectSaveData in levelObjectsSaveData)
{
LevelObjectType levelObjectType = levelObjectSaveData.LevelObjectType;
GenerateableLevelObjectNode levelEditorLevelObjectEditorNode = GenerateableLevelObjectLibrary.GetNode(levelObjectType);
Vector2 position = levelObjectSaveData.Position;
GameObject levelObject = LevelObjectHelper.InstantiateLevelObject(levelEditorLevelObjectEditorNode, position, context);
levelObject.transform.localScale = levelObjectSaveData.Size;
levelObject.transform.rotation = levelObjectSaveData.Rotation;
}
}
public void OnPlayerHit(out LevelObjectType type)
{
type = TypeOfObstacle;
if (gameObject.activeSelf)
{
if (obstacleBlock != null && TypeOfObstacle == LevelObjectType.GOOD_BLOCK)
{
EffectsController.instance.CameraShake();
DoDestroyEffect();
obstacleBlock.DestroyAllBad();
}
GameEventSystem.RaiseGameEvent(GAME_EVENT.OBSTACLE_HIT, gameObject);
}
}
private void DoMissileSkill(Vector3 startPosition, int skillID)
{
int total_parts = levelController.partsOfLevel.Length;
LevelObjectType type = LevelObjectType.NONE;
GameObject missilePrefab = null;
if (skillID == 1)
{
missilePrefab = BadMissilePrefab;
type = LevelObjectType.BAD_BLOCK;
}
else if (skillID == 2)
{
missilePrefab = GoodMissilePrefab;
type = LevelObjectType.GOOD_BLOCK;
}
else if (type == LevelObjectType.NONE)
{
Debug.LogError("Cant do missile skill : Invalid skill ID");
return;
}
else if (missilePrefab == null)
{
Debug.LogError("Missile Prefab is null");
return;
}
for (int i = 0; i < total_parts; i++)
{
Obstacle closest_obstacle = levelController.partsOfLevel[i].FindClosestObstacleForMissile(startPosition, type);
if (closest_obstacle != null)
{
GameObject go = Instantiate(missilePrefab, startPosition, Quaternion.identity);
ISkill controller = go.GetComponent <ISkill>();
if (controller != null)
{
controller.UseSkill(closest_obstacle);
InventoryHelper.UpdateSkills(skillID, -1);
if (LevelUIManager.instance != null)
{
LevelUIManager.instance.RefreshSkills(skillID);
}
}
else
{
Debug.LogError("ISkill interface not implemented for : " + go.name);
}
}
}
}
protected override void Execute()
{
LevelObjectType levelObjectType = selectedLevelObjectRef.Get().LevelObjectType;
GenerateableLevelObjectNode generateableLevelObjectNode = GenerateableLevelObjectLibrary.GetNode(levelObjectType);
if (SelectedLevelObjectTransformTypeStatusView.TransformType == null)
{
SelectedLevelObjectTransformTypeStatusView.TransformType = generateableLevelObjectNode.GetDefaultLevelObjectInputType();
}
else
{
bool selectedLevelObjectContainsCurrentTransformType = generateableLevelObjectNode.TransformTypes.Contains((LevelObjectTransformType)SelectedLevelObjectTransformTypeStatusView.TransformType);
if (!selectedLevelObjectContainsCurrentTransformType)
{
SelectedLevelObjectTransformTypeStatusView.TransformType = generateableLevelObjectNode.GetDefaultLevelObjectInputType();
}
}
}
/// <summary>
/// Orders this entity to build another entity
/// </summary>
/// <param name="EntityID">The ID of the entity to be built</param>
public void Build(LevelObjectType EntityID)
{
if (!CanBuild)
return;
Log.AI(this, "Building '" + EntityID + "'");
if (StateMachine.CurrentState is StateBuilding)
{
BuildQueue.Enqueue(EntityID);
}
else
{
BuildQueue.Clear();
BuildQueue.Enqueue(EntityID);
StateMachine.ChangeState(new StateBuilding(this));
}
}
private void SpawnLevelObject(LevelObjectType levelObjectType, Vector3 spawnOrigin, LevelObjectSpawnData sd)
{
switch (levelObjectType)
{
case LevelObjectType.Hay:
case LevelObjectType.SuperHay:
for (float xAdjust = sd.startAdjustment; xAdjust < sd.edge; xAdjust += sd.distanceBetween)
{
for (float zAdjust = sd.startAdjustment; zAdjust < sd.edge; zAdjust += sd.distanceBetween)
{
sd.positionModifications = new Vector3(
sd.modifiedPositionIndex + xAdjust,
0,
SpawnDistance + sd.modifiedHeight + zAdjust);
CreateLevelObject(spawnOrigin, sd.positionModifications, levelObjectType, sd.objectIndex);
}
}
break;
case LevelObjectType.EndLevelBlock:
sd.positionModifications = new Vector3(
sd.modifiedPositionIndex,
0,
SpawnDistance + sd.modifiedHeight + LevelEndBlockDistance);
CreateLevelObject(spawnOrigin, sd.positionModifications, levelObjectType, sd.objectIndex);
break;
case LevelObjectType.Rock:
sd.positionModifications = new Vector3(
sd.modifiedPositionIndex,
0,
SpawnDistance + sd.modifiedHeight);
CreateLevelObject(spawnOrigin, sd.positionModifications, levelObjectType, sd.objectIndex);
break;
}
}
/// <summary>
/// Orders this entity to build another entity
/// </summary>
/// <param name="EntityID">The ID of the entity to be built</param>
public void Build(LevelObjectType EntityID)
{
if (!CanBuild)
{
return;
}
Log.AI(this?.ToString(), "Building '" + EntityID + "'");
if (StateMachine.CurrentState is StateBuilding)
{
BuildQueue.Enqueue(EntityID);
}
else
{
BuildQueue.Clear();
BuildQueue.Enqueue(EntityID);
StateMachine.ChangeState(new StateBuilding(this));
}
} // Build(EntityID)
private void Awake()
{
if (gameObject.tag.ToLower() == "good")
{
TypeOfObstacle = LevelObjectType.GOOD_BLOCK;
}
else if (gameObject.tag.ToLower() == "bad")
{
TypeOfObstacle = LevelObjectType.BAD_BLOCK;
}
else if (gameObject.tag.ToLower() == "untagged")
{
TypeOfObstacle = LevelObjectType.NONE;
}
if (obstacleBlock == null)
{
Debug.LogError("Parent of obstacle is null. Object Name : " + gameObject.name + " Parent : " + transform.parent.name);
}
UniqueID = Helper.GenerateID();
}
public void Collide(LevelObjectType levelObjectType, GameObject go, int index, Collider col)
{
switch (levelObjectType)
{
case LevelObjectType.Hay:
GivePoints(10);
CutLevelObject(go, col);
ParticleManagerView.Instance.CreateParticle(go.transform.position, ParticleType.Hay);
break;
case LevelObjectType.Rock:
if (SuperSawActive)
{
CutLevelObject(go, col);
// go.Recycle();
ParticleManagerView.Instance.CreateParticle(go.transform.position, ParticleType.Rock);
}
else
{
EndGame(LevelEndState.Fail, index);
}
BigVibrate();
break;
case LevelObjectType.EndLevelBlock:
EndGame(LevelEndState.Complete, index);
break;
case LevelObjectType.SuperHay:
GivePoints(100);
GatherSuperHay(1);
CutLevelObject(go, col);
ParticleManagerView.Instance.CreateParticle(go.transform.position,
ParticleType.SuperHay);
break;
}
}
private void CreateChildSpawners(LevelObjectType type, Level mum, Level dad)
{
SpawnerGroup dadSpawners = dad.GetSpawners(type);
SpawnerGroup mumSpawners = mum.GetSpawners(type);
SpawnerGroup newSpawners = new SpawnerGroup(mumSpawners);
newSpawners.BuildFromParents(mumSpawners, dadSpawners);
m_spawners[(int)type] = newSpawners;
}
public SpawnsInfo(LevelObjectType objectType, int count)
{
ObjectType = objectType;
Count = count;
}
public static bool Contains(LevelObjectType levelObjectType)
{
bool containsLevelObjectEditorNode = GetInstance().generateableLevelObjectNodes.Exists(x => x.LevelObjectType == levelObjectType);
return(containsLevelObjectEditorNode);
}
public ObjectTypeInfo Get(LevelObjectType type)
{
return(itemsMap[(int)type]);
}
public static GenerateableLevelObjectNode GetNode(LevelObjectType levelObjectType)
{
GenerateableLevelObjectNode levelObjectEditorNode = GetInstance().generateableLevelObjectNodes.Find(x => x.LevelObjectType == levelObjectType);
return(levelObjectEditorNode);
}
private void NewObject()
{
// DebugUtils.Log("LevelAreaGeneratorView.NewObject()");
Profiler.BeginSample("LevelAreaGeneratorView.NewObject()");
LevelObjectType objectType =
spawnsInfos[spawnsInfosIndex].ObjectType;
List <SpawnLocation> spawnLocations =
envTypeInfo.SpawnMap.GetLocations(objectType);
ObjectTypeInfo objectTypeInfo =
objectTypeInfoStorage.Get(objectType);
Vector3 spawnPoint;
SpawnLocation spawnLocation;
bool isFreeSpaceExists = true;
do
{
spawnLocation = spawnLocations[
UnityEngine.Random.Range(0, spawnLocations.Count)];
spawnPoint = GetRandomSpawnPoint(
spawnLocation.Bounds, objectTypeInfo);
if (spawnTriesCount == 0)
{
isFreeSpaceExists = false;
break;
}
--spawnTriesCount;
} while (IsSpawnPointReserved(spawnPoint));
if (isFreeSpaceExists)
{
int objectProtoIndex = UnityEngine.Random.Range(
0, objectTypeInfo.ProtoInfos.Length);
ObjectProtoInfo objectProtoInfo =
objectTypeInfo.ProtoInfos[objectProtoIndex];
LevelObjectView obj = level.NewObject(
objectProtoInfo.View, spawnPoint, area.Index);
InitObject(obj, objectTypeInfo, objectProtoInfo, spawnLocation,
levelSettings);
ReserveSpawnPoint(spawnPoint);
}
--objectsCountToSpawn;
Profiler.EndSample();
if (objectsCountToSpawn <= 0 || spawnTriesCount <= 0)
{
++spawnsInfosIndex;
if (spawnsInfosIndex >= spawnsInfos.Count)
{
CancelInvoke("NewObject");
if (onDone != null)
{
onDone(area);
}
return;
}
NextObjectType();
}
}
public void AddLevelObject(LevelObjectType objectType, Vector2Int position)
{
objectTypes.Add(objectType);
objectPositions.Add(position);
}
public SpawnerGroup GetSpawners(LevelObjectType type)
{
return m_spawners[(int)type];
}
public DrawableLevelObjectType(LevelObjectType type, LevelObjectData data, ServiceManager services)
{
m_lot = type;
m_services = services;
Init(data);
}
public SpawnerGroup GetSpawners(LevelObjectType type)
{
return(m_spawners[(int)type]);
}
internal bool CreateEntity(int x, int y, LevelObjectType entityType, BasePlayer owner)
{
Log.Write(LogType.Generic, LogSeverity.Debug, "Pathfinder at [" + x + "," + y + "]: " + Pathfinder[x, y]);
Log.Write(LogType.Generic, LogSeverity.Debug, "levelPassable at [" + x + "," + y + "]: " + levelPassable.passableData[x, y]);
if (Pathfinder[x, y] != 0)
return false;
Entity newEnt = Entity.CreateEntityFromType (entityType, this);
newEnt.SetPosition (x, y);
entities.Add (newEnt);
if (owner != null)
// Neutral entities may not have an owner
owner.ClaimeOwnership (newEnt);
newEnt.DidSpawn ();
// Add to Pathfinder
Pathfinder.SetFieldsBlocked(x, y, newEnt.TileSizeX, newEnt.TileSizeY);
return true;
}
