private void SaveSideScrollMap()
{
var playerGameObject = GameObject.Find("Player");
var player = playerGameObject.GetComponent <Player>();
var lastMapPosition = player.PlayerDataModel.LastMapPosition;
levelDataModel = GameManager.Instance.Savables.Find(obj => obj.GetType() == typeof(LevelDataModel) && obj.name == string.Format("Level_{0}-{1}", lastMapPosition.x, lastMapPosition.y)) as LevelDataModel;
var objectsContainer = GameObject.Find("ObjectsContainer");
levelDataModel.GeneratedObjects = new List <GeneratedItemDataModel>();
foreach (Transform child in objectsContainer.transform)
{
var gameStaticObject = child.GetComponent <GameStaticObject>();
levelDataModel.GeneratedObjects.Add(
new GeneratedItemDataModel()
{
Prefab = child.gameObject.name.Replace("(Clone)", string.Empty),
Position = child.position,
Type = gameStaticObject.Type
}
);
}
levelDataModel.Position = player.PlayerDataModel.LastMapPosition;
levelDataModel.IsVisitedBefore = true;
levelDataModel.LastVisitTime = DateTime.Now.Ticks;
//Debug.Log("generated objects count " + levelDataModel.GeneratedObjects.Count);
}
void Start()
{
var playerDataModel = GameManager.Instance.PlayerDataModel;
levelDataModel = GameManager.Instance.Savables.Find(obj => obj.GetType() == typeof(LevelDataModel) && obj.name == string.Format("Level_{0}-{1}", playerDataModel.LastMapPosition.x, playerDataModel.LastMapPosition.y)) as LevelDataModel;
var levelGenerationDataModel = GetLevelGenerationDataModel(levelDataModel.LevelType);
if (!levelDataModel.IsVisitedBefore)
{
//this is new map lets generate it
if (levelGenerationDataModel == null)
{
return;
}
CreateSideScrollMap(levelGenerationDataModel);
SaveSideScrollMap();
}
else
{
LoadSideScrollMap(levelDataModel, levelGenerationDataModel);
SaveSideScrollMap();
}
EventManager.StartListening("OnBeforeSave", OnBeforeSave);
}
private void OnLevelLoadedHandler(object obj)
{
Debug.Log("Updating loaded level");
LevelDataModel levelDataModel = (LevelDataModel)obj;
best.text = $"Best: {levelDataModel.GridData.Count/2}";
}
protected override void Init()
{
LevelDataModel = LevelDataModel.Instance;
parser = ParserFactory.Get <JsonParser>() as JsonParser;
ParseLevel(levelAsset.text);
}
private void RemoveListener(LevelDataModel levelDataModel)
{
if (levelDataModel != null)
{
levelDataModel.OnLevelListUpdated -= HandleOnLevelDataListUpdated;
}
}
public void ParseMidiSong(byte[] midiSong, SongDataModel songModel)
{
//read midi file
var data = new MidiData();
MidiParser.ParseNotesData(midiSong, ref data);
LevelDataModel lv = new LevelDataModel();
lv.noteData = data.notesData[NoteTrack];
lv.playbackData = data.notesData[PlaybackTrack];
lv.playbackData.Sort((x, y) => (x.timeAppear.CompareTo(y.timeAppear)));
lv.noteData.Sort((x, y) => (x.timeAppear.CompareTo(y.timeAppear)));
lv.BPM = data.beatsPerMinute;
lv.denominator = data.denominator;
lv.tickPerQuarterNote = (int)data.deltaTickPerQuarterNote;
var ticksPerTile = songModel.tickPerTile;
var minTickPerTile = Mathf.FloorToInt(ticksPerTile * (1 - tickTolerance));
var maxTickPerTile = Mathf.CeilToInt(ticksPerTile * (1 + tickTolerance));
StartCoroutine(PrepareTileData(lv, minTickPerTile, maxTickPerTile, songModel));
}
private void AddListener(LevelDataModel levelDataModel)
{
if (levelDataModel != null)
{
levelDataModel.OnLevelListUpdated += HandleOnLevelDataListUpdated;
}
}
protected override void Start()
{
base.Start();
screen = Camera.main.ScreenToWorldPoint(new Vector3(Screen.width, Screen.height));
Debug.Log(screen);
LevelDataModel = LevelDataModel.Instance;
cellSize = screen.x / LevelDataModel.BoardValue;
Debug.Log(cellSize);
}
// Use this for initialization
//void Start () {
//}
//// Update is called once per frame
//void Update () {
//}
public override void Press(TouchCover _touchCover)
{
if (!isClickable)
{
return;
}
InGameUIController.Instance.gameplay.StartGame();
isClickable = false;
gameObject.SetActive(false);
//EffectWhenFinish ();
LevelDataModel level = GameManager.Instance.SessionData.currentLevel;
Mio.Utils.AnalyticsHelper.Instance.LogSongstart(level.songData.name);
}
private void LoadSideScrollMap(LevelDataModel levelDataModel, LevelGenerationDataModel levelGenerationDataModel)
{
var mapStaticObject = CreateStatics(levelGenerationDataModel);
var objectsContainer = GameObject.Find("ObjectsContainer");
// In here we are give a chance to createing harvested or destroyed game objects again.
foreach (var probabilityDataModel in levelGenerationDataModel.ItemGenerationProbabilityDataModels)
{
var alreadyGeneratedItemsForThisModel = levelDataModel.GeneratedObjects.FindAll(obj => obj.Prefab.StartsWith(probabilityDataModel.BasePrefabName));
var deltaCount = probabilityDataModel.Intensity - alreadyGeneratedItemsForThisModel.Count;
if (deltaCount <= 0)
{
deltaCount = 0;
}
//calculating new delta count according to lastVisitTime
var currentTime = DateTime.Now;
var timePastSinceLastVisit = new TimeSpan(currentTime.Ticks - levelDataModel.LastVisitTime);
var newDeltaCount = Math.Floor(((float)(timePastSinceLastVisit.TotalSeconds) / (float)levelGenerationDataModel.FullyGenerationTimeInSeconds) * deltaCount);
if (newDeltaCount >= deltaCount)
{
newDeltaCount = deltaCount;
}
Debug.Log("deltacount " + deltaCount);
Debug.Log("newdeltacount " + newDeltaCount);
// trying to create game objects per amount of delta count
var counter = 0;
for (int i = 0; i < newDeltaCount; i++)
{
var gameObject = TryInstantiateGameObject(probabilityDataModel, levelGenerationDataModel, objectsContainer, false);
if (gameObject != null)
{
counter++;
}
}
Debug.Log(counter + " " + probabilityDataModel.BasePrefabName + " is created since last visit.");
}
// crateing game objects those are already there
foreach (var generatedObject in levelDataModel.GeneratedObjects)
{
var prefab = Resources.Load("Prefabs/" + generatedObject.Prefab, typeof(GameObject));
if (prefab != null)
{
Instantiate(prefab, generatedObject.Position, Quaternion.identity, objectsContainer.transform);
}
}
}
private void UpdateMap()
{
LevelDataModel level = DataModels.Level;
float marioRelY = DataModels.Mario.PURelative_Y;
MapLayout bestMap = Config.MapAssociations.GetBestMap(
level.Index, level.Area, level.LoadingPoint, level.MissionLayout, marioRelY);
object mapLayoutChoice = Config.MapGui.ComboBoxLevel.SelectedItem;
if (mapLayoutChoice is MapLayout)
{
bestMap = (MapLayout)mapLayoutChoice;
}
ChangeCurrentMap(bestMap);
}
void Start()
{
IsEnabled = true;
sideScrollMap = GetComponent <SideScrollMap>();
if (sideScrollMap == null)
{
IsEnabled = false;
// Debug.Log("ItemSpawner: Item Spawner is not working because it could not reach the SideScrollMap.");
return;
}
levelDataModel = sideScrollMap.GetLevelDataModel();
levelGenerationDataModel = sideScrollMap.GetLevelGenerationDataModel(levelDataModel.LevelType);
objectsContainer = GameObject.Find("ObjectsContainer");
}
private void UpdateBackground()
{
LevelDataModel level = DataModels.Level;
float marioRelY = DataModels.Mario.PURelative_Y;
MapLayout bestMap = Config.MapAssociations.GetBestMap(
level.Index, level.Area, level.LoadingPoint, level.MissionLayout, marioRelY);
object backgroundChoice = Config.MapGui.ComboBoxBackground.SelectedItem;
if (backgroundChoice is BackgroundImage background)
{
ChangeBackground(background.Image);
}
else
{
ChangeBackground(bestMap.BackgroundImage);
}
}
/// <summary>
/// Create GUI elements for operations with level creation or loading.
/// </summary>
private void DisplayCreateLevelGui()
{
EditorGUILayout.BeginVertical(_innerContainerGuiStyle);
EditorGUILayout.LabelField("Level Creation", EditorStyles.boldLabel);
_levelName = EditorGUILayout.TextField("Level Name", _levelName);
EditorGUILayout.LabelField("How much tiles will have level with and height.", EditorStyles.miniLabel);
_levelSize = EditorGUILayout.Vector2IntField("Level Size: ", _levelSize);
EditorGUILayout.Space();
if (GUILayout.Button("Create New Level", GUILayout.ExpandWidth(true), GUILayout.Height(PRIMARY_BUTTON_HEIGHT)))
{
_currentLevelDataModel = new LevelDataModel(_levelSize.x, _levelSize.y)
{
levelName = _levelName
};
}
EditorGUILayout.Space();
EditorGUILayout.LabelField("Level Loading", EditorStyles.boldLabel);
_savedLevelJSON = (TextAsset)EditorGUILayout.ObjectField("JSON Level:", _savedLevelJSON, typeof(TextAsset), false);
if (GUILayout.Button("Load Level", GUILayout.ExpandWidth(true), GUILayout.Height(PRIMARY_BUTTON_HEIGHT)))
{
var deserializedData = JsonUtility.FromJson <LevelDataModel>(_savedLevelJSON.text);
_currentLevelDataModel = deserializedData;
_levelSize = _currentLevelDataModel.GetLevelSize();
_levelName = _currentLevelDataModel.levelName;
}
EditorGUILayout.Space();
if (_currentLevelDataModel == null)
{
EditorGUILayout.HelpBox("Click at the button \"Create New Level\" to create new Level Data.\nOr \"Load Level\" to load levels JSON config.", MessageType.Warning);
}
EditorGUILayout.EndVertical();
}
IEnumerator Load()
{
isLoading = true;
string path =
#if UNITY_ANDROID && !UNITY_EDITOR
Application.streamingAssetsPath + "/SecondWeaponsdata.txt";
#elif UNITY_IPHONE && !UNITY_EDITOR
"file://" + Application.streamingAssetsPath + "/SecondWeaponsdata.txt";
#elif UNITY_STANDLONE_WIN || UNITY_EDITOR
"file://" + Application.streamingAssetsPath + "/SecondWeaponsdata.txt";
#else
string.Empty;
#endif
//string path = Application.streamingAssetsPath + "/SecondWeaponsdata.txt";
WWW www = new WWW(path);
yield return(www);
if (www.isDone && string.IsNullOrEmpty(www.error))
{
List <WeaponModel> weapons = JsonConvert.DeserializeObject <List <WeaponModel> >(www.text);
for (int i = 0; i < weapons.Count; i++)
{
AllSecondWeapons.Add(weapons[i].Id, weapons[i]);
}
}
else
{
Debug.Log(www.isDone + www.error);
}
//LoadDataFromLocal();
LevelData = new LevelDataModel();
Test();
isLoading = false;
var p = ObjectPool.GetInstance().GetObj("Player");
CurrentPlayer = p.GetComponent <Player>();
}
private void OnLevelDataLoadedHandler(object obj)
{
LevelDataModel levelData = (LevelDataModel)obj;
_totalLinesToBeCompleted = levelData.GridData.Count / 2;
}
protected override void Init()
{
LevelDataModel = LevelDataModel.Instance;
StartGame();
}
IEnumerator PrepareTileData(LevelDataModel lv, int minTickPerTile, int maxTickPerTile, SongDataModel songDataModel, Action <float> onProgress = null, Action onComplete = null, Action <string> onError = null)
{
//listNoteData = noteData;
var listTilesData = new List <TileData>(1000);
var noteData = lv.noteData;
var playbackData = lv.playbackData;
//float BPM = lv.BPM;
//we know that note data will always less or equals to playback data
//so we will start by traverse through list note data
NoteData currentNote, nextNote;
int currentNoteIndex;
//int loopCount = 0;
//int maxLoop = 10;
float lastReleaseThreadTime = Time.realtimeSinceStartup;
float maxTimeLockThread = 1;
//this variable is used to reduce number of cast operation
float noteDataCount = noteData.Count;
//for each note in view list
for (int i = 0; i < noteData.Count; i++)
{
currentNoteIndex = i;
//set up range for checking song data
currentNote = noteData[currentNoteIndex];
nextNote = null;
//don't hog up all the CPU, save some for rendering task
if (lastReleaseThreadTime + maxTimeLockThread >= Time.realtimeSinceStartup)
{
lastReleaseThreadTime = Time.realtimeSinceStartup;
Helpers.CallbackWithValue(onProgress, ((i / noteDataCount)));
yield return(null);
}
//try to get next view note (must be different at timestamp with current note)
while (++i < noteData.Count)
{
//++i;
nextNote = noteData[i];
//stop the loop right when next note is found
if (nextNote.timeAppear != currentNote.timeAppear)
{
//decrease i so that at the end of the loop, it can be increased gracefully
--i;
break;
}
}
if (i >= noteData.Count)
{
i = noteData.Count - 1;
}
//how many notes existed at the same timestamp
int numConcurrentNotes = i - currentNoteIndex + 1;
//print("Num concurrent notes" + numConcurrentNotes + " at " + i);
//for each note, create a tile
for (int j = currentNoteIndex; j <= i; j++)
{
//print(string.Format("i {0}, j {1}, Concurrent notes: {2}", i, j, numConcurrentNotes));
//print(string.Format("Current note: {0}, timestamp {1}; Next note; {2}, timestamp: {3}", currentNote.nodeID, currentNote.timeAppear, nextNote.nodeID, nextNote.timeAppear));
//with each note data, there is a tile
TileData tileData = new TileData();
tileData.type = TileType.Normal;
tileData.notes = new List <NoteData>();
tileData.startTime = currentNote.timeAppear;
tileData.startTimeInTicks = currentNote.tickAppear;
tileData.soundDelay = 0;
//fetch midi data for tile
//float endTime = ((nextNote == null) ? currentNote.timeAppear + currentNote.duration : nextNote.timeAppear);
//AddConcurrentMidiData(
// ref tileData,
// playbackData,
// currentNote.timeAppear,
// endTime,
// currentNoteIndex
// );
int startTime, endTime;
startTime = endTime = -1;
switch (numConcurrentNotes)
{
//only 1 tile
case 1:
tileData.subType = TileType.Normal;
startTime = currentNote.tickAppear;
endTime = ((nextNote == null) ? currentNote.tickAppear + currentNote.durationInTick : nextNote.tickAppear);
break;
//dual tile
case 2:
tileData.subType = TileType.Dual;
if (j % 2 == 0)
{
startTime = currentNote.tickAppear;
endTime = currentNote.tickAppear + (int)(currentNote.durationInTick * 0.5f);
}
else
{
tileData.soundDelay = currentNote.duration * 0.5f;
startTime = currentNote.tickAppear + (int)(currentNote.durationInTick * 0.5f);
endTime = ((nextNote == null) ? currentNote.tickAppear + currentNote.durationInTick : nextNote.tickAppear);
}
break;
//big tile
case 3:
tileData.subType = TileType.Big;
if (listTilesData.Count > 1)
{
TileData lastTileData = listTilesData[listTilesData.Count - 1];
if (lastTileData.startTimeInTicks != currentNote.tickAppear)
{
startTime = currentNote.tickAppear;
endTime = ((nextNote == null) ? currentNote.tickAppear + currentNote.durationInTick : nextNote.tickAppear);
}
else
{
startTime = endTime = -1;
}
}
break;
}
if (startTime >= 0 && endTime >= 0)
{
//print("Adding note data into tile " + j);
AddConcurrentMidiDataByTick(
ref tileData,
playbackData,
startTime,
endTime,
j
);
tileData.durationInTicks = currentNote.durationInTick;
tileData.duration = currentNote.duration;
//Debug.Log(string.Format("Duration of note {0}, ID: {2} is {1}", i, tileData.duration, currentNote.nodeID));
//if a tile has duration belong to the normal tile's range
if (minTickPerTile <= tileData.durationInTicks && tileData.durationInTicks <= maxTickPerTile)
{
//set it as so
tileData.type = TileType.Normal;
listTilesData.Add(tileData);
}
else
{
//else, it is either a long note...
if (maxTickPerTile < tileData.durationInTicks)
{
tileData.type = TileType.LongNote;
listTilesData.Add(tileData);
}
else
{
//... or just an error note, f**k that shit
//Debug.LogWarning(string.Format("A tile data has duration of {0}, which is less than a normal tile ({1}), please check. It has Index of {2}, midi note {3}", tileData.durationInTicks, currentLevelData.songData.tickPerTile, currentNoteIndex, currentNote.nodeID));
}
}
}
}
}
//Debug.Log("Prepare tile data completed");
//easy, start render in the next frame
SongTileData b_data = new SongTileData();
b_data.BPM = lv.BPM;
b_data.denominator = lv.denominator;
b_data.tickPerQuarterNote = lv.tickPerQuarterNote;
b_data.titledata = listTilesData;
b_data.songDataModel = songDataModel;
SaveTileData(b_data, "songs/parsed/" + b_data.songDataModel.storeID);
JobCompleted();
yield return(null);
//Helpers.Callback(onComplete);
}
private void Start()
{
LevelDataModel = LevelDataModel.Instance;
}
