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; } }
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; }