Taiko_Stuff/OpenTaiko
1
0
Fork 0
mirror of synced 2025-02-17 11:08:33 +01:00
Code Releases Activity

translate comparer codes and add unlockable check on it

Browse Source
This commit is contained in:
0auBSQ 2024-10-24 05:11:08 +09:00
parent 3b2cef2636
commit d7ea86cd86
16 changed files with 301 additions and 330 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
OpenTaiko/src/Songs/C曲リストノードComparers/C曲リストノードComparerLevel.cs → OpenTaiko/src/Songs/CSongListNodeComparers/CSongListNodeComparerLevel.cs
View File

@ -1,9 +1,9 @@
namespace OpenTaiko.C曲リストノードComparers;
namespace OpenTaiko.CSongListNodeComparers;
internal sealed class C曲リストノードComparerLevel : IComparer<CSongListNode> {
internal sealed class CSongListNodeComparerLevel : IComparer<CSongListNode> {
private readonly int _order;
public C曲リストノードComparerLevel(int order) {
public CSongListNodeComparerLevel(int order) {
this._order = order;
}

6
OpenTaiko/src/Songs/C曲リストノードComparers/C曲リストノードComparerLevelIcon.cs → OpenTaiko/src/Songs/CSongListNodeComparers/CSongListNodeComparerLevelIcon.cs
View File

@ -1,9 +1,9 @@
namespace OpenTaiko.C曲リストノードComparers;
namespace OpenTaiko.CSongListNodeComparers;
internal sealed class C曲リストノードComparerLevelIcon : IComparer<CSongListNode> {
internal sealed class CSongListNodeComparerLevelIcon : IComparer<CSongListNode> {
private readonly int _order;
public C曲リストノードComparerLevelIcon(int order) {
public CSongListNodeComparerLevelIcon(int order) {
this._order = order;
}

8
OpenTaiko/src/Songs/C曲リストノードComparers/C曲リストノードComparerノード種別.cs → OpenTaiko/src/Songs/CSongListNodeComparers/CSongListNodeComparerNodeType.cs
View File

@ -1,12 +1,12 @@
namespace OpenTaiko.C曲リストノードComparers;
namespace OpenTaiko.CSongListNodeComparers;
internal sealed class C曲リストノードComparerノード種別 : IComparer<CSongListNode> {
internal sealed class CSongListNodeComparerNodeType : IComparer<CSongListNode> {
public int Compare(CSongListNode x, CSongListNode y) {
return ToComparable(x.eノード種別).CompareTo(ToComparable(y.eノード種別));
}
private static int ToComparable(CSongListNode.ENodeType eノード種別) {
switch (eノード種別) {
private static int ToComparable(CSongListNode.ENodeType nodeType) {
switch (nodeType) {
case CSongListNode.ENodeType.BOX:
return 0;
case CSongListNode.ENodeType.SCORE:

30
OpenTaiko/src/Songs/CSongListNodeComparers/CSongListNodeComparerPath.cs Normal file
View File

@ -0,0 +1,30 @@
namespace OpenTaiko.CSongListNodeComparers;
internal sealed class CSongListNodeComparerPath : IComparer<CSongListNode> {
private readonly int _order;
public CSongListNodeComparerPath(int order) {
this._order = order;
}
public int Compare(CSongListNode n1, CSongListNode n2) {
if ((n1.eノード種別 == CSongListNode.ENodeType.BOX) && (n2.eノード種別 == CSongListNode.ENodeType.BOX)) {
return _order * n1.arスコア[0].ファイル情報.フォルダの絶対パス.CompareTo(n2.arスコア[0].ファイル情報.フォルダの絶対パス);
}
var str = filePath(n1);
var strB = filePath(n2);
return _order * str.CompareTo(strB);
}
private static string filePath(CSongListNode songNode) {
for (int i = 0; i < (int)Difficulty.Total; i++) {
if (songNode.arスコア[i] != null) {
return songNode.arスコア[i].ファイル情報.ファイルの絶対パス ?? "";
}
}
return "";
}
}

6
OpenTaiko/src/Songs/C曲リストノードComparers/C曲リストノードComparerSubtitle.cs → OpenTaiko/src/Songs/CSongListNodeComparers/CSongListNodeComparerSubtitle.cs
View File

@ -1,9 +1,9 @@
namespace OpenTaiko.C曲リストノードComparers;
namespace OpenTaiko.CSongListNodeComparers;
internal sealed class C曲リストノードComparerSubtitle : IComparer<CSongListNode> {
internal sealed class CSongListNodeComparerSubtitle : IComparer<CSongListNode> {
private readonly int _order;
public C曲リストノードComparerSubtitle(int order) {
public CSongListNodeComparerSubtitle(int order) {
this._order = order;
}

13
OpenTaiko/src/Songs/CSongListNodeComparers/CSongListNodeComparerTitle.cs Normal file
View File

@ -0,0 +1,13 @@
namespace OpenTaiko.CSongListNodeComparers;
internal sealed class CSongListNodeComparerTitle : IComparer<CSongListNode> {
private readonly int _order;
public CSongListNodeComparerTitle(int order) {
this._order = order;
}
public int Compare(CSongListNode n1, CSongListNode n2) {
return _order * n1.ldTitle.GetString("").CompareTo(n2.ldTitle.GetString(""));
}
}

20
OpenTaiko/src/Songs/CSongListNodeComparers/CSongListNodeComparerUnlockStatus.cs Normal file
View File

@ -0,0 +1,20 @@
namespace OpenTaiko.CSongListNodeComparers;
internal sealed class CSongListNodeComparerUnlockStatus : IComparer<CSongListNode> {
public int Compare(CSongListNode n1, CSongListNode n2) {
int _n1s = (n1.eノード種別 != CSongListNode.ENodeType.SCORE) ? 0 : 1;
int _n2s = (n2.eノード種別 != CSongListNode.ENodeType.SCORE) ? 0 : 1;
if (_n1s == 0 || _n2s == 0) {
return -1;
}
return _unlockStatusToInt(n1).CompareTo(_unlockStatusToInt(n2));
}
private int _unlockStatusToInt(CSongListNode n1) {
if (!OpenTaiko.Databases.DBSongUnlockables.tIsSongLocked(n1)) return -1;
return (int)OpenTaiko.Databases.DBSongUnlockables.tGetSongHiddenIndex(n1);
}
}

2
OpenTaiko/src/Songs/C曲リストノードComparers/ComparerChain.cs → OpenTaiko/src/Songs/CSongListNodeComparers/ComparerChain.cs
View File

@ -1,4 +1,4 @@
namespace OpenTaiko.C曲リストノードComparers;
namespace OpenTaiko.CSongListNodeComparers;
internal sealed class ComparerChain<T> : IComparer<T> where T : class {
private readonly IComparer<T>[] _comparers;

423
OpenTaiko/src/Songs/CSong管理.cs
View File

@ -1,14 +1,14 @@
using System.Diagnostics;
using System.Security.Cryptography;
using System.Text;
using OpenTaiko.C曲リストノードComparers;
using OpenTaiko.CSongListNodeComparers;
namespace OpenTaiko;
[Serializable]
internal class CSongs管理 {
// Properties
internal class CSongs管理 {
// Properties
public int nスコアキャッシュから反映できたスコア数 {
get;
set;
@ -25,17 +25,17 @@ internal class CSongs管理 {
get;
set;
}
public Dictionary<string, CSongListNode> listSongsDB; // songs.dbから構築されるlist
public List<CSongListNode> list曲ルート; // 起動時にフォルダ検索して構築されるlist
public List<CSongListNode> list曲ルート_Dan = new List<CSongListNode>(); // 起動時にフォルダ検索して構築されるlist
public List<CSongListNode> list曲ルート_Tower = new List<CSongListNode>(); // 起動時にフォルダ検索して構築されるlist
public Dictionary<string, CSongListNode> listSongsDB; // songs.dbから構築されるlist
public List<CSongListNode> list曲ルート; // 起動時にフォルダ検索して構築されるlist
public List<CSongListNode> list曲ルート_Dan = new List<CSongListNode>(); // 起動時にフォルダ検索して構築されるlist
public List<CSongListNode> list曲ルート_Tower = new List<CSongListNode>(); // 起動時にフォルダ検索して構築されるlist
public static List<FDK.CTexture> listCustomBGs = new List<FDK.CTexture>();
public bool bIsSuspending // 外部スレッドから、内部スレッドのsuspendを指示する時にtrueにする
{ // 再開時は、これをfalseにしてから、次のautoReset.Set()を実行する
public bool bIsSuspending // 外部スレッドから、内部スレッドのsuspendを指示する時にtrueにする
{ // 再開時は、これをfalseにしてから、次のautoReset.Set()を実行する
get;
set;
}
public bool bIsSlowdown // #PREMOVIE再生時に曲検索を遅くする
public bool bIsSlowdown // #PREMOVIE再生時に曲検索を遅くする
{
get;
set;
@ -43,26 +43,26 @@ internal class CSongs管理 {
[NonSerialized]
public AutoResetEvent AutoReset;
private int searchCount; // #PREMOVIE中は検索n回実行したら少しスリープする
// Constructor
private int searchCount; // #PREMOVIE中は検索n回実行したら少しスリープする
// Constructor
public CSongs管理() {
this.listSongsDB = new();
this.list曲ルート = new List<CSongListNode>();
this.n検索された曲ノード数 = 0;
this.n検索されたスコア数 = 0;
this.bIsSuspending = false; // #27060
this.AutoReset = new AutoResetEvent(true); // #27060
this.bIsSuspending = false; // #27060
this.AutoReset = new AutoResetEvent(true); // #27060
this.searchCount = 0;
}
// メソッド
}
// メソッド
#region [ Fetch song list ]
//-----------------
//-----------------
public void UpdateDownloadBox() {
CSongListNode downloadBox = null;
@ -76,9 +76,9 @@ internal class CSongs管理 {
if (downloadBox != null && downloadBox.list子リスト != null) {
var flatten = OpenTaiko.stageSongSelect.actSongList.flattenList(downloadBox.list子リスト);
// Works because flattenList creates a new List
var flatten = OpenTaiko.stageSongSelect.actSongList.flattenList(downloadBox.list子リスト);
// Works because flattenList creates a new List
for (int i = 0; i < downloadBox.list子リスト.Count; i++) {
CSongDict.tRemoveSongNode(downloadBox.list子リスト[i].uniqueId);
downloadBox.list子リスト.Remove(downloadBox.list子リスト[i]);
@ -96,7 +96,7 @@ internal class CSongs管理 {
}
t曲を検索してリストを作成する(path, true, downloadBox.list子リスト, downloadBox);
this.t曲リストへ後処理を適用する(downloadBox.list子リスト, $"/{downloadBox.ldTitle.GetString("")}/");
this.tSongListPostprocessing(downloadBox.list子リスト, $"/{downloadBox.ldTitle.GetString("")}/");
downloadBox.list子リスト.Insert(0, CSongDict.tGenerateBackButton(downloadBox, $"/{downloadBox.ldTitle.GetString("")}/"));
}
}
@ -112,10 +112,10 @@ internal class CSongs管理 {
DirectoryInfo info = new DirectoryInfo(str基点フォルダ);
if (OpenTaiko.ConfigIni.bOutputSongSearchLog)
Trace.TraceInformation("基点フォルダ: " + str基点フォルダ);
Trace.TraceInformation("基点フォルダ: " + str基点フォルダ);
#region [ a.フォルダ内に set.def が存在する場合 → 1フォルダ内のtjaファイル無制限]
//-----------------------------
//-----------------------------
string path = str基点フォルダ + "set.def";
if (File.Exists(path)) {
new FileInfo(path);
@ -125,22 +125,22 @@ internal class CSongs管理 {
}
try {
foreach (FileInfo fileinfo in info.GetFiles()) {
SlowOrSuspendSearchTask();
SlowOrSuspendSearchTask();
#region[ 拡張子を取得 ]
string strExt = fileinfo.Extension.ToLower();
string strExt = fileinfo.Extension.ToLower();
#endregion
if ((strExt.Equals(".tja") || strExt.Equals(".dtx"))) {
if (strExt.Equals(".tja")) {
//tja、dtxが両方存在していた場合、tjaを読み込まずにtjaと同名のdtxだけを使う。
if (strExt.Equals(".tja")) {
//tja、dtxが両方存在していた場合、tjaを読み込まずにtjaと同名のdtxだけを使う。
string dtxscoreini = str基点フォルダ + (fileinfo.Name.Replace(strExt, ".dtx"));
if (File.Exists(dtxscoreini)) {
continue;
}
}
}
#region[ 新処理 ]
CSongListNode c曲リストノード = new CSongListNode();
c曲リストノード.eノード種別 = CSongListNode.ENodeType.SCORE;
@ -169,17 +169,17 @@ internal class CSongs管理 {
c曲リストノード.strSelectBGPath = $@"{fileinfo.FullName}{Path.DirectorySeparatorChar}..{Path.DirectorySeparatorChar}{dtx.SELECTBG}";
if (!File.Exists(c曲リストノード.strSelectBGPath)) c曲リストノード.strSelectBGPath = null;
c曲リストノード.nLevel = dtx.LEVELtaiko;
c曲リストノード.nLevelIcon = dtx.LEVELtaikoIcon;
// LIFE here
c曲リストノード.nLevelIcon = dtx.LEVELtaikoIcon;
// LIFE here
c曲リストノード.nLife = dtx.LIFE;
c曲リストノード.nTowerType = dtx.TOWERTYPE;
c曲リストノード.nDanTick = dtx.DANTICK;
c曲リストノード.cDanTickColor = dtx.DANTICKCOLOR;
// Total count of floors for a tower chart
c曲リストノード.cDanTickColor = dtx.DANTICKCOLOR;
// Total count of floors for a tower chart
c曲リストノード.nTotalFloor = 0;
for (int i = 0; i < dtx.listChip.Count; i++) {
@ -206,7 +206,7 @@ internal class CSongs管理 {
}
}
}
}
}
#endregion
}
} finally {
@ -214,22 +214,22 @@ internal class CSongs管理 {
Trace.Unindent();
}
}
}
//-----------------------------
}
//-----------------------------
#endregion
#region [ b.フォルダ内に set.def が存在しない場合 → 個別ファイルからノード作成 ]
//-----------------------------
//-----------------------------
else {
foreach (FileInfo fileinfo in info.GetFiles()) {
SlowOrSuspendSearchTask(); // #27060 中断要求があったら、解除要求が来るまで待機, #PREMOVIE再生中は検索負荷を落とす
SlowOrSuspendSearchTask(); // #27060 中断要求があったら、解除要求が来るまで待機, #PREMOVIE再生中は検索負荷を落とす
string strExt = fileinfo.Extension.ToLower();
if ((strExt.Equals(".tja") || strExt.Equals(".dtx"))) {
// 2017.06.02 kairera0467 廃止。
if ((strExt.Equals(".tja") || strExt.Equals(".dtx"))) {
// 2017.06.02 kairera0467 廃止。
#region[ 新処理 ]
string filePath = str基点フォルダ + fileinfo.Name;
using SHA1 hashProvider = SHA1.Create();
@ -432,20 +432,20 @@ internal class CSongs管理 {
}
}
}
}
}
#endregion
}
}
}
//-----------------------------
}
//-----------------------------
#endregion
foreach (DirectoryInfo infoDir in info.GetDirectories()) {
SlowOrSuspendSearchTask(); // #27060 中断要求があったら、解除要求が来るまで待機, #PREMOVIE再生中は検索負荷を落とす
SlowOrSuspendSearchTask(); // #27060 中断要求があったら、解除要求が来るまで待機, #PREMOVIE再生中は検索負荷を落とす
#region [ a.box.def を含むフォルダの場合 ]
//-----------------------------
//-----------------------------
if (File.Exists(infoDir.FullName + @$"{Path.DirectorySeparatorChar}box.def")) {
CBoxDef boxdef = new CBoxDef(infoDir.FullName + @$"{Path.DirectorySeparatorChar}box.def");
CSongListNode c曲リストノード = new CSongListNode();
@ -592,26 +592,26 @@ internal class CSongs管理 {
if (b子BOXへ再帰する) {
this.t曲を検索してリストを作成する(infoDir.FullName + Path.DirectorySeparatorChar, b子BOXへ再帰する, c曲リストノード.list子リスト, c曲リストノード);
}
}
//-----------------------------
}
//-----------------------------
#endregion
#region [ c.通常フォルダの場合 ]
//-----------------------------
//-----------------------------
else {
this.t曲を検索してリストを作成する(infoDir.FullName + Path.DirectorySeparatorChar, b子BOXへ再帰する, listノードリスト, node親);
}
//-----------------------------
}
//-----------------------------
#endregion
}
}
//-----------------
}
//-----------------
#endregion
private void LoadChartInfo(CSongListNode c曲リストノード, CDTX cdtx, int i) {
if ((c曲リストノード.arスコア[i] != null) && !c曲リストノード.arスコア[i].bSongDBにキャッシュがあった) {
if ((c曲リストノード.arスコア[i] != null) && !c曲リストノード.arスコア[i].bSongDBにキャッシュがあった) {
#region [ DTX ファイルのヘッダだけ読み込み、Cスコア.譜面情報 を設定する ]
//-----------------
//-----------------
string path = c曲リストノード.arスコア[i].ファイル情報.ファイルの絶対パス;
if (File.Exists(path)) {
try {
@ -633,7 +633,7 @@ internal class CSongs管理 {
c曲リストノード.arスコア[i].譜面情報.BaseBpm = cdtx.BASEBPM;
c曲リストノード.arスコア[i].譜面情報.MinBpm = cdtx.MinBPM;
c曲リストノード.arスコア[i].譜面情報.MaxBpm = cdtx.MaxBPM;
c曲リストノード.arスコア[i].譜面情報.Duration = 0; // (cdtx.listChip == null)? 0 : cdtx.listChip[ cdtx.listChip.Count - 1 ].n発声時刻ms;
c曲リストノード.arスコア[i].譜面情報.Duration = 0; // (cdtx.listChip == null)? 0 : cdtx.listChip[ cdtx.listChip.Count - 1 ].n発声時刻ms;
c曲リストノード.arスコア[i].譜面情報.strBGMファイル名 = cdtx.strBGM_PATH;
c曲リストノード.arスコア[i].譜面情報.SongVol = cdtx.SongVol;
c曲リストノード.arスコア[i].譜面情報.SongLoudnessMetadata = cdtx.SongLoudnessMetadata;
@ -643,9 +643,9 @@ internal class CSongs管理 {
c曲リストノード.arスコア[i].譜面情報.b譜面分岐[k] = cdtx.bHIDDENBRANCH ? false : cdtx.bHasBranch[k];
c曲リストノード.arスコア[i].譜面情報.nレベル[k] = cdtx.LEVELtaiko[k];
c曲リストノード.arスコア[i].譜面情報.nLevelIcon[k] = cdtx.LEVELtaikoIcon[k];
}
// Tower Lives
}
// Tower Lives
c曲リストノード.arスコア[i].譜面情報.nLife = cdtx.LIFE;
c曲リストノード.arスコア[i].譜面情報.nTowerType = cdtx.TOWERTYPE;
@ -665,9 +665,9 @@ internal class CSongs管理 {
this.nファイルから反映できたスコア数++;
cdtx.DeActivate();
cdtx.DeActivate();
#region [ 曲検索ログ出力 ]
//-----------------
//-----------------
if (OpenTaiko.ConfigIni.bOutputSongSearchLog) {
StringBuilder sb = new StringBuilder(0x400);
sb.Append(string.Format("曲データファイルから譜面情報を転記しました。({0})", path));
@ -687,11 +687,11 @@ internal class CSongs管理 {
sb.Append(", bpm=" + c曲リストノード.arスコア[i].譜面情報.Bpm);
sb.Append(", basebpm=" + c曲リストノード.arスコア[i].譜面情報.BaseBpm);
sb.Append(", minbpm=" + c曲リストノード.arスコア[i].譜面情報.MinBpm);
sb.Append(", maxbpm=" + c曲リストノード.arスコア[i].譜面情報.MaxBpm);
// sb.Append( ", duration=" + c曲リストノード.arスコア[ i ].譜面情報.Duration );
sb.Append(", maxbpm=" + c曲リストノード.arスコア[i].譜面情報.MaxBpm);
// sb.Append( ", duration=" + c曲リストノード.arスコア[ i ].譜面情報.Duration );
Trace.TraceInformation(sb.ToString());
}
//-----------------
}
//-----------------
#endregion
} catch (Exception exception) {
Trace.TraceError(exception.ToString());
@ -700,15 +700,15 @@ internal class CSongs管理 {
this.n検索されたスコア数--;
Trace.TraceError("曲データファイルの読み込みに失敗しました。({0})", path);
}
}
//-----------------
}
//-----------------
#endregion
}
}
}
#region [ 曲リストへ後処理を適用する ]
//-----------------
public void t曲リストへ後処理を適用する() {
//-----------------
public void tSongListPostprocessing() {
listStrBoxDefSkinSubfolderFullName = new List<string>();
if (OpenTaiko.Skin.strBoxDefSkinSubfolders != null) {
foreach (string b in OpenTaiko.Skin.strBoxDefSkinSubfolders) {
@ -716,7 +716,7 @@ internal class CSongs管理 {
}
}
this.t曲リストへ後処理を適用する(this.list曲ルート);
this.tSongListPostprocessing(this.list曲ルート);
for (int p = 0; p < list曲ルート.Count; p++) {
var c曲リストノード = list曲ルート[p];
@ -725,9 +725,9 @@ internal class CSongs管理 {
if (OpenTaiko.ConfigIni.bDanTowerHide) {
list曲ルート.Remove(c曲リストノード);
p--;
}
// Add to dojo
}
// Add to dojo
list曲ルート_Dan = c曲リストノード.list子リスト;
} else if (c曲リストノード.strジャンル == "太鼓タワー") {
if (OpenTaiko.ConfigIni.bDanTowerHide) {
@ -756,8 +756,8 @@ internal class CSongs管理 {
}
}
}
}
}
#region [ skin名で比較して、systemスキンとboxdefスキンに重複があれば、boxdefスキン側を削除する ]
string[] systemSkinNames = CSkin.GetSkinName(OpenTaiko.Skin.strSystemSkinSubfolders);
List<string> l = new List<string>(listStrBoxDefSkinSubfolderFullName);
@ -767,7 +767,7 @@ internal class CSongs管理 {
StringComparer.InvariantCultureIgnoreCase) >= 0) {
listStrBoxDefSkinSubfolderFullName.Remove(boxdefSkinSubfolderFullName);
}
}
}
#endregion
string[] ba = listStrBoxDefSkinSubfolderFullName.ToArray();
Array.Sort(ba);
@ -775,163 +775,128 @@ internal class CSongs管理 {
}
private void t曲リストへ後処理を適用する(List<CSongListNode> ノードリスト, string parentName = "/", bool isGlobal = true) {
private void tSongListPostprocessing(List<CSongListNode> nodeList, string parentName = "/", bool isGlobal = true) {
if (isGlobal && ノードリスト.Count > 0) {
var randomNode = CSongDict.tGenerateRandomButton(ノードリスト[0].rParentNode, parentName);
ノードリスト.Add(randomNode);
}
// Don't sort songs if the folder isn't global
// Call back reinsert back folders if sort called ?
if (isGlobal) {
#region [ Sort nodes ]
//-----------------------------
if (OpenTaiko.ConfigIni.nDefaultSongSort == 0) {
t曲リストのソート1_絶対パス順(ノードリスト);
} else if (OpenTaiko.ConfigIni.nDefaultSongSort == 1) {
t曲リストのソート9_ジャンル順(ノードリスト, EInstrumentPad.Taiko, 1, 0);
} else if (OpenTaiko.ConfigIni.nDefaultSongSort == 2) {
t曲リストのソート9_ジャンル順(ノードリスト, EInstrumentPad.Taiko, 2, 0);
}
//-----------------------------
#endregion
}
// すべてのノードについて…
foreach (CSongListNode c曲リストノード in ノードリスト) {
SlowOrSuspendSearchTask(); // #27060 中断要求があったら、解除要求が来るまで待機, #PREMOVIE再生中は検索負荷を落とす
if (isGlobal && nodeList.Count > 0) {
var randomNode = CSongDict.tGenerateRandomButton(nodeList[0].rParentNode, parentName);
nodeList.Add(randomNode);
}
// Don't sort songs if the folder isn't global
// Call back reinsert back folders if sort called ?
if (isGlobal) {
tSongListSortByPath(nodeList);
}
// すべてのノードについて…
foreach (CSongListNode songNode in nodeList) {
SlowOrSuspendSearchTask(); // #27060 中断要求があったら、解除要求が来るまで待機, #PREMOVIE再生中は検索負荷を落とす
#region [ Append "Back" buttons to the included folders ]
//-----------------------------
if (c曲リストノード.eノード種別 == CSongListNode.ENodeType.BOX) {
//-----------------------------
if (songNode.eノード種別 == CSongListNode.ENodeType.BOX) {
tSongListSortByPath(songNode.list子リスト);
string newPath = parentName + songNode.ldTitle.GetString("") + "/";
#region [ Sort child nodes ]
//-----------------------------
if (OpenTaiko.ConfigIni.nDefaultSongSort == 0) {
t曲リストのソート1_絶対パス順(c曲リストノード.list子リスト);
} else if (OpenTaiko.ConfigIni.nDefaultSongSort == 1) {
t曲リストのソート9_ジャンル順(c曲リストノード.list子リスト, EInstrumentPad.Taiko, 1, 0);
} else if (OpenTaiko.ConfigIni.nDefaultSongSort == 2) {
t曲リストのソート9_ジャンル順(c曲リストノード.list子リスト, EInstrumentPad.Taiko, 2, 0);
}
//-----------------------------
#endregion
string newPath = parentName + c曲リストノード.ldTitle.GetString("") + "/";
CSongDict.tReinsertBackButtons(c曲リストノード, c曲リストノード.list子リスト, newPath, listStrBoxDefSkinSubfolderFullName);
// Process subfolders recussively
t曲リストへ後処理を適用する(c曲リストノード.list子リスト, newPath, false);
CSongDict.tReinsertBackButtons(songNode, songNode.list子リスト, newPath, listStrBoxDefSkinSubfolderFullName);
// Process subfolders recussively
tSongListPostprocessing(songNode.list子リスト, newPath, false);
continue;
}
//-----------------------------
}
//-----------------------------
#endregion
#region [ If no node title found, try to fetch it within the score objects ]
//-----------------------------
if (string.IsNullOrEmpty(c曲リストノード.ldTitle.GetString(""))) {
//-----------------------------
if (string.IsNullOrEmpty(songNode.ldTitle.GetString(""))) {
for (int j = 0; j < (int)Difficulty.Total; j++) {
if ((c曲リストノード.arスコア[j] != null) && !string.IsNullOrEmpty(c曲リストノード.arスコア[j].譜面情報.タイトル)) {
c曲リストノード.ldTitle = new CLocalizationData();
if ((songNode.arスコア[j] != null) && !string.IsNullOrEmpty(songNode.arスコア[j].譜面情報.タイトル)) {
songNode.ldTitle = new CLocalizationData();
if (OpenTaiko.ConfigIni.bOutputSongSearchLog)
Trace.TraceInformation("タイトルを設定しました。(nID#{0:D3}, title={1})", c曲リストノード.nID, c曲リストノード.ldTitle.GetString(""));
Trace.TraceInformation("タイトルを設定しました。(nID#{0:D3}, title={1})", songNode.nID, songNode.ldTitle.GetString(""));
break;
}
}
}
//-----------------------------
}
//-----------------------------
#endregion
}
}
//-----------------
}
//-----------------
#endregion
#region [ Sort Song List ]
//-----------------
public static void tSongListSortByPath(List<CSongListNode> nodeList) {
tSongListSortByPath(nodeList, 1, 0);
#region [ 曲リストソート ]
//-----------------
public static void t曲リストのソート1_絶対パス順(List<CSongListNode> ノードリスト) {
t曲リストのソート1_絶対パス順(ノードリスト, EInstrumentPad.Taiko, 1, 0);
foreach (CSongListNode c曲リストノード in ノードリスト) {
if ((c曲リストノード.list子リスト != null) && (c曲リストノード.list子リスト.Count > 1)) {
t曲リストのソート1_絶対パス順(c曲リストノード.list子リスト);
foreach (CSongListNode songNode in nodeList) {
if ((songNode.list子リスト != null) && (songNode.list子リスト.Count > 1)) {
tSongListSortByPath(songNode.list子リスト);
}
}
}
public static void t曲リストのソート1_絶対パス順(List<CSongListNode> ノードリスト, EInstrumentPad part, int order, params object[] p) {
public static void tSongListSortByPath(List<CSongListNode> nodeList, int order, params object[] p) {
var comparer = new ComparerChain<CSongListNode>(
new C曲リストノードComparerノード種別(),
new C曲リストノードComparer絶対パス(order),
new C曲リストノードComparerタイトル(order),
new C曲リストノードComparerSubtitle(order));
new CSongListNodeComparerNodeType(),
new CSongListNodeComparerUnlockStatus(),
new CSongListNodeComparerPath(order),
new CSongListNodeComparerTitle(order),
new CSongListNodeComparerSubtitle(order));
ノードリスト.Sort(comparer);
nodeList.Sort(comparer);
}
public static void t曲リストのソート2_タイトル順(List<CSongListNode> ノードリスト, EInstrumentPad part, int order, params object[] p) {
public static void tSongListSortByTitle(List<CSongListNode> nodeList, int order, params object[] p) {
var comparer = new ComparerChain<CSongListNode>(
new C曲リストノードComparerノード種別(),
new C曲リストノードComparerタイトル(order),
new C曲リストノードComparerSubtitle(order),
new C曲リストノードComparer絶対パス(order));
new CSongListNodeComparerNodeType(),
new CSongListNodeComparerUnlockStatus(),
new CSongListNodeComparerTitle(order),
new CSongListNodeComparerSubtitle(order),
new CSongListNodeComparerPath(order));
ノードリスト.Sort(comparer);
nodeList.Sort(comparer);
}
public static void tSongListSortBySubtitle(List<CSongListNode> ノードリスト, EInstrumentPad part, int order, params object[] p) {
public static void tSongListSortBySubtitle(List<CSongListNode> nodeList, int order, params object[] p) {
var comparer = new ComparerChain<CSongListNode>(
new C曲リストノードComparerノード種別(),
new C曲リストノードComparerSubtitle(order),
new C曲リストノードComparerタイトル(order),
new C曲リストノードComparer絶対パス(order));
new CSongListNodeComparerNodeType(),
new CSongListNodeComparerUnlockStatus(),
new CSongListNodeComparerSubtitle(order),
new CSongListNodeComparerTitle(order),
new CSongListNodeComparerPath(order));
ノードリスト.Sort(comparer);
nodeList.Sort(comparer);
}
public static void tSongListSortByLevel(List<CSongListNode> ノードリスト, EInstrumentPad part, int order, params object[] p) {
public static void tSongListSortByLevel(List<CSongListNode> nodeList, int order, params object[] p) {
var comparer = new ComparerChain<CSongListNode>(
new C曲リストノードComparerノード種別(),
new C曲リストノードComparerLevel(order),
new C曲リストノードComparerLevelIcon(order),
new C曲リストノードComparerタイトル(order),
new C曲リストノードComparerSubtitle(order),
new C曲リストノードComparer絶対パス(order));
ノードリスト.Sort(comparer);
}
public static void t曲リストのソート9_ジャンル順(List<CSongListNode> ノードリスト, EInstrumentPad part, int order, params object[] p) {
try {
var acGenreComparer = order == 1
? (IComparer<CSongListNode>)new C曲リストノードComparerAC8_14()
: new C曲リストノードComparerAC15();
var comparer = new ComparerChain<CSongListNode>(
new C曲リストノードComparerノード種別(),
acGenreComparer,
new C曲リストノードComparer絶対パス(1),
new C曲リストノードComparerタイトル(1));
ノードリスト.Sort(comparer);
} catch (Exception ex) {
Trace.TraceError(ex.ToString());
Trace.TraceError("例外が発生しましたが処理を継続します。 (bca6dda7-76ad-42fc-a415-250f52c0b17d)");
}
}
new CSongListNodeComparerNodeType(),
new CSongListNodeComparerUnlockStatus(),
new CSongListNodeComparerLevel(order),
new CSongListNodeComparerLevelIcon(order),
new CSongListNodeComparerTitle(order),
new CSongListNodeComparerSubtitle(order),
new CSongListNodeComparerPath(order));
nodeList.Sort(comparer);
}
#if TEST_SORTBGM
public static void t曲リストのソート9_BPM順( List<C曲リストノード> ノードリスト, E楽器パート part, int order, params object[] p )
{
@ -984,34 +949,34 @@ Debug.WriteLine( dBPM + ":" + c曲リストノード.strタイトル );
}
}
#endif
//-----------------
//-----------------
#endregion
// その他
// その他
#region [ private ]
//-----------------
//-----------------
public List<string> listStrBoxDefSkinSubfolderFullName {
get;
private set;
}
}
/// <summary>
/// 検索を中断_スローダウンする
/// </summary>
private void SlowOrSuspendSearchTask() {
if (this.bIsSuspending) // #27060 中断要求があったら、解除要求が来るまで待機
if (this.bIsSuspending) // #27060 中断要求があったら、解除要求が来るまで待機
{
AutoReset.WaitOne();
}
if (this.bIsSlowdown && ++this.searchCount > 10) // #27060 #PREMOVIE再生中は検索負荷を下げる
if (this.bIsSlowdown && ++this.searchCount > 10) // #27060 #PREMOVIE再生中は検索負荷を下げる
{
Thread.Sleep(100);
this.searchCount = 0;
}
}
//-----------------
}
//-----------------
#endregion
}

7
OpenTaiko/src/Songs/C曲リストノードComparers/C曲リストノードComparerAC15.cs
View File

@ -1,7 +0,0 @@
namespace OpenTaiko.C曲リストノードComparers;
internal sealed class C曲リストノードComparerAC15 : IComparer<CSongListNode> {
public int Compare(CSongListNode n1, CSongListNode n2) {
return CStrジャンルtoNum.ForAC15(n1.strジャンル).CompareTo(CStrジャンルtoNum.ForAC15(n2.strジャンル));
}
}

7
OpenTaiko/src/Songs/C曲リストノードComparers/C曲リストノードComparerAC8_14.cs
View File

@ -1,7 +0,0 @@
namespace OpenTaiko.C曲リストノードComparers;
internal sealed class C曲リストノードComparerAC8_14 : IComparer<CSongListNode> {
public int Compare(CSongListNode n1, CSongListNode n2) {
return CStrジャンルtoNum.ForAC8_14(n1.strジャンル).CompareTo(CStrジャンルtoNum.ForAC8_14(n2.strジャンル));
}
}

13
OpenTaiko/src/Songs/C曲リストノードComparers/C曲リストノードComparerタイトル.cs
View File

@ -1,13 +0,0 @@
namespace OpenTaiko.C曲リストノードComparers;
internal sealed class C曲リストノードComparerタイトル : IComparer<CSongListNode> {
private readonly int _order;
public C曲リストノードComparerタイトル(int order) {
this._order = order;
}
public int Compare(CSongListNode n1, CSongListNode n2) {
return _order * n1.ldTitle.GetString("").CompareTo(n2.ldTitle.GetString(""));
}
}

30
OpenTaiko/src/Songs/C曲リストノードComparers/C曲リストノードComparer絶対パス.cs
View File

@ -1,30 +0,0 @@
namespace OpenTaiko.C曲リストノードComparers;
internal sealed class C曲リストノードComparer絶対パス : IComparer<CSongListNode> {
private readonly int _order;
public C曲リストノードComparer絶対パス(int order) {
this._order = order;
}
public int Compare(CSongListNode n1, CSongListNode n2) {
if ((n1.eノード種別 == CSongListNode.ENodeType.BOX) && (n2.eノード種別 == CSongListNode.ENodeType.BOX)) {
return _order * n1.arスコア[0].ファイル情報.フォルダの絶対パス.CompareTo(n2.arスコア[0].ファイル情報.フォルダの絶対パス);
}
var str = strファイルの絶対パス(n1);
var strB = strファイルの絶対パス(n2);
return _order * str.CompareTo(strB);
}
private static string strファイルの絶対パス(CSongListNode c曲リストノード) {
for (int i = 0; i < (int)Difficulty.Total; i++) {
if (c曲リストノード.arスコア[i] != null) {
return c曲リストノード.arスコア[i].ファイル情報.ファイルの絶対パス ?? "";
}
}
return "";
}
}

2
OpenTaiko/src/Stages/02.Title/CEnumSongs.cs
View File

@ -363,7 +363,7 @@ internal class CEnumSongs // #27060 2011.2.7 yyagi 曲
Trace.Indent();
try {
this.Songs管理.t曲リストへ後処理を適用する();
this.Songs管理.tSongListPostprocessing();
} catch (Exception e) {
Trace.TraceError(e.ToString());
Trace.TraceError("例外が発生しましたが処理を継続します。 (6480ffa0-1cc1-40d4-9cc9-aceeecd0264b)");

6
OpenTaiko/src/Stages/05.SongSelect/CActSelect曲リスト.cs
View File

@ -160,20 +160,20 @@ internal class CActSelect曲リスト : CActivity {
}
public delegate void DGSortFunc(List<CSongListNode> songList, EInstrumentPad eInst, int order, params object[] p);
public delegate void DGSortFunc(List<CSongListNode> songList, int order, params object[] p);
/// <summary>
/// 主にCSong管理.cs内にあるソート機能を、delegateで呼び出す。
/// </summary>
/// <param name="sf">ソート用に呼び出すメソッド</param>
/// <param name="eInst">ソート基準とする楽器</param>
/// <param name="order">-1=降順, 1=昇順</param>
public void t曲リストのソート(DGSortFunc sf, EInstrumentPad eInst, int order, params object[] p) {
public void t曲リストのソート(DGSortFunc sf, int order, params object[] p) {
List<CSongListNode> songList = GetSongListWithinMe(this.rCurrentlySelectedSong);
if (songList == null) {
// 何もしない;
} else {
// CDTXMania.Songs管理.t曲リストのソート3_演奏回数の多い順( songList, eInst, order );
sf(songList, eInst, order, p);
sf(songList, order, p);
// this.r現在選択中の曲 = CDTXMania
void addBackBox(List<CSongListNode> list, string parentName = "/") {
foreach (CSongListNode node in list) {

52
OpenTaiko/src/Stages/05.SongSelect/CActSortSongs.cs
View File

@ -1,57 +1,57 @@
namespace OpenTaiko;
internal class CActSortSongs : CActSelectPopupMenu {
// Constructor
internal class CActSortSongs : CActSelectPopupMenu {
// Constructor
public CActSortSongs() {
List<CItemBase> lci = new List<CItemBase>();
lci.Add(new CItemList(CLangManager.LangInstance.GetString("SONGSELECT_SORT_PATH"), CItemBase.EPanelType.Normal, 0, "", "", new string[] { "Z,Y,X,...", "A,B,C,..." }));
lci.Add(new CItemList(CLangManager.LangInstance.GetString("SONGSELECT_SORT_TITLE"), CItemBase.EPanelType.Normal, 0, "", "", new string[] { "Z,Y,X,...", "A,B,C,..." }));
lci.Add(new CItemList(CLangManager.LangInstance.GetString("SONGSELECT_SORT_SUBTITLE"), CItemBase.EPanelType.Normal, 0, "", "", new string[] { "Z,Y,X,...", "A,B,C,..." }));
lci.Add(new CItemList(CLangManager.LangInstance.GetString("SONGSELECT_SORT_LEVEL"), CItemBase.EPanelType.Normal, 0, "", "", new string[] { "13,12,11,...", "1,2,3,..." }));
lci.Add(new CItemList(CLangManager.LangInstance.GetString("SONGSELECT_SORT_LEVEL"), CItemBase.EPanelType.Normal, 0, "", "", new string[] { "13,12,11,...", "1,2,3,..." }));
#if TEST_SORTBGM
lci.Add( new CItemList( "BPM", CItemBase.EPanelType.Normal, 0, "", "", new string[] { "300,200,...", "70,80,90,..." } ) );
#endif
lci.Add(new CItemList(CLangManager.LangInstance.GetString("MENU_RETURN"), CItemBase.EPanelType.Normal, 0, "", "", new string[] { "", "" }));
base.Initialize(lci, false, CLangManager.LangInstance.GetString("SONGSELECT_SORT"));
}
// メソッド
}
// メソッド
public void tActivatePopupMenu(EInstrumentPad einst, ref CActSelect曲リスト ca) {
this.act曲リスト = ca;
base.tActivatePopupMenu(einst);
}
public override void tEnter押下Main(int nSortOrder) {
nSortOrder *= 2; // 0,1 => -1, 1
nSortOrder *= 2; // 0,1 => -1, 1
nSortOrder -= 1;
switch ((EOrder)n現在の選択行) {
case EOrder.Path:
this.act曲リスト.t曲リストのソート(
CSongs管理.t曲リストのソート1_絶対パス順, eInst, nSortOrder
CSongs管理.tSongListSortByPath, nSortOrder
);
this.act曲リスト.t選択曲が変更された(true);
break;
case EOrder.Title:
this.act曲リスト.t曲リストのソート(
CSongs管理.t曲リストのソート2_タイトル順, eInst, nSortOrder
CSongs管理.tSongListSortByTitle, nSortOrder
);
this.act曲リスト.t選択曲が変更された(true);
break;
case EOrder.Subtitle:
this.act曲リスト.t曲リストのソート(
CSongs管理.tSongListSortBySubtitle, eInst, nSortOrder
CSongs管理.tSongListSortBySubtitle, nSortOrder
);
this.act曲リスト.t選択曲が変更された(true);
break;
case EOrder.Level:
this.act曲リスト.t曲リストのソート(
CSongs管理.tSongListSortByLevel, eInst, nSortOrder
CSongs管理.tSongListSortByLevel, nSortOrder
);
this.act曲リスト.t選択曲が変更された(true);
break;
break;
#if TEST_SORTBGM
case (int) ESortItem.BPM:
this.act曲リスト.t曲リストのソート(
@ -67,19 +67,19 @@ internal class CActSortSongs : CActSelectPopupMenu {
default:
break;
}
}
// CActivity 実装
}
// CActivity 実装
public override void DeActivate() {
if (!base.IsDeActivated) {
base.DeActivate();
}
}
}
#region [ private ]
//-----------------
//-----------------
private CActSelect曲リスト act曲リスト;
private enum EOrder : int {
@ -88,8 +88,8 @@ internal class CActSortSongs : CActSelectPopupMenu {
Subtitle = 2,
Level = 3,
Return = 4
}
//-----------------
}
//-----------------
#endregion
}