Wickedness/lol_coder
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

초기 커밋.

Browse Source
This commit is contained in:
y2keui
2026-04-01 20:20:09 +09:00
parent c286f362e5
commit fd1a2cba32
172 changed files with 43588 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
lck_cl_data_solution/LolDataRequestLib/ResponseData/있는데이터/KDA선수.cs Normal file
View File

@@ -0,0 +1,83 @@
using MongoDB.Bson;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LolDataRequestLib.ResponseData
{
class KDA선수 : IResponseData
{
public DataTable 디비데이터를데이터테이블로만듬()
{
DataTable 킬뎃어시테이블 = new DataTable(DBDefine.요청데이터분류.킬뎃어시.ToString());
try
{
List<BsonValue> 선수데이터들 = DataManager.getInstance().경기데이터["participants"].AsBsonArray.ToList();
킬뎃어시테이블.Columns.Add("팀");
//픽리스트테이블.Columns.Add("포지션");
킬뎃어시테이블.Columns.Add("선수닉네임");
킬뎃어시테이블.Columns.Add("챔피언이름");
킬뎃어시테이블.Columns.Add("킬");
킬뎃어시테이블.Columns.Add("데스");
킬뎃어시테이블.Columns.Add("어시스트");
for (int i = 0; i < 선수데이터들.Count(); i++)
{
BsonValue item = 선수데이터들[i];
DataRow bufRow = 킬뎃어시테이블.NewRow();
bufRow["팀"] = (DBDefine.팀구분)item["teamID"].ToInt32();
//bufRow["포지션"] = (DBDefine.라인구분)item["participantID"].AsInt32 + 1;
bufRow["선수닉네임"] = item["playerName"];
bufRow["챔피언이름"] = item["championName"];
try
{
bufRow["킬"] = item["stats"].AsBsonArray.Where(v => v["name"] == "CHAMPIONS_KILLED").ToList()[0]["value"];
}
catch(Exception ex)
{
bufRow["킬"] = "0";
}
try {
bufRow["데스"] = item["stats"].AsBsonArray.Where(v => v["name"] == "NUM_DEATHS").ToList()[0]["value"];
}
catch(Exception ex)
{
bufRow["데스"] = "0";
}
try
{
bufRow["어시스트"] = item["stats"].AsBsonArray.Where(v => v["name"] == "ASSISTS").ToList()[0]["value"];
}
catch (Exception ex)
{
bufRow["어시스트"] = "0";
}
킬뎃어시테이블.Rows.Add(bufRow);
}
}
catch(Exception ex) {
Console.WriteLine(ex.ToString());
}
return 킬뎃어시테이블;
}
}
}

69
lck_cl_data_solution/LolDataRequestLib/ResponseData/있는데이터/경험치레벨선수.cs Normal file
View File

@@ -0,0 +1,69 @@
using MongoDB.Bson;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LolDataRequestLib.ResponseData
{
class 경험치레벨선수 : IResponseData
{
public DataTable 디비데이터를데이터테이블로만듬()
{
DataTable 경험치레벨선수테이블 = new DataTable(DBDefine.요청데이터분류.경험치레벨.ToString());
try
{
경험치레벨선수테이블.Columns.Add("팀");
//픽리스트테이블.Columns.Add("포지션");
경험치레벨선수테이블.Columns.Add("선수닉네임");
경험치레벨선수테이블.Columns.Add("챔피언이름");
경험치레벨선수테이블.Columns.Add("레벨");
경험치레벨선수테이블.Columns.Add("경험치");
경험치레벨선수테이블.Columns.Add("경험치대비");
경험치레벨선수테이블.Columns.Add("레벨대비");
경험치레벨선수테이블.Columns.Add("퀘스트여부");
if (DataManager.getInstance().경기데이터 == null)
{
return 경험치레벨선수테이블;
}
List<BsonValue> 선수데이터들 = DataManager.getInstance().경기데이터["participants"].AsBsonArray.OrderByDescending(p => p["XP"].ToInt32()).ToList();
double maxXP = (double)선수데이터들[0]["XP"].ToInt32();
for (int i = 0; i < 선수데이터들.Count(); i++)
{
BsonValue item = 선수데이터들[i];
DataRow bufRow = 경험치레벨선수테이블.NewRow();
bufRow["팀"] = (DBDefine.팀구분)item["teamID"].ToInt32();
//bufRow["포지션"] = (DBDefine.라인구분)item["participantID"].AsInt32 + 1;
bufRow["선수닉네임"] = item["playerName"];
bufRow["챔피언이름"] = item["championName"];
bufRow["레벨"] = item["level"].ToInt32();
bufRow["경험치"] = item["XP"];
bufRow["경험치대비"] = (item["XP"].ToInt32() / maxXP) * 100;
//bufRow["레벨대비"] = (item["XP"].ToInt32() - 180 - (item["level"].ToInt32() * 180) / 180 + ((item["level"].ToInt32() + 1) * 180)) * 100;
경험치레벨선수테이블.Rows.Add(bufRow);
}
}
catch(Exception ex) { }
return 경험치레벨선수테이블;
}
}
}

