private void LoadLevelListContent(LevelConfig config, LevelConfig nextConfig, int i, int count)
{
////设置星星数量
//if(!XPlayerPrefs.HasKey(config.LevelId.ToString()+numStar))
//{
// XPlayerPrefs.SetInt(config.LevelId.ToString() + numStar, 0);
//}
if (config.LevelType == 2)
{
return;
}
//新的主题
if (curTheme != config.LevelTheme)
{
curTheme = config.LevelTheme;
curHeight += offsetMenu;
menu = ResMgr.LoadGameObject(menuPath);
menu.transform.SetParent(LevelContent.transform);
menu.transform.localPosition = Vector3.zero - new Vector3(0, curHeight, 0);
menu.transform.localScale = LevelContent.localScale;
LoadMenu(menu, config.LevelTheme);
themeCnt++;
levelCnt = 0;
}
int cnt = levelCnt % 3;
if (cnt == 0)
{
curHeight += offsetY;
}
levelBtn = ResMgr.LoadGameObject(levelBtnPath);
levelBtn.transform.SetParent(LevelContent.transform);
levelBtn.transform.localPosition = Vector3.zero - new Vector3((cnt - 1) * offsetX * -1, curHeight, 0);
levelBtn.transform.localScale = LevelContent.localScale;
UILevelBtn UIBtn = levelBtn.GetComponent <UILevelBtn>();
if (cnt == 1)
{
UIBtn.line.SetActive(true);
}
LoadLevelBtn(UIBtn, config.LevelId, config.LevelPicture.ToString(), levelCnt, themeCnt);
UIBtn.setLevelID(config.LevelId);
UIBtn.setThemeID(config.LevelTheme);
//if (count > i + 1)
//{
// UIBtn.setNextLevelID(config.LevelId+1);
// if (config.LevelTheme != nextConfig.LevelTheme)
// UIBtn.setNextThemeID(nextConfig.LevelTheme);
// else
// UIBtn.setNextThemeID(config.LevelTheme);
//}
//else
//{
// UIBtn.setNextLevelID(0);
// UIBtn.setNextThemeID("null");
//}
levelCnt++;
}
void Start()
{
level = GameData.actualLevel.config;
SetRestPlaces();
StartCoroutine(SendTouristWave());
StartCoroutine(SendEnemytWave());
}
private void RefreshLevelList()
{
SetScrollValue();
SetTopText();
int levelCnt = 0;
int themeCnt = 0;
for (int i = 0; i < LevelContent.gameObject.transform.childCount; i++)
{
if (LevelContent.gameObject.transform.GetChild(i).name == "menu(Clone)")
{
themeCnt++;
levelCnt = 0;
}
if (LevelContent.gameObject.transform.GetChild(i).name == "UILevelBtn(Clone)")
{
UILevelBtn uibtn = LevelContent.gameObject.transform.GetChild(i).GetComponent <UILevelBtn>();
if (levelCnt == 1)
{
uibtn.line.SetActive(true);
}
LevelConfig config = LevelMgr.GetInstance().GetLevelConfig(uibtn.levelID).Config;
LoadLevelBtn(uibtn, config.LevelId, config.LevelPicture.ToString(), levelCnt, themeCnt);
}
}
}
public void RenderNumberTest()
{
var instance = new LevelConfig
{
NumberingFormat = NumberFormatValues.Decimal
};
Assert.AreEqual("1", instance.RenderNumber(1));
instance.NumberingFormat = NumberFormatValues.Ordinal;
Assert.AreEqual("1st", instance.RenderNumber(1));
instance.NumberingFormat = NumberFormatValues.OrdinalText;
Assert.AreEqual("one", instance.RenderNumber(1));
instance.NumberingFormat = NumberFormatValues.LowerRoman;
Assert.AreEqual("i", instance.RenderNumber(1));
instance.NumberingFormat = NumberFormatValues.UpperRoman;
Assert.AreEqual("I", instance.RenderNumber(1));
instance.NumberingFormat = NumberFormatValues.LowerLetter;
Assert.AreEqual("a", instance.RenderNumber(1));
instance.NumberingFormat = NumberFormatValues.UpperLetter;
Assert.AreEqual("A", instance.RenderNumber(1));
}
public Level(int _number, LevelConfig _config, int _minPoints, int _totalTime)
{
number = _number;
config = _config;
minPoints = _minPoints;
totalTime = _totalTime;
}
public void LoadLevel()
{
string content = (Resources.Load("levels") as TextAsset).text;
if (string.IsNullOrEmpty(content))
{
Debug.LogError("content == null");
return;
}
LevelConfig config = JsonConvert.DeserializeObject <LevelConfig>(content);
foreach (var level in config.levels)
{
this.AddLevel(level);
}
if (!PlayerPrefs.HasKey(CommonDefineBase.LockedLevel))
{
PlayerPrefs.SetString(CommonDefineBase.LockedLevel, "1");
}
string[] levelsContent = PlayerPrefs.GetString(CommonDefineBase.LockedLevel).Split(',');
foreach (var id in levelsContent)
{
int levelId = int.Parse(id);
if (this.dicLevels.ContainsKey(levelId))
{
this.dicLevels[levelId].valid = true;
}
}
}
void OnLevelStarted(int levelIdx, LevelConfig leveConfig, float startDelay)
{
MusicToggle?.RefreshMusicToggle();
if (_endPanel.activeInHierarchy)
{
_endPanel.SetActive(false);
}
RefreshFatigue(_gameController.FatiguePercent);
RefreshTime(_gameController.TimeLeft);
RefreshIncome(_gameController.Earnings);
if (GameBeaten.activeInHierarchy)
{
GameBeaten.SetActive(false);
}
StartPanel.SetActive(true);
StartLevelText.text = $"Level {levelIdx + 1}";
StartLevelDesc.text = leveConfig.DescriptionStart;
foreach (var hint in Hints)
{
hint.gameObject.SetActive(false);
}
bool immediate = Mathf.Approximately(startDelay, 0f);
InputHint.SetActive(immediate);
if (!immediate)
{
StartCoroutine(DelayedShow(InputHint, startDelay));
}
}
void GenerateRandomParameters()
{
Random.InitState(1);
Settings settings = Refs.Instance.Settings;
for (int i = 0; i < settings.Levels.Count; i++)
{
LevelConfig levelConfig = settings.Levels[i];
levelConfig.Seed = Random.Range(int.MinValue, int.MaxValue); // This is the main part
/*
* levelConfig.AsteroidsRate = Random.Range( .5f, .25f );
* levelConfig.Time = Random.Range( 10f, 30f );
*/
float t = i / (settings.Levels.Count - 1f);
levelConfig.AsteroidsRate = Mathf.Lerp(.25f, .025f, t);
levelConfig.Time = Mathf.Lerp(10, 30, t);
}
#if UNITY_EDITOR
EditorUtility.SetDirty(settings);
#endif
}
/// <summary>
/// Generate a new puzzle with some rows. This assumes the puzzle is empty.
/// </summary>
public void InitializeNewPuzzle(int initialRows, LevelConfig config)
{
int width = DefaultPuzzleWidth;
int height = DefaultPuzzleHeight;
// Create a new puzzle.
PuzzleGrid = new PuzzleTile[width, 1000];
ResetPuzzle();
// Set some of the variables from the config.
VerticalScrollSpeed = config.ScrollSpeed;
m_shouldSpawnJunk = config.SpawnJunkTiles;
m_shouldSpawnAlarms = config.SpawnAlarmTiles;
ScoreToWin = config.ScoreToWin;
GameManager.Instance.GameCanvas.UpdateTargetScore(ScoreToWin);
m_junkDropRate = config.JunkDropRateSeconds;
// Row 0 is the top, the bottom at the start is equal to the height. Generate 1 row past that.
int bottomRow = height + 1;
// Iterate through the first few initial rows.
int rowsToAdd = initialRows;
for (int row = bottomRow - rowsToAdd; row <= bottomRow; row++)
{
bool isLastRow = row >= bottomRow;
GenerateRow(row, width, isLastRow);
}
}
//initializes level values
public void initialize()
{
damageTaken = 0;
damageDealt = 0;
numDogsDied = 0;
dead = new bool[3] {
false, false, false
};
newLevel = brrrr.myCoolLevel;
playa = brrrr.myCoolPlayer;
NMEs = new Queue <EnemyStatsConfig>(newLevel.enemies);
dogs = playa.yourTeam;
chews = playa.yourPack;
background = newLevel.background;
backgroundSpriteRenderer = GetComponent <SpriteRenderer>();
backgroundSpriteRenderer.sprite = background;
howManyDogs = 0;
for (int i = 0; i < dogs.Length; i++)
{
if (dogs[i] != null)
{
howManyDogs++;
}
}
}
public static Config CreateNewConfig()
{
Config config = new Config
{
Id = 0,
Name = "Nazwa",
CreationDate = DateTime.Now,
DrawStartPoint = true,
NrOfLevels = 2,
WaitingTime = 3f,
Levels = new List <LevelConfig>()
};
var level1 = new LevelConfig {
levelNumber = 1, shape = Shape.HorizontalLine, lineStroke = LineStroke.Medium, shapeColor = PastelColorFactory.RandomColor
};
level1.brushColor = PastelColorFactory.RandomColorWithExclude(level1.shapeColor);
config.Levels.Add(level1);
var level2 = new LevelConfig {
levelNumber = 2, shape = Shape.VerticalLine, lineStroke = LineStroke.Medium, shapeColor = PastelColorFactory.RandomColor
};
level2.brushColor = PastelColorFactory.RandomColorWithExclude(level2.shapeColor);
config.Levels.Add(level2);
return(config);
}
// 0 -- PlayScene
public void LoadPlayScene(LevelData levelData, string songScript = null)
{
if (!_CheckInput(PlaySceneName))
{
return;
}
if (!LevelConfig.CheckEnergy())
{
return;
}
m_LoadingPlayScene = true;
StaticData.LevelID = levelData.levelID;
StaticData.NowLevelData = levelData;
CorePlayData.SongID = LanguageManager.GetSongIdFromLanguage(levelData.songID);
if (string.IsNullOrEmpty(songScript))
{
CorePlayData.SongScript = SongConfig.Instance.GetsongScriptBySongIDAndLevelDiffculty(LanguageManager.GetSongIdFromLanguage(levelData.songID), levelData.LevelDifficulty);
}
else
{
CorePlayData.SongScript = songScript;
}
CorePlayData.SongOffset = SongConfig.Instance.GetSongOffsetBySongIDAndLevelDiffculty(LanguageManager.GetSongIdFromLanguage(levelData.songID), levelData.LevelDifficulty);
CorePlayData.CurrentSong = BeatmapParse.Parse(CorePlayData.SongScript);
CorePlayData.BossLife = levelData.bosslife;
CorePlayData.BossSongName = LevelConfig.AllLevelDic[levelData.levelID].boss_song_name;
CorePlayData.EducationText = SongConfig.Instance.m_items[LanguageManager.GetSongIdFromLanguage(levelData.songID)]["educationText"];
StartCoroutine(_LoadSceneAsyncInternal());
}
public void LoadBaseLevel()
{
loading = true;
MazeRoom mainRoom = new MazeRoom(new Rect(5, 5, 11, 11));
LevelDepthConfig depthConfig = generalLevelConfig.GetLevelDepthConfiguration(-1);
LevelConfig levelConfig = Resources.Load <LevelConfig>("LevelConfigs/base");
levelConfig.Randomize();
MapGenerator.Initialize(levelConfig, depthConfig, ReadyWithBase);
//MazeCarver carver = mapGenerator.InitializeCarver(worldRect, mapGenerator, levelConfig, depthConfig);
MazeCarver carver = MapGenerator.InitializeCarver();
MapGenerator.PlaceRoom(mainRoom);
carver.FillWithHallway();
//carver.RemoveFalseWalls();
carver.Create3DWalls();
carver.CreateNavMeshes();
mapPopulator = MapGenerator.InitializeMapPopulator();
//mapPopulator.SpawnKeyAt(mapGenerator.GetScaled(new Vector3(10, 10, 0)));
SpawnWandAt(new Vector3(9, 9, 0), depthConfig.PowerLevel);
SpawnWandAt(new Vector3(7, 9, 0), depthConfig.PowerLevel);
SpawnWandAt(new Vector3(9, 7, 0), depthConfig.PowerLevel);
Dummy dummyPrefab = Resources.Load <Dummy>("Dummy");
Dummy dummy = Instantiate(dummyPrefab, MapGenerator.transform);
dummy.transform.position = MapGenerator.GetScaled(new Vector3(13, 13, 0));
mapPopulator.SpawnEndAt(MapGenerator.GetScaled(new Vector3(10, 10, 0)));
player = mapPopulator.SpawnPlayerAt(MapGenerator.GetScaled(new Vector3(7, 7, 0)));
mapPopulator.SetUpCamera(player);
//fullscreenFade.FadeOut(ReadyWithBase);
}
static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
{
foreach (string asset in importedAssets)
{
if (!filePath.Equals(asset))
{
continue;
}
LevelConfig data = (LevelConfig)AssetDatabase.LoadAssetAtPath(assetFilePath, typeof(LevelConfig));
if (data == null)
{
data = ScriptableObject.CreateInstance <LevelConfig> ();
data.SheetName = filePath;
data.WorksheetName = sheetName;
AssetDatabase.CreateAsset((ScriptableObject)data, assetFilePath);
//data.hideFlags = HideFlags.NotEditable;
}
//data.dataArray = new ExcelQuery(filePath, sheetName).Deserialize<LevelConfigData>().ToArray();
//ScriptableObject obj = AssetDatabase.LoadAssetAtPath (assetFilePath, typeof(ScriptableObject)) as ScriptableObject;
//EditorUtility.SetDirty (obj);
ExcelQuery query = new ExcelQuery(filePath, sheetName);
if (query != null && query.IsValid())
{
data.dataArray = query.Deserialize <LevelConfigData>().ToArray();
ScriptableObject obj = AssetDatabase.LoadAssetAtPath(assetFilePath, typeof(ScriptableObject)) as ScriptableObject;
EditorUtility.SetDirty(obj);
}
}
}
public void SetMapId(int mapId)
{
CurrentLevelType = LevelType.Exception;
BigMapParameters = null;
SmallMapParameters = null;
foreach (var levelInfo in Data.Items)
{
if (levelInfo.Id == mapId)
{
SceneParameters = levelInfo;
if (levelInfo is SceneConfig)
{
CurrentLevelType = LevelType.BigMap;
BigMapParameters = levelInfo as SceneConfig;
}
else
{
CurrentLevelType = LevelType.SmallMap;
SmallMapParameters = levelInfo as LevelConfig;
}
break;
}
}
}
void Start()
{
if (PlayerPrefs.HasKey("FinishedLevels"))
{
FinishedLevels = PlayerPrefs.GetInt("FinishedLevels", 0);
}
else
{
PlayerPrefs.SetInt("FinishedLevels", 0);
PlayerPrefs.Save();
}
TextAsset levelConfigContent = Resources.Load <TextAsset>("Config/levels");
LevelConfig levelConfig = JsonUtility.FromJson <LevelConfig>(levelConfigContent.text);
for (int i = 0; i < levelConfig.levels.Count; i++)
{
GameObject newButton = Instantiate(LevelButtonPrefab);
newButton.GetComponentInChildren <TextMeshProUGUI>().text = $"{i+1}";
newButton.transform.SetParent(Panel.transform);
int index = i;
newButton.GetComponent <Button>().onClick.AddListener(() => LoadLevel(index));
if (FinishedLevels < i)
{
newButton.GetComponent <Button>().interactable = false;
}
}
}
private void StartLevel()
{
_currentLevel = GameSettings.Instance.Levels[_currentLevelIndex % GameSettings.Instance.Levels.Count];
_currentCylinderCount = _totalCylinderCount = _currentLevel.GetCylinderCount();
AdjustPlatformSize();
_towerManager.SpawnTower(_currentLevel);
}
public static void StartLevel(int levelIndex)
{
_levelIndex = levelIndex;
LevelConfig levelConfig = Refs.Instance.Settings.Levels[levelIndex];
Random.InitState(levelConfig.Seed);
// Spawn Ship
SpawnShip();
// Init Asteroid spawning
_asteroidSpawner = Observable
.Interval(TimeSpan.FromSeconds(Refs.Instance.Settings.AsteroidsSpawnRate))
.Subscribe(_ => Spawner.SpawnAsteroid());
// Init Level Timer
float time = levelConfig.Time;
TimerEndTime.Value = Time.time + time;
_timer = Observable
.Timer(TimeSpan.FromSeconds(time))
.Subscribe(_ => OnTimerOut());
// Change State
Transition(LevelState.InProcess);
}
/// <summary>
/// m_config排序
/// </summary>
private void SortConfig()
{
//第一遍排序按照关卡id
for (int i = 0; i < m_config.Items.Count; i++)
{
for (int j = 0; j < m_config.Items.Count - i - 1; j++)
{
if (m_config.Items[j].LevelId > m_config.Items[j + 1].LevelId)
{
LevelConfig temp = m_config.Items[j];
m_config.Items[j] = m_config.Items[j + 1];
m_config.Items[j + 1] = temp;
}
}
}
//第二遍排序按照主题id
for (int i = 0; i < m_config.Items.Count; i++)
{
for (int j = 0; j < m_config.Items.Count - i - 1; j++)
{
if (string.Compare(m_config.Items[j].LevelTheme, m_config.Items[j + 1].LevelTheme) == 1)
{
LevelConfig temp = m_config.Items[j];
m_config.Items[j] = m_config.Items[j + 1];
m_config.Items[j + 1] = temp;
}
}
}
}
// check and save achievement,返回是否升级
private void CheckNum(int id, int num, int oldNum, bool checkLevel)
{
int needNum = this.GetAchievementNeedNum(id);
if (needNum == -1)
{
return;
}
if (num >= needNum) // passed
{
SetAchievement(id, true);
// 播放通过条件动画
AniInfo aniInfo = new AniInfo(AniConditionPass);
string txt = LevelConfig.GetAchievement(id).GetNumText(this.GetAchievementNeedNum(id, true));
this.PlayAni(aniInfo.AddParam("condition", txt));
if (checkLevel)
{
this.CheckLevel(); // 检查等级
}
}
else if (id != 3003)
{
// 播放进度动画
string txt = LevelConfig.GetAchievement(id).GetNumText(this.GetAchievementNeedNum(id, true));
AniInfo aniInfo = new AniInfo(AniConditionProgress);
this.PlayAni(aniInfo.AddParam("condition", txt).AddParam("oldNum", oldNum.ToString()).AddParam("newNum", num.ToString()));
}
}
/**
* Main scene configuring function
*/
void OnSceneLoaded(Scene scene, LoadSceneMode mode)
{
//loading screen
if (scene.buildIndex == 3)
{
TextMesh levelNum = GameObject.Find("/Number").GetComponent <TextMesh>();
levelNum.text = "" + Level;
StartCoroutine(LoadScreen());
return;
}
// level config reading and setting up
string path = "Assets/Levels/level" + Level + ".json"; //todo: encrypt & decrypt file!!!
StreamReader reader = new StreamReader(path);
string jsonData = reader.ReadToEnd();
reader.Close();
LevelConfig conf = JsonUtility.FromJson <LevelConfig>(jsonData);
//todo: make separate setup functions for enemy and level in Level class
//todo: add more level config properties
GameObject levelObj = GameObject.FindGameObjectWithTag("Level");
Level levelScript = levelObj.GetComponent <Level>();
levelScript.points = conf.points;
levelScript.currentLevel = Level;
levelScript.playerScore = GameObject.Find("/DeadZone/Back"); // setting score objects for dynamical update
levelScript.enemyScore = GameObject.Find("/DeadZone/Front");
GameObject enemyObj = GameObject.FindGameObjectWithTag("Enemy");
enemyObj.GetComponent <Enemy>().speed = conf.aispeed;
}
public void Save()
{
var levelSettings = FindObjectOfType(typeof(LevelSettingsForSave)) as LevelSettingsForSave;
if (!levelSettings)
{
Debug.LogError("Please, use one active LevelSettingsForSave script on a GameObject in your scene.");
return;
}
Level = ScriptableObject.CreateInstance <LevelConfig>();
AssetDatabase.CreateAsset(Level, "Assets/Resources/Levels/" + levelName + ".asset");
EditorUtility.SetDirty(Level);
var objectsList = Utils.FindGameObjectsWithTags("WalkableArea", "Obstacle", "Platform", "Spawner", "Base");
var towerPrefabs = levelSettings.TowerPrefabs;
var pools = levelSettings.Pools;
Level.Objects = new LevelConfig.PrefabData[objectsList.Count];
for (int i = 0; i < objectsList.Count; ++i)
{
var obj = objectsList[i];
Level.Objects[i] = new LevelConfig.PrefabData
{
Prefab = (GameObject)PrefabUtility.GetPrefabParent(obj.gameObject),
Position = obj.transform.position,
Size = obj.transform.localScale,
Rotation = obj.transform.rotation
};
Level.Settings = levelSettings.GameSettings;
Level.TowerPrefabs = towerPrefabs;
Level.PoolsParts = pools;
}
}
static void PrintMapInfo(Player p, LevelConfig cfg)
{
p.Message("%TPhysics settings:");
p.Message(" Finite mode: {0}%S, Random flow: {1}",
GetBool(cfg.FiniteLiquids), GetBool(cfg.RandomFlow));
p.Message(" Animal hunt AI: {0}%S, Edge water: {1}",
GetBool(cfg.AnimalHuntAI), GetBool(cfg.EdgeWater));
p.Message(" Grass growing: {0}%S, {1} tree growing: {2}",
GetBool(cfg.GrassGrow), cfg.TreeType.Capitalize(), GetBool(cfg.GrowTrees));
p.Message(" Leaf decay: {0}%S, Physics overload: {1}",
GetBool(cfg.LeafDecay), cfg.PhysicsOverload);
p.Message(" Physics speed: &b{0} %Smilliseconds between ticks",
cfg.PhysicsSpeed);
p.Message("%TSurvival settings:");
p.Message(" Survival death: {0} %S(Fall: {1}, Drown: {2})",
GetBool(cfg.SurvivalDeath), cfg.FallHeight, cfg.DrownTime);
p.Message(" Guns: {0}%S, Killer blocks: {1}",
GetBool(cfg.Guns), GetBool(cfg.KillerBlocks));
p.Message("%TGeneral settings:");
p.Message(" MOTD: &b" + cfg.MOTD);
p.Message(" Local level only chat: " + GetBool(!cfg.ServerWideChat));
p.Message(" Load on /goto: {0}%S, Auto unload: {1}",
GetBool(cfg.LoadOnGoto), GetBool(cfg.AutoUnload));
p.Message(" Buildable: {0}%S, Deletable: {1}%S, Drawing: {2}",
GetBool(cfg.Buildable), GetBool(cfg.Deletable), GetBool(cfg.Drawing));
}
public GameObject CreateEnemy(GameObject playerGM, int enemyNumber, int levelNumber)
{
GameObject enemyGM = null;
if (levelNumber < Levels.Count)
{
LevelConfig level = Levels [levelNumber];
if (enemyNumber < level.ListOfEnemies.Count)
{
CharacterConfig charConfig = level.ListOfEnemies [enemyNumber].CharacterConfig;
RuntimeAnimatorController rac = Resources.Load <RuntimeAnimatorController> ("enemyAnimation");
enemyGM = CreateCharacter(charConfig, rac);
enemyGM.GetComponent <InGamePosition> ().X = playerGM.GetComponent <InGamePosition> ().X + 5;
Character playerCh = playerGM.GetComponent <Character> ();
playerCh.leftHand.GetComponent <InputContr> ().Enemy = enemyGM;
playerCh.rightHand.GetComponent <InputContr> ().Enemy = enemyGM;
AI ai = enemyGM.AddComponent <AI> ();
ai.Delay = 1f;
ai.SetChances(60, 20);
ai.Enemy = playerGM;
}
}
return(enemyGM);
}
void LoadLevel()
{
LevelConfig levelConfig = chapterConfig.levels[CurrentLevel];
List <Enemy> newEnemyList = levelBuilder.BuildLevel(levelConfig);
enemiesCount = newEnemyList.Count;
// Init Controllers
enemyMoveManager.Init(levelConfig.enemyConfig, newEnemyList);
enemyShootManager.Init(levelConfig, newEnemyList);
uiGameManager.Init(levelConfig.playerConfig.lives);
// Callbacks
levelBuilder.Player.onPlayerHit += OnPlayerHit;
levelBuilder.Player.onPlayerHit += uiGameManager.OnPlayerHit;
enemyMoveManager.onEnemyReachedLimit += Lose;
foreach (Enemy enemy in newEnemyList)
{
enemy.onEnemyKilled += OnEnemyKilled;
}
StartCoroutine(StartLevelCoroutine());
}
private void CreateObstacles(LevelConfig config)
{
for (int i = 0; i < config.GetPositions().Count; i++)
{
var temp = InstantiatePlatform(config.GetObstacleConfig()[i],
config.GetPositions()[i] + new Vector3(0, 16, 0),
config.GetObstacleScales()[i]);
temp.GetComponent <SpriteRenderer>().sortingLayerName = "Obstacle";
temp.transform.rotation = Quaternion.Euler(config.GetObstacleRotations()[i].x,
config.GetObstacleRotations()[i].y,
config.GetObstacleRotations()[i].z);
if (config.GetBreakCount()[i] != 0)
{
temp.AddComponent(typeof(Breakable));
if (!config.DependsOnPrevBallCount())
{
temp.GetComponent <Breakable>().SetBreakCount(config.GetBreakCount()[i]);
}
else
{
temp.GetComponent <Breakable>().SetBreakCount((FindObjectOfType <Target>().GetCount() / 3) + 1);
}
}
platforms.Add(temp);
}
}
public override void Use(Player p, string message)
{
string[] urls = message.SplitSpaces(2);
if (urls.Length < 2)
{
Help(p); return;
}
int changed = 0;
string[] maps = LevelInfo.AllMapNames();
Level lvl;
foreach (string map in maps)
{
LevelConfig cfg = LevelInfo.GetConfig(map, out lvl);
if (cfg.Terrain.CaselessEq(urls[0]))
{
p.Message("Changed terrain.png of map " + cfg.Color + map);
cfg.Terrain = urls[1];
cfg.SaveFor(map);
changed++;
}
else if (cfg.TexturePack.CaselessEq(urls[0]))
{
p.Message("Changed texture pack of map " + cfg.Color + map);
cfg.TexturePack = urls[1];
cfg.SaveFor(map);
changed++;
}
}
p.Message("Gone through all the maps. {0} were changed. ");
}
public async Task AddRole(IRole role, int level)
{
var config = LevelService.TryGetLevelConfig(Context.Guild.Id);
if (config == null || !config.Enabled)
{
await ReplyAsync("You must enable leveling before editing it's settings.");
return;
}
//Remove the role if it already exists in the rewards
config.RewardRoles = config.RewardRoles.Where(x => x.RoleId != role.Id).ToList();
if (config.RewardRoles.Any(x => x.LevelRequirement == level))
{
await ReplyAsync("There can only be one role per level.");
return;
}
config.RewardRoles.Add(new LevelConfig.LevelReward
{
RoleId = role.Id,
LevelRequirement = level
});
LevelService.Database.Store(config, LevelConfig.DocumentName(Context.Guild.Id));
await ReplyAsync($"Role Added");
}
private void Initialize()
{
_score = 0;
_levelConfig = new LevelConfig();
InitializeLocation();
_floor.Initialize(OnEnemyLeftArea);
Player = new Player();
Player.Initialize(_levelConfig.PlayerConfig, _levelConfig.ProjectileConfig);
CameraController cameraController = _cameraController.GetComponent <CameraController>();
cameraController.Initialize(this, Player.View.transform, _levelConfig.CameraConfig);
_enemyPool = new EnemyPool(this, _levelConfig.EnemyConfig, _spawnPoints);
_enemyPool.Initialize();
EventManager.OnEnemyDied += OnEnemyDied;
_gui.Initialize(_levelConfig.PlayerConfig);
_spawnController = Observable.FromCoroutine(SpawnEnemy).Subscribe();
}
public ChunkGenerator(LevelConfig config, LevelObjectsPool pool, int length, int width)
{
levelConfig = config;
levelObjectsPool = pool;
this.length = Mathf.Max(length, LevelGraph.MinLength);
this.width = Mathf.Max(width, LevelGraph.MinWidth);
}
public void Init(LevelConfig levelConfig, CameraController cameraController)
{
var terrain = Instantiate(levelConfig.terrainToSpawn, Vector2.zero, Quaternion.identity);
var playerChar = Instantiate (_playerCharacter, levelConfig.diggerSpawnPoint, Quaternion.identity) as Character;
var playerView = Instantiate (_playerCharacterView, levelConfig.diggerSpawnPoint, Quaternion.identity) as View;
var cave = Instantiate(_cave, levelConfig.caveSpawnPoint, Quaternion.identity) as CaveBehaviour;
PlayerVariablesController.Instance.Init (playerChar.unit, PlayerVariablesController.Instance.BeardyStats);
playerChar.Init (PlayerVariablesController.Instance.BeardyStats, playerView);
cameraController.Init (playerChar);
cave.Init(levelConfig.diamondsCountToPassLevel);
PreviousTilePosition = Vector2.zero;
}
public void Load()
{
if (!loaded)
loaded = true;
else
return;
WarriorXlsData = new WarriorConfig("Hero", "ID");
WarriorXlsData.Load();
SkillXlsData = new SkillConfig("Skill", 10001, 19999);
SkillXlsData.Load();
ExpSetXlsData = new XlsData("ExpSet", "Lv");
ExpSetXlsData.Load();
NatureXlsData = new NatureConfig("Nature", "ID");
NatureXlsData.Load();
AvatarXlsData = new XlsData("Avatar", "ID");
AvatarXlsData.Load();
GradeSetupXlsData = new GradeSetupConfig("GradeSetup", "ID");
GradeSetupXlsData.Load();
BuffXlsData = new XlsData("Buff", "ID");
BuffXlsData.Load();
LevelXlsData = new LevelConfig("Level", 1001, 9999);
LevelXlsData.Load();
LevelNpcXlsData = new LevelNpcConfig("LevelSet", 1001, 9999);
LevelNpcXlsData.Load();
LevelBgXlsData = new LevelBgConfig("LevelScene", 1001, 9999);
LevelBgXlsData.Load();
}
void OnEnable()
{
config = (LevelConfig)target;
}
void ShowLevelDetails()
{
if (curLevel == null)
{
//find in scene and set
curLevel = GameObject.FindObjectOfType(typeof(LevelConfig)) as LevelConfig;
//set to last data
if (curLevel)
{
select.curChapterIndex = EditorPrefs.GetInt(KEY_LCChapterIndex, select.curChapterIndex);
select.curDungeonIndex = EditorPrefs.GetInt(KEY_LCDungeonIndex, select.curDungeonIndex);
select.curConfigIndex = EditorPrefs.GetInt(KEY_LCTableIndex, select.curConfigIndex);
}
}
#region level prefab
GUILayout.BeginHorizontal();
string resName = select.prbMapRes ? "Res:" : select.curDungeon.resname;
GUILayout.Label(resName);
bool hasRes = EditorGUILayout.ObjectField("", select.prbMapRes, typeof(Object), false);
if (!hasRes) return;
bool hasConfig = select.prbLevelConfig;
if (!hasConfig)
{
if (select.prbModelConfig && GUILayout.Button("Create Config"))
{
CreateConfigPrefab();
}
}
else
{
GUILayout.Label("Config:");
EditorGUILayout.ObjectField("", select.prbLevelConfig, typeof(Object), false);
//if (curLevel != null && curLevel.name == select.prbLevelConfig.name)
//{
// if (GUILayout.Button("Edit")) EditLevel();
//}
if (GUILayout.Button("Show In Scene"))
{
LoadLevelToScene();
}
//, GUILayout.MinWidth(200f)
if (GUILayout.Button("ReLoad Json", GUILayout.MaxWidth(100f)))
{
ReLoadJson();
}
}
GUILayout.EndHorizontal();
#endregion
if (curLevel == null) return;
GUILayout.BeginHorizontal();
if (GUILayout.Button("Save"))
{
SaveLevel();
}
if (GUILayout.Button("Edit", GUILayout.MaxWidth(100f)))
{
KMTools.SetActive(curLevel.gameObject, true);
EditLevel();
}
GUILayout.EndHorizontal();
if (KMInspectorEditor.DrawHeader("Position Edit"))
{
ShowPositions();
}
EditorGUILayout.Space();
if (KMInspectorEditor.DrawHeader("Stage Actions"))
{
ShowLevelActions();
}
EditorGUILayout.Space();
if (KMInspectorEditor.DrawHeader("External Event"))
{
ShowExternalEvent();
}
EditorGUILayout.Space();
if (KMInspectorEditor.DrawHeader("Other------"))
{
ShowOther();
}
}
void LoadLevelToScene()
{
if (curLevel != null)
{
curLevel.gameObject.SetActive(false);
}
LevelConfig lc = GetExistLevel(select.prbLevelConfig.name);
if (lc != null)
{
lc.gameObject.SetActive(true);
curLevel = lc;
}
else
{
GameObject go = KMPrefabEditor.LoadPrefab(select.prbLevelConfig, null);
go.transform.parent = goParent.transform;
curLevel = go.GetComponent<LevelConfig>();
}
if (curRes) DestroyImmediate(curRes.gameObject);
curRes = KMPrefabEditor.LoadPrefab(select.prbMapRes, null);
targetPrefab = select.prbLevelConfig;
//save data form last load
EditorPrefs.SetInt(KEY_LCTableIndex, select.curConfigIndex);
EditorPrefs.SetInt(KEY_LCDungeonIndex, select.curDungeonIndex);
EditorPrefs.SetInt(KEY_LCChapterIndex, select.curChapterIndex);
}
/// <summary>
/// Retrieves the level of a sample, stream, MOD music, or recording channel.
/// </summary>
/// <param name="config">Level configure.</param>
/// <param name="length">
/// The amount of data to inspect to calculate the level, in seconds. The maximum is 1 second. Less
/// data than requested may be used if the full amount is not available, eg. if the channel's playback buffer is
/// shorter.
/// </param>
/// <returns>An array to receive the levels. </returns>
public float[] GetLevelEx(LevelConfig config, float length)
{
CheckAvailable();
float[] result = null;
if (config.HasFlag(LevelConfig.Mono))
{
result = new float[1];
}
else if (config.HasFlag(LevelConfig.Stereo))
{
result = new float[2];
}
else
{
result = new float[Information.Channels];
}
GCHandle resultHandle = GCHandle.Alloc(result, GCHandleType.Pinned);
ChannelModule.ChannelGetLevelExFunction.CheckResult(ChannelModule.ChannelGetLevelExFunction.Delegate(
Handle, resultHandle.AddrOfPinnedObject(), length, config));
resultHandle.Free();
return result;
}
public IEnumerator Init()
{
#region debug
if (isDebug)
{
// record params of camera
camParam = new CamParam(new Vector3(50, 0, 0), heroCamera.fieldOfView);
curConfig = GameObject.FindObjectOfType(typeof(LevelConfig)) as LevelConfig;
curLevelCamera = GameObject.FindObjectOfType(typeof(LevelCamera)) as LevelCamera;
InitRes();
if (isDebugPvp)
{
flowType = FlowType.PVP;
LevelData.levelType = 8;
}
}
#endregion
curConfig.Init();
while (!isInit) yield return null;
//my heros init :
myPlayer.ExternalInit();
switch (flowType)
{
case FlowType.PVP:
InitPVP();
break;
default:
InitPVE();
break;
}
//顺计时开始
StartCoroutine(BeginTimer());
//默认计时显示
UIBattleManager.instance.LoginCountUpTimer();
InvokeRepeating("CountUpTimer", 0f, 1f);
ExecuteAction();
//Debug.Log(" wait time----------------------" + curLevelCamera.waitTimeToPlay);
if (curLevelCamera)
{
if (curLevelCamera.waitTimeToPlay > 0)
yield return new WaitForSeconds(curLevelCamera.waitTimeToPlay);
if (curLevelCamera.open.Count > 0)
{
int endIndex = curLevelCamera.open.Count - 1;
foreach (CameraPathBezierAnimator cpa in curLevelCamera.open)
{
cpa.animationTarget = heroCamera.transform;
}
curLevelCamera.open[endIndex].AnimationFinished += CameraFinish;
curLevelCamera.open[0].Play();
Debug.Log("Camera Play --------------");
}
else CameraFinish();
}
else
{
Debug.Log("LevelCamera is Null --------------");
CameraFinish();
}
}
public LevelState(LevelConfig config)
{
MaxTime = config.Enemy.InitialTime;
TimeLeft = config.Enemy.InitialTime;
Enemy = config.Enemy;
}
//创建资源
void CreateRes()
{
camParam = new CamParam(new Vector3(50, 0, 0), heroCamera.fieldOfView);
//level resources
GameObject go = (GameObject)Instantiate(prbLevelRes);
go.transform.parent = transform;
//level config
go = (GameObject)Instantiate(prbLevelConfig, Vector3.zero, Quaternion.identity);
curConfig = go.GetComponent<LevelConfig>();
go.transform.parent = transform;
if (prbLevelCamera)
{
//level camera path animation
go = (GameObject)Instantiate(prbLevelCamera);
curLevelCamera = go.GetComponent<LevelCamera>();
go.transform.parent = transform;
}
//开始
StartCoroutine(Init());
InitRes();
}
