private object Read(Type type, PPDPackStreamReader reader)
{
if (type.IsEnum || type == typeof(int))
{
return(ParseInt(reader));
}
else if (type == typeof(float))
{
return(ParseFloat(reader));
}
else if (type == typeof(string))
{
return(ParseString(reader));
}
else if (type == typeof(byte))
{
return(ParseByte(reader));
}
else if (type == typeof(bool))
{
return(ParseBoolean(reader));
}
else
{
throw new Exception("Not supported type");
}
}
protected bool ParseBoolean(PPDPackStreamReader packStreamReader)
{
byte[] data = new byte[sizeof(bool)];
packStreamReader.Read(data, 0, data.Length);
var ret = BitConverter.ToBoolean(data, 0);
return(ret);
}
protected float ParseFloat(PPDPackStreamReader packStreamReader)
{
byte[] data = new byte[sizeof(float)];
packStreamReader.Read(data, 0, data.Length);
var ret = BitConverter.ToSingle(data, 0);
return(ret);
}
protected int ParseInt(PPDPackStreamReader packStreamReader)
{
byte[] data = new byte[sizeof(int)];
packStreamReader.Read(data, 0, data.Length);
var ret = BitConverter.ToInt32(data, 0);
return(ret);
}
protected string ParseString(PPDPackStreamReader packStreamReader)
{
using (StreamReader streamReader = new StreamReader(packStreamReader, Encoding.UTF8))
{
var ret = streamReader.ReadToEnd();
return(ret);
}
}
private string ReadString(PackReader reader, string key, string defaultValue = "")
{
using (PPDPackStreamReader packReader = reader.Read(key))
{
if (packReader == null)
{
return(defaultValue);
}
byte[] bytes = new byte[packReader.Length];
packReader.Read(bytes, 0, bytes.Length);
return(Encoding.UTF8.GetString(bytes));
}
}
public PPDPackStreamReader Read(string fileName)
{
var info = files[fileName];
if (info == null)
{
return(null);
}
stream.Seek(info.Offset, SeekOrigin.Begin);
var ret = new PPDPackStreamReader(stream, (int)info.FileSize, (int)info.Offset);
return(ret);
}
protected int ParseInt(PPDPack.V2.PackReader reader, string keyName)
{
if (reader.Files.Any(f => f == keyName))
{
using (PPDPackStreamReader packStreamReader = reader.Read(keyName))
{
byte[] data = new byte[sizeof(int)];
packStreamReader.Read(data, 0, data.Length);
var ret = BitConverter.ToInt32(data, 0);
return(ret);
}
}
return(0);
}
protected string ParseString(PackReader reader, string keyName)
{
if (reader.FileList.Contains(keyName))
{
using (PPDPackStreamReader packStreamReader = reader.Read(keyName))
{
using (StreamReader streamReader = new StreamReader(packStreamReader, Encoding.UTF8))
{
var ret = streamReader.ReadToEnd();
return(ret);
}
}
}
return(null);
}
public override void Load()
{
if (!Param.ContainsKey("PPDGameUtility"))
{
throw new PPDException(PPDExceptionType.SkinIsNotCorrectlyImplemented);
}
ppdgameutility = Param["PPDGameUtility"] as PPDGameUtility;
currentLatency = ppdgameutility.SongInformation.Latency;
if (Param.ContainsKey("ExitOnReturn"))
{
exitonreturn = true;
}
if (Param.ContainsKey("StartTime"))
{
ppdgameutility.IsDebug = true;
startTime = (float)Param["StartTime"] - 3;
mmStartTime = (float)Param["StartTime"];
}
else if (Param.ContainsKey("StartTimeEx"))
{
ppdgameutility.IsDebug = true;
startTime = (float)Param["StartTimeEx"];
mmStartTime = (float)Param["StartTimeEx"];
}
else
{
startTime = ppdgameutility.SongInformation.StartTime;
mmStartTime = startTime;
}
black = new PictureObject("img\\default\\black.png", 0, 0, false, ResourceManager, Device);
black.Alpha = 0;
black.Hidden = true;
string moviefile = ppdgameutility.SongInformation.MoviePath;
#if x64
if (Path.GetExtension(moviefile) == ".mp4")
{
PlatformGap = 0.03f;
}
#endif
if (moviefile != "")
{
m = GameHost.GetMovie(moviefile);
try
{
if (m.Initialize() == -1)
{
throw new PPDException(PPDExceptionType.CannotOpenMovie);
}
readmoviesetting();
initialized = true;
}
catch (Exception e)
{
MessageBox.Show(e.Message);
initialized = false;
ReturnToMenu();
return;
}
}
else
{
MessageBox.Show("No moviefile");
black.Hidden = false;
if (exitonreturn)
{
Application.Exit();
}
else
{
ReturnToMenu();
return;
}
}
keychange = new int[(int)ButtonType.Start];
for (int i = 0; i < keychange.Length; i++)
{
keychange[i] = i;
}
if (ppdgameutility.Random)
{
randomchange();
}
readprofile();
hm = new HoldManager(Device, ResourceManager);
hm.ScoreGained += new HoldManager.GainScoreEventHandler(hm_ScoreGained);
ppdem = new PPDEffectManager(Device, ResourceManager);
km = new KasiManager(ppdgameutility);
km.KasiChanged += new KasiManager.KasiChangeEventHandler(km_KasiChanged);
cgi = GameHost.GetCGameInterface();
cgi.PPDGameUtility = ppdgameutility;
cgi.ResourceManager = ResourceManager;
cgi.Load();
sm = new SoundManager(Sound as ExSound, ppdgameutility);
if (ppdgameutility.SongInformation.IsOld)
{
em = new EventManager(ppdgameutility);
mm = new MarkManager(Device, em, ppdgameutility, keychange, ppdem, GameHost.GetMarkImagePath(), ResourceManager);
}
else
{
string path = Path.Combine(ppdgameutility.SongInformation.DirectoryPath, DifficultyUtility.ConvertDifficulty(ppdgameutility.Difficulty) + ".ppd");
PackReader reader = new PackReader(path);
PPDPackStreamReader ppdpsr = reader.Read("evd");
em = new EventManager(ppdgameutility, ppdpsr);
ppdpsr.Close();
ppdpsr = reader.Read("ppd");
mm = new MarkManager(Device, em, ppdgameutility, keychange, ppdem, GameHost.GetMarkImagePath(), ppdpsr, ResourceManager);
ppdpsr.Close();
reader.Close();
}
grm = new GameResultManager();
gr = GameHost.GetGameResult();
gr.PPDGameUtility = ppdgameutility;
gr.ResourceManager = ResourceManager;
gr.TweetManager = this;
gr.Load();
pd = GameHost.GetPauseMenu();
pd.PPDGameUtility = ppdgameutility;
pd.ResourceManager = ResourceManager;
pd.Load();
pd.Resumed += new EventHandler(pd_Resumed);
pd.Retryed += new EventHandler(pd_Retryed);
pd.Returned += new EventHandler(pd_Returned);
pd.LatencyChanged += new ChangeLatencyEventHandler(pd_LatencyChanged);
gr.Retryed += new EventHandler(this.Retry);
gr.Returned += new EventHandler(this.Return);
mm.ChangeCombo += new MarkManager.ChangeComboHandler(mm_ChangeCombo);
mm.PlaySound += new MarkManager.SpecialSoundHandler(this.SpecialPlaySound);
mm.StopSound += new MarkManager.SpecialSoundHandler(this.SpecialStopSound);
mm.EvaluateCount += new MarkManager.EvaluateCountHandler(this.EvaluateCount);
mm.PressingButton += new MarkManager.PressingButtonHandler(mm_PressingButton);
em.ChangeMovieVolume += new EventManager.VolumeHandler(ChangeMovieVolume);
//seek
mm.Seek(mmStartTime);
em.Seek(startTime > 0 ? startTime : 0);
sm.Seek(startTime);
km.Seek(startTime);
if (m != null && m.Initialized)
{
m.Play();
m.Pause();
m.Seek(startTime);
}
if (startTime < 0)
{
waitingmoviestart = true;
lasttime = Win32API.timeGetTime();
}
else
{
if (m != null && m.Initialized)
{
m.Play();
}
}
this.AddChild(black);
}
private void AnalyzeMod(PackReader reader)
{
var engine = new Engine();
modSettingManager = new ModSettingManager();
foreach (string content in reader.FileList)
{
using (PPDPackStreamReader ppdpsr = reader.Read(content))
{
if (content.StartsWith("Scripts"))
{
var manager = engine.Load(ppdpsr, false);
manager.Items["ModSettingManager"] = modSettingManager;
manager.Initialize();
}
}
}
ContainsModifyData = engine.ContainsAttribute(typeof(ModifyDataAttribute));
engine.Call(ModSettingManager.MODSTART, null);
settings.Clear();
settings.AddRange(modSettingManager.ModSettings);
var dict = new Dictionary <string, ModSetting>();
foreach (ModSetting setting in settings)
{
if (!dict.ContainsKey(setting.Key))
{
dict.Add(setting.Key, setting);
}
}
settings.Clear();
settings.AddRange(dict.Values);
var currentSettings = ModSettingDatabase.Setting.GetSetting(UniqueName);
foreach (ModSetting modSetting in settings)
{
if (!currentSettings.ContainsKey(modSetting.Key))
{
currentSettings.Add(modSetting.Key, modSetting.Default);
}
else
{
try
{
var str = modSetting.GetStringValue(currentSettings[modSetting.Key]);
if (!modSetting.Validate(str, out object val))
{
throw new Exception("Validate Failed");
}
}
catch
{
currentSettings.Remove(modSetting.Key);
currentSettings.Add(modSetting.Key, modSetting.Default);
}
}
}
ModSettingDatabase.Setting.SetSetting(UniqueName, currentSettings);
foreach (KeyValuePair <string, object> pair in currentSettings)
{
ModSettingManager[pair.Key] = pair.Value;
}
}
protected byte ParseByte(PPDPackStreamReader packStreamReader)
{
return((byte)packStreamReader.ReadByte());
}