67
lck_cl_data_solution/LolDataRequestLib/ResponseData/있는데이터/골드획득량선수.cs Normal file
View File

@@ -0,0 +1,67 @@
using MongoDB.Bson;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LolDataRequestLib.ResponseData
{
class 골드획득량선수 : IResponseData
{
public DataTable 디비데이터를데이터테이블로만듬()
{
DataTable 골드획득량선수테이블 = new DataTable(DBDefine.요청데이터분류.현재골드량선수.ToString());
try
{
골드획득량선수테이블.Columns.Add("팀");
//픽리스트테이블.Columns.Add("포지션");
골드획득량선수테이블.Columns.Add("선수닉네임");
골드획득량선수테이블.Columns.Add("챔피언이름");
골드획득량선수테이블.Columns.Add("총골드획득량");
골드획득량선수테이블.Columns.Add("보유골드량");
골드획득량선수테이블.Columns.Add("대비총골드퍼센트");
골드획득량선수테이블.Columns.Add("대비보유골드퍼센트");
if (DataManager.getInstance().경기데이터 == null)
{
return 골드획득량선수테이블;
}
List<BsonValue> 선수데이터들 = DataManager.getInstance().경기데이터["participants"].AsBsonArray.OrderByDescending(p => p["totalGold"].ToInt32()).ToList();
double maxGold = (double)선수데이터들[0]["totalGold"].ToInt32();
for (int i = 0; i < 선수데이터들.Count(); i++)
{
BsonValue item = 선수데이터들[i];
DataRow bufRow = 골드획득량선수테이블.NewRow();
bufRow["팀"] = (DBDefine.팀구분)item["teamID"].ToInt32();
//bufRow["포지션"] = (DBDefine.라인구분)item["participantID"].AsInt32 + 1;
bufRow["선수닉네임"] = item["playerName"];
bufRow["챔피언이름"] = item["championName"];
bufRow["총골드획득량"] = item["totalGold"].ToInt32();
bufRow["보유골드량"] = item["currentGold"];
bufRow["대비총골드퍼센트"] = (item["totalGold"].ToInt32() / maxGold) * 100;
bufRow["대비보유골드퍼센트"] = (item["currentGold"].ToInt32() / maxGold) * 100;
골드획득량선수테이블.Rows.Add(bufRow);
}
}
catch (Exception ex) { }
return 골드획득량선수테이블;
}
}
}

74
lck_cl_data_solution/LolDataRequestLib/ResponseData/있는데이터/누적데미지선수.cs Normal file
View File

@@ -0,0 +1,74 @@
using MongoDB.Bson;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LolDataRequestLib.ResponseData
{
class 누적데미지선수 : IResponseData
{
public DataTable 디비데이터를데이터테이블로만듬()
{
DataTable 데미지리스트테이블 = new DataTable("누적데미지");
데미지리스트테이블.Columns.Add("팀");
데미지리스트테이블.Columns.Add("선수닉네임");
데미지리스트테이블.Columns.Add("챔피언이름");
데미지리스트테이블.Columns.Add("총가한데미지");
데미지리스트테이블.Columns.Add("대비총데미지퍼센트");
if (DataManager.getInstance().경기데이터 == null)
{
return 데미지리스트테이블;
}
List<BsonValue> 선수데이터들 = DataManager.getInstance().경기데이터["participants"].AsBsonArray.ToList();
for (int i = 0; i < 선수데이터들.Count(); i++)
{
BsonValue item = 선수데이터들[i];
DataRow bufRow = 데미지리스트테이블.NewRow();
bufRow["팀"] = (DBDefine.팀구분)item["teamID"].ToInt32();
//bufRow["포지션"] = (DBDefine.라인구분)item["participantID"].AsInt32 + 1;
bufRow["선수닉네임"] = item["playerName"];
bufRow["챔피언이름"] = item["championName"];
bufRow["총가한데미지"] = item["stats"].AsBsonArray.Where(v => v["name"] == "TOTAL_DAMAGE_DEALT_TO_CHAMPIONS").ToList()[0]["value"];
데미지리스트테이블.Rows.Add(bufRow);
}
if (데미지리스트테이블.Rows.Count > 0)
{
데미지리스트테이블 = 데미지리스트테이블.AsEnumerable().OrderByDescending(r => Convert.ToDouble(r.Field<string>("총가한데미지"))).CopyToDataTable();
double maxDamageToChamps = Convert.ToDouble(데미지리스트테이블.Rows[0]["총가한데미지"].ToString());
foreach (DataRow item in 데미지리스트테이블.Rows)
{
item["대비총데미지퍼센트"] = Convert.ToDouble(item["총가한데미지"]) / maxDamageToChamps * 100;
}
}
데미지리스트테이블.TableName = DBDefine.요청데이터분류.현재데미지량선수.ToString();
return 데미지리스트테이블;
}
}
}

170
lck_cl_data_solution/LolDataRequestLib/ResponseData/있는데이터/밴데이터.cs Normal file
View File

@@ -0,0 +1,170 @@
using MongoDB.Bson;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LolDataRequestLib.ResponseData
{
class 밴데이터 : IResponseData
{
public DataTable 디비데이터를데이터테이블로만듬()
{
List<DataTable> rtnValue = new List<DataTable>();
DataTable 밴리스트테이블 = new DataTable(DBDefine.요청데이터분류.밴데이터.ToString());
rtnValue.Add(밴리스트테이블);
//추가 시작
// 1) 순번 컬럼을 int로 (정렬/비교 안정화)
밴리스트테이블.Columns.Add("순번", typeof(int));
밴리스트테이블.Columns.Add("챔피언ID");
밴리스트테이블.Columns.Add("챔피언이름");
밴리스트테이블.Columns.Add("팀");
// 여기부터 새로 넣기
var dm = DataManager.getInstance();
if (dm.밴픽데이터 == null || dm.밴픽데이터.IsBsonNull || !dm.밴픽데이터.IsBsonDocument)
{
밴리스트테이블.TableName = DBDefine.요청데이터분류.밴데이터.ToString();
return 밴리스트테이블;
}
var doc = dm.밴픽데이터.AsBsonDocument;
if (!doc.TryGetValue("bannedChampions", out var banned) || banned == null || banned.IsBsonNull || !banned.IsBsonArray)
{
밴리스트테이블.TableName = DBDefine.요청데이터분류.밴데이터.ToString();
return 밴리스트테이블;
}
//List<BsonValue> 밴데이터 = banned.AsBsonArray.ToList();
List<BsonValue> 밴데이터 = dm.밴픽데이터["bannedChampions"].AsBsonArray.ToList();
var turns = 밴데이터.Select(x => x["pickTurn"].ToInt32()).ToList();
bool isGlobalTurnFormat = turns.Any(t => t >= 13); // 1~6 + 13~16
bool isDirectSlotFormat = turns.Distinct().Count() == turns.Count // 1~10 같은 직접 슬롯
&& turns.All(t => t >= 1 && t <= 10);
foreach (BsonValue item in 밴데이터)
{
DataRow bufRow = 밴리스트테이블.NewRow();
int pickTurn = item["pickTurn"].ToInt32();
int teamId = item["teamID"].ToInt32();
int slot = 0;
/*
if (isDirectSlotFormat)
{
slot = pickTurn;
}
else if (isGlobalTurnFormat)
{
if (pickTurn >= 1 && pickTurn <= 6) slot = pickTurn;
else if (pickTurn >= 13 && pickTurn <= 16) slot = pickTurn - 6; // 13~16 => 7~10
else slot = 0;
}
else
{
int key = pickTurn + teamId;
if (!dm.밴픽순서테이블.TryGetValue(key, out slot))
slot = 0;
}
*/
//if (slot == 0) slot = 밴리스트테이블.Rows.Count + 1;
//bufRow["순번"] = slot;
bufRow["순번"] = pickTurn;
int selectedChamp = item["championID"].ToInt32();
bufRow["챔피언ID"] = selectedChamp;
bufRow["팀"] = item["teamID"].ToInt32();
if (selectedChamp > 0)
bufRow["챔피언이름"] = dm.mChampionTable[selectedChamp].champNameKOR;
else if (selectedChamp == -1)
bufRow["챔피언이름"] = "선택없음";
밴리스트테이블.Rows.Add(bufRow);
}
// 여기까지 새로 넣기
// 5) 정렬도 int 기준으로
if (밴리스트테이블.Rows.Count > 0)
{
밴리스트테이블 = 밴리스트테이블.AsEnumerable()
.OrderBy(r => r.Field<int>("순번"))
.CopyToDataTable();
}
////추가 끝
//밴리스트테이블.Columns.Add("순번");
//밴리스트테이블.Columns.Add("챔피언ID");
//밴리스트테이블.Columns.Add("챔피언이름");
//if (DataManager.getInstance().밴픽데이터 == null)
//{
// return 밴리스트테이블;
//}
//List<BsonValue> 밴데이터 = DataManager.getInstance().밴픽데이터["bannedChampions"].AsBsonArray.ToList();
//foreach (BsonValue item in 밴데이터)
//{
// DataRow bufRow = 밴리스트테이블.NewRow();
// //Console.WriteLine(item["pickTurn"].ToInt32() + item["teamID"].ToInt32());
// if (DataManager.getInstance().isNewBanPick)
// {
// bufRow["순번"] = item["pickTurn"].ToInt32();
// }
// else
// {
// bufRow["순번"] = DataManager.getInstance().밴픽순서테이블[item["pickTurn"].ToInt32() + item["teamID"].ToInt32()];
// }
// int selectedChamp = item["championID"].ToInt32();
// if (selectedChamp > 0 )
// {
// bufRow["챔피언이름"] = DataManager.getInstance().mChampionTable[selectedChamp];
// }
// if (selectedChamp == -1)
// {
// bufRow["챔피언이름"] = "선택없음";
// }
// bufRow["챔피언ID"] = selectedChamp;
// 밴리스트테이블.Rows.Add(bufRow);
//}
//if (밴리스트테이블.Rows.Count > 0)
//{
// 밴리스트테이블 = 밴리스트테이블.AsEnumerable().OrderBy(r => Convert.ToInt32(r.Field<string>("순번"))).CopyToDataTable();
//}
밴리스트테이블.TableName = DBDefine.요청데이터분류.밴데이터.ToString();
return 밴리스트테이블;
}
}
}

53
lck_cl_data_solution/LolDataRequestLib/ResponseData/있는데이터/아타칸데이터.cs Normal file
View File

@@ -0,0 +1,53 @@
using MongoDB.Bson;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LolDataRequestLib.ResponseData
{
class 아타칸데이터 //: IResponseData
{
//public DataTable 디비데이터를데이터테이블로만듬()
//{
// DataTable 아타칸리스폰테이블 = new DataTable(DBDefine.요청데이터분류.아타칸리스폰.ToString());
// 아타칸리스폰테이블.Columns.Add("아타칸정보");
// 아타칸리스폰테이블.Columns.Add("리스폰타임");
// if (DataManager.getInstance().아타칸리스폰== null)
// {
// return 아타칸리스폰테이블;
// }
// BsonDocument dd = DataManager.getInstance().아타칸리스폰.DeepClone().AsBsonDocument;
// dd.Remove("sequenceIndex");
// List<BsonElement> bufStructDataList = dd.ToList();
// foreach (BsonElement item in bufStructDataList)
// {
// DataRow bufRow = 아타칸리스폰테이블.NewRow();
// BsonDocument bufValue = item.Value.AsBsonDocument;
// bufRow["아타칸정보"] = bufValue["monsterName"].ToString();
// int 아타칸리스폰타임 = bufValue["sequenceIndex"].ToInt32();
// bufRow["리스폰타임"] = 아타칸리스폰타임;
// if (bufValue["monsterName"].ToString().Contains("Atakhan")) 아타칸리스폰테이블.Rows.Add(bufRow);
// }
// return 아타칸리스폰테이블;
//}
}
}

144
lck_cl_data_solution/LolDataRequestLib/ResponseData/있는데이터/오브젝트킬전체.cs Normal file
View File

@@ -0,0 +1,144 @@
using MongoDB.Bson;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LolDataRequestLib.ResponseData
{
class 오브젝트킬전체 : IResponseData
{
internal 오브젝트킬전체(bool recvIsPostGameData)
{
this.isPostGame = recvIsPostGameData;
}
bool isPostGame = false;
public DataTable 디비데이터를데이터테이블로만듬()
{
DataTable 오브젝트테이블 = new DataTable("오브젝트리스트");
오브젝트테이블.Columns.Add("오브젝트타입");
오브젝트테이블.Columns.Add("드래곤종류");
오브젝트테이블.Columns.Add("잡은팀");
오브젝트테이블.Columns.Add("킬시간");
오브젝트테이블.Columns.Add("킬분");
오브젝트테이블.Columns.Add("킬초");
//오브젝트테이블.Columns.Add("리젠분");
//오브젝트테이블.Columns.Add("리젠초");
if (DataManager.getInstance().오브젝트데이터 != null)
{
BsonDocument dd = DataManager.getInstance().오브젝트데이터.DeepClone().AsBsonDocument;
dd.Remove("sequenceIndex");
List<BsonElement> 오브젝트데이터들 = dd.ToList().OrderBy(e => e.Value.AsBsonDocument["gameTime"].ToInt32()).ToList();
bool is크로노 = false;
int Index크로노 = 0;
int nowSequenceIndex = 0;
//크로노브레이크를 대비해야 sequenceIndex 가 역변하는 순간이 존재하는지 확인하는 절차
for (int i = 0; i < 오브젝트데이터들.Count(); i++)
{
BsonValue item = 오브젝트데이터들[i].ToBsonDocument().AsBsonValue;
int sequenceIndex = item["Value"]["sequenceIndex"].ToInt32();
if (sequenceIndex > nowSequenceIndex) nowSequenceIndex = sequenceIndex;
else
{
is크로노 = true;
nowSequenceIndex = sequenceIndex;
Index크로노 = i;
break;
}
}
for (int i = 0; i < 오브젝트데이터들.Count(); i++)
{
BsonValue item = 오브젝트데이터들[i].ToBsonDocument().AsBsonValue;
int sequenceIndex = item["Value"]["sequenceIndex"].ToInt32();
DataRow bufRow = 오브젝트테이블.NewRow();
if (is크로노)
{
if (sequenceIndex >= nowSequenceIndex)
{
if (i < Index크로노)
{
continue;
}
}
}
if (item["Value"]["killerTeamID"].ToInt32() == 300)
{
continue;
}
bufRow["잡은팀"] = (DBDefine.팀구분)item["Value"]["killerTeamID"].ToInt32();
bufRow["오브젝트타입"] = item["Value"]["monsterType"].ToString();
int 킬시간베이직 = item["Value"]["gameTime"].ToInt32();
int 분 = 킬시간베이직 / 1000 / 60;
int 초 = 킬시간베이직 / 1000 - (분 * 60);
bufRow["킬시간"] = 킬시간베이직;
bufRow["킬분"] = 분;
bufRow["킬초"] = 초;
if (item["Value"]["monsterType"].AsString == "dragon")
{
//20210615 용이 상단에 딜레이보다 미리 들어가는 현상이 보여서 처리
if (킬시간베이직 > DataManager.getInstance().경기시간 * 1000 && !isPostGame)
{
continue;
}
bufRow["드래곤종류"] = item["Value"]["dragonType"];
}
오브젝트테이블.Rows.Add(bufRow);
}
}
if (오브젝트테이블.Rows.Count > 0)
{
DataTable 오브젝트킬결과테이블 = 오브젝트테이블.AsEnumerable().OrderBy(r => Convert.ToInt32(r.Field<string>("킬시간"))).CopyToDataTable();
오브젝트킬결과테이블.TableName = DBDefine.요청데이터분류.오브젝트킬.ToString();
return 오브젝트킬결과테이블;
}
else
{
오브젝트테이블.TableName = DBDefine.요청데이터분류.오브젝트킬.ToString();
return 오브젝트테이블;
}
}
}
}

55
lck_cl_data_solution/LolDataRequestLib/ResponseData/있는데이터/용데이터.cs Normal file
View File

@@ -0,0 +1,55 @@
using MongoDB.Bson;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LolDataRequestLib.ResponseData
{
class 용데이터 : IResponseData
{
public DataTable 디비데이터를데이터테이블로만듬()
{
DataTable 용리스폰테이블 = new DataTable(DBDefine.요청데이터분류.용리스폰.ToString());
용리스폰테이블.Columns.Add("용정보");
용리스폰테이블.Columns.Add("리스폰타임");
if (DataManager.getInstance().드래곤리스폰 == null)
{
return 용리스폰테이블;
}
BsonDocument dd = DataManager.getInstance().드래곤리스폰.DeepClone().AsBsonDocument;
dd.Remove("sequenceIndex");
List<BsonElement> bufStructDataList = dd.ToList();
foreach (BsonElement item in bufStructDataList)
{
DataRow bufRow = 용리스폰테이블.NewRow();
BsonDocument bufValue = item.Value.AsBsonDocument;
bufRow["용정보"] = bufValue["nextDragonName"].ToString();
int 용리스폰타임 = bufValue["nextDragonSpawnTime"].ToInt32();
bufRow["리스폰타임"] = 용리스폰타임;
용리스폰테이블.Rows.Add(bufRow);
}
return 용리스폰테이블;
}
}
}

56
lck_cl_data_solution/LolDataRequestLib/ResponseData/있는데이터/퀘스트완료여부.cs Normal file
View File

@@ -0,0 +1,56 @@
using MongoDB.Bson;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LolDataRequestLib.ResponseData
{
class 퀘스트완료여부 : IResponseData
{
public DataTable 디비데이터를데이터테이블로만듬()
{
DataTable 퀘스트완료여부테이블 = new DataTable(DBDefine.요청데이터분류.퀘스트완료여부.ToString());
try
{
퀘스트완료여부테이블.Columns.Add("팀");
//픽리스트테이블.Columns.Add("포지션");
퀘스트완료여부테이블.Columns.Add("선수닉네임");
퀘스트완료여부테이블.Columns.Add("챔피언이름");
퀘스트완료여부테이블.Columns.Add("퀘스트완료여부");
if (DataManager.getInstance().경기데이터 == null)
{
return 퀘스트완료여부테이블;
}
List<BsonValue> 선수데이터들 = DataManager.getInstance().경기데이터["participants"].AsBsonArray.OrderByDescending(p => p["roleBoundQuestComplete"].ToBoolean()).ToList();
for (int i = 0; i < 선수데이터들.Count(); i++)
{
BsonValue item = 선수데이터들[i];
DataRow bufRow = 퀘스트완료여부테이블.NewRow();
bufRow["팀"] = (DBDefine.팀구분)item["teamID"].ToInt32();
bufRow["선수닉네임"] = item["playerName"];
bufRow["챔피언이름"] = item["championName"];
bufRow["퀘스트완료여부"] = item["roleBoundQuestComplete"].ToBoolean();
퀘스트완료여부테이블.Rows.Add(bufRow);
}
}
catch (Exception ex) { }
return 퀘스트완료여부테이블;
}
}
}

77
lck_cl_data_solution/LolDataRequestLib/ResponseData/있는데이터/타워골드데이터.cs Normal file
View File

@@ -0,0 +1,77 @@
using MongoDB.Bson;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LolDataRequestLib.ResponseData
{
class 타워골드데이터 : IResponseData
{
public DataTable 디비데이터를데이터테이블로만듬()
{
DataTable 타워골드테이블 = new DataTable(DBDefine.요청데이터분류.타워골드데이터.ToString());
타워골드테이블.Columns.Add("지급원인");
타워골드테이블.Columns.Add("팀");
타워골드테이블.Columns.Add("선수");
타워골드테이블.Columns.Add("지급골드");
타워골드테이블.Columns.Add("타워위치");
타워골드테이블.Columns.Add("타워티어");
타워골드테이블.Columns.Add("게임시간");
if (DataManager.getInstance().타워골드데이터 == null)
{
return 타워골드테이블;
}
BsonDocument dd = DataManager.getInstance().타워골드데이터.DeepClone().AsBsonDocument;
dd.Remove("sequenceIndex");
List<BsonElement> bufStructDataList = dd.ToList();
//Console.WriteLine("타워파괴전체.cs : 시작");
foreach (BsonElement item in bufStructDataList)
{
DataRow bufRow = 타워골드테이블.NewRow();
BsonDocument bufValue = item.Value.AsBsonDocument;
//Console.WriteLine("타워파괴전체.cs 정보 : " + bufValue.ToString());
try
{
{
bufRow["지급원인"] = bufValue["source"].ToString();
bufRow["팀"] = bufValue["teamID"].ToString();
bufRow["선수"] = bufValue["recipientId"].ToString();
bufRow["지급골드"] = bufValue["amount"].ToString();
bufRow["타워위치"] = bufValue["lane"].ToString();
bufRow["타워티어"] = bufValue["turretTier"].ToString();
bufRow["게임시간"] = bufValue["gameTime"].ToString();
타워골드테이블.Rows.Add(bufRow);
}
}
catch (Exception ex)
{
}
}
return 타워골드테이블;
}
}
}

89
lck_cl_data_solution/LolDataRequestLib/ResponseData/있는데이터/타워파괴전체.cs Normal file
View File

@@ -0,0 +1,89 @@
using MongoDB.Bson;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LolDataRequestLib.ResponseData
{
class 타워파괴전체 : IResponseData
{
public DataTable 디비데이터를데이터테이블로만듬()
{
DataTable 타워철거테이블 = new DataTable(DBDefine.요청데이터분류.타워철거전체.ToString());
타워철거테이블.Columns.Add("타워부서진팀");
타워철거테이블.Columns.Add("경기시간(초)");
타워철거테이블.Columns.Add("파괴된라인");
타워철거테이블.Columns.Add("터렛티어");
타워철거테이블.Columns.Add("타워종류");
타워철거테이블.Columns.Add("타워위치");
타워철거테이블.Columns.Add("넥서스타워");
if (DataManager.getInstance().건물데이터 == null)
{
return 타워철거테이블;
}
BsonDocument dd = DataManager.getInstance().건물데이터.DeepClone().AsBsonDocument;
dd.Remove("sequenceIndex");
List<BsonElement> bufStructDataList = dd.ToList();
//Console.WriteLine("타워파괴전체.cs : 시작");
foreach (BsonElement item in bufStructDataList)
{
DataRow bufRow = 타워철거테이블.NewRow();
BsonDocument bufValue = item.Value.AsBsonDocument;
//Console.WriteLine("타워파괴전체.cs 정보 : " + bufValue.ToString());
//turretTier
try
{
bufRow["타워부서진팀"] = (DBDefine.팀구분)(bufValue["teamID"].ToInt32());
bufRow["경기시간(초)"] = (bufValue["gameTime"].ToInt32()) / 1000;
if (bufValue.AsBsonDocument.Contains("lane"))
{
bufRow["파괴된라인"] = bufValue["lane"].ToString();
if (bufValue.AsBsonDocument.Contains("turretTier"))
{
bufRow["터렛티어"] = bufValue["turretTier"].ToString();
}
if (bufValue.AsBsonDocument.Contains("nexusTurretName"))
{
bufRow["넥서스타워"] = bufValue["nexusTurretName"].ToString();
bufRow["타워위치"] = bufValue["position"].ToString();
}
bufRow["타워종류"] = bufValue["buildingType"].ToString();
타워철거테이블.Rows.Add(bufRow);
}
}
catch (Exception ex)
{
}
}
return 타워철거테이블;
}
}
}

101
lck_cl_data_solution/LolDataRequestLib/ResponseData/있는데이터/픽데이터.cs Normal file
View File

@@ -0,0 +1,101 @@
using MongoDB.Bson;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LolDataRequestLib.ResponseData
{
class 픽데이터 : IResponseData
{
public DataTable 디비데이터를데이터테이블로만듬()
{
DataTable 픽리스트테이블 = new DataTable(DBDefine.요청데이터분류.픽데이터.ToString());
픽리스트테이블.Columns.Add("팀");
//픽리스트테이블.Columns.Add("포지션");
픽리스트테이블.Columns.Add("선수닉네임");
픽리스트테이블.Columns.Add("챔피언ID");
픽리스트테이블.Columns.Add("챔피언이름");
픽리스트테이블.Columns.Add("픽상태");
픽리스트테이블.Columns.Add("선택스킨ID");
픽리스트테이블.Columns.Add("순번", typeof(int));
if (DataManager.getInstance().밴픽데이터 == null)
{
return 픽리스트테이블;
}
List<BsonValue> 블루픽데이터 = DataManager.getInstance().밴픽데이터["teamOne"].AsBsonArray.ToList();
foreach (BsonValue item in 블루픽데이터)
{
DataRow bufRow = 픽리스트테이블.NewRow();
bufRow["팀"] = DBDefine.팀구분.블루;
//bufRow["포지션"] = (DBDefine.라인구분)item["participantID"].AsInt32 + 1;
bufRow["선수닉네임"] = item["summonerName"];
int selectedChamp = item["championID"].ToInt32();
if (selectedChamp != 0)
{
bufRow["챔피언이름"] = DataManager.getInstance().mChampionTable[selectedChamp].champNameKOR;
}
bufRow["챔피언ID"] = selectedChamp;
bufRow["픽상태"] = (DBDefine.픽상태구분)item["pickMode"].ToInt32();
bufRow["선택스킨ID"] = item["championID"];
bufRow["순번"] = item["pickTurn"].ToInt32();
픽리스트테이블.Rows.Add(bufRow);
}
List<BsonValue> 퍼플픽데이터 = DataManager.getInstance().밴픽데이터["teamTwo"].AsBsonArray.ToList();
foreach (BsonValue item in 퍼플픽데이터)
{
DataRow bufRow = 픽리스트테이블.NewRow();
bufRow["팀"] = DBDefine.팀구분.퍼플;
//bufRow["포지션"] = (DBDefine.라인구분)item["participantID"].AsInt32 - 4;
bufRow["선수닉네임"] = item["summonerName"];
int selectedChamp = item["championID"].ToInt32();
if (selectedChamp != 0)
{
bufRow["챔피언이름"] = DataManager.getInstance().mChampionTable[selectedChamp].champNameKOR;
}
bufRow["챔피언ID"] = selectedChamp;
bufRow["픽상태"] = (DBDefine.픽상태구분)item["pickMode"].ToInt32();
bufRow["선택스킨ID"] = item["championID"];
bufRow["순번"] = item["pickTurn"].ToInt32();
픽리스트테이블.Rows.Add(bufRow);
}
if (DataManager.getInstance().isNewBanPick)
{
if (픽리스트테이블.Rows.Count > 0)
{
픽리스트테이블 = 픽리스트테이블.AsEnumerable()
.OrderBy(r => r.Field<string>("팀") == DBDefine.팀구분.블루.ToString() ? 0 : 1) // 블루 팀 우선
.ThenBy(r => r.Field<int>("순번")) // 같은 팀 내에서는 순번 오름차순
.CopyToDataTable();
}
}
return 픽리스트테이블;
}
}
}