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

33
lck_cl_data_solution/LolDataRequestLib/ResponseData/AResponseData.cs Normal file
View File

@@ -0,0 +1,33 @@
using MongoDB.Bson;
using MongoDB.Driver;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LolDataRequestLib.ResponseData
{
internal abstract class AResponseData : IResponseData
{
protected MongoClient mDBClient = new MongoClient(DBDefine.MONGODB주소);
protected IMongoDatabase mEventDataBase = null;
public DataTable 디비데이터를데이터테이블로만듬() {
mEventDataBase = mDBClient.GetDatabase("datalol");
return buildDataForResponse(getDataFromMongo());
}
protected abstract BsonDocument getDataFromMongo();
protected abstract DataTable buildDataForResponse(BsonDocument recvDocument);
}
}

16
lck_cl_data_solution/LolDataRequestLib/ResponseData/IResponseData.cs Normal file
View File

@@ -0,0 +1,16 @@
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LolDataRequestLib
{
internal interface IResponseData
{
DataTable 디비데이터를데이터테이블로만듬();
}
}

68
lck_cl_data_solution/LolDataRequestLib/ResponseData/없는데이터/경기종료정보.cs Normal file
View File

@@ -0,0 +1,68 @@
using MongoDB.Bson;
using MongoDB.Driver;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LolDataRequestLib.ResponseData
{
internal class 경기종료정보 : AResponseData
{
protected override DataTable buildDataForResponse(BsonDocument recvDocument)
{
BsonValue bufGameEndData = null;
if (recvDocument != null)
{
bufGameEndData = recvDocument["eventDocument"];
}
DataTable gameEndData = new DataTable();
try
{
gameEndData.TableName = DBDefine.요청데이터분류.경기종료정보.ToString();
gameEndData.Columns.Add("승리팀");
gameEndData.Columns.Add("경기시간");
DataRow bufRow = gameEndData.NewRow();
bufRow["승리팀"] = (DBDefine.팀구분)bufGameEndData["winningTeam"].ToInt32();
bufRow["경기시간"] = bufGameEndData["gameTime"].ToInt32() / 1000;
gameEndData.Rows.Add(bufRow);
}
catch(Exception ex) { }
return gameEndData;
}
protected override BsonDocument getDataFromMongo()
{
//var filter = Builders<BsonDocument>.Filter.Eq("RequestGameID", DataManager.getInstance().mPlatformGameID);
var projection = Builders<BsonDocument>.Projection
.Exclude("_id")
.Include("eventDocument");
List<BsonDocument> documents = mEventDataBase.GetCollection<BsonDocument>("game_end")
.Find(new BsonDocument()) //.Find(filter)
.SortByDescending(x => x["sequenceIndex"])
.Project(projection)
.Limit(1)
.ToList();
return documents.Last();
}
}
}

155
lck_cl_data_solution/LolDataRequestLib/ResponseData/없는데이터/골드차이팀.cs Normal file
View File

@@ -0,0 +1,155 @@
using MongoDB.Bson;
using MongoDB.Driver;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LolDataRequestLib.ResponseData
{
internal class 골드차이팀 : AResponseData
{
protected override DataTable buildDataForResponse(BsonDocument recvDocument)
{
List<BsonElement> bufPlayerDataList = null;
if (recvDocument != null)
{
bufPlayerDataList = recvDocument.Elements.ToList();
}
DataTable goldData = new DataTable();
goldData.TableName = DBDefine.요청데이터분류.골드차이팀.ToString();
goldData.Columns.Add("블루팀골드량");
goldData.Columns.Add("레드팀골드량");
goldData.Columns.Add("골드차");
goldData.Columns.Add("골드차블루최대");
goldData.Columns.Add("골드차레드최대");
goldData.Columns.Add("초");
int 골드차블루최대값 = 0;
int 골드차레드최대값 = 0;
foreach (BsonElement item in bufPlayerDataList)
{
DataRow bufRow = goldData.NewRow();
BsonArray itemValue = item.Value.ToBsonDocument()["teams"].AsBsonArray;
int 블루팀골드 = 0;
int 레드팀골드 = 0;
foreach (BsonValue itemTeam in itemValue)
{
if (itemTeam["teamID"].ToInt32() == (int)DBDefine.팀구분.블루)
{
블루팀골드 = itemTeam["totalGold"].ToInt32();
}
else
{
레드팀골드 = itemTeam["totalGold"].ToInt32();
}
}
bufRow["블루팀골드량"] = 블루팀골드;
bufRow["레드팀골드량"] = 레드팀골드;
bufRow["골드차"] = 블루팀골드 - 레드팀골드;
if (골드차블루최대값 < (블루팀골드 - 레드팀골드))
{
골드차블루최대값 = (블루팀골드 - 레드팀골드);
}
if (골드차레드최대값 < (레드팀골드 - 블루팀골드))
{
골드차레드최대값 = (레드팀골드 - 블루팀골드);
}
bufRow["골드차블루최대"] = 골드차블루최대값;
bufRow["골드차레드최대"] = 골드차레드최대값 * -1;
bufRow["초"] = item.Value["gameTime"].ToInt32() / 1000;
goldData.Rows.Add(bufRow);
}
return goldData;
}
protected override BsonDocument getDataFromMongo()
{
// 필요한 필드만 포함하는 필터 문서를 생성합니다.
var subFilter = MongoDB.Bson.Serialization.BsonSerializer.Deserialize<BsonDocument>("{'eventDocument.playbackID' : 1, 'eventDocument.teams.totalGold' : 1, 'eventDocument.teams.teamID' : 1, 'eventDocument.sequenceIndex' : 1, " +
"'eventDocument.gameTime' : 1, 'eventDocument.parentGameID': 1, 'eventDocument.repeater_timestamp': 1}");
//var subFilter = MongoDB.Bson.Serialization.BsonSerializer.Deserialize<BsonDocument>("{'eventDocument.playbackID' : 1, 'eventDocument.teams.totalGold' : 1, 'eventDocument.teams.teamID' : 1,'eventDocument.sequenceIndex' : 1, 'eventDocument.gameTime' : 1}");
// MongoDB 컬렉션 "stats_update"에서 전체 문서를 가져오고 필요한 필드만 Projection합니다.
List<BsonDocument> documents = mEventDataBase.GetCollection<BsonDocument>("stats_update")
.Find(new BsonDocument())
.Project(subFilter)
.ToList();
//documents = documents.OrderBy(r => r["eventDocument"]["sequenceIndex"].ToInt32()).ToList();
documents = documents.OrderBy(r => DateTime.Parse(r["eventDocument"]["repeater_timestamp"].AsString)).ToList();
BsonDocument rtnValue = new BsonDocument();
// 이전 이벤트의 RequestGameID를 저장할 변수입니다.
string previousRequestGameID = null;
foreach (BsonDocument item in documents)
{
try
{
// 현재 이벤트의 RequestGameID 값을 추출합니다.
string currentRequestGameID = item["eventDocument"]["parentGameID"].ToString();
// 롤백 상황 감지:
// 이전 이벤트의 RequestGameID가 존재하고, 현재 이벤트의 값과 다르다면
// 이는 롤백 후 새로운 게임 데이터가 들어왔음을 의미합니다.
if (previousRequestGameID != null && !currentRequestGameID.Equals(previousRequestGameID))
{
// 현재 이벤트의 gameTime을 롤백 기준으로 설정합니다.
int rollbackThreshold = item["eventDocument"]["gameTime"].ToInt32();
// 지금까지 모아둔 데이터(rtnValue) 중 gameTime이 rollbackThreshold 미만인 이벤트만 유지합니다.
List<BsonElement> filteredElements = rtnValue.ToList()
.Where(d => d.Value["gameTime"].ToInt32() < rollbackThreshold)
.ToList();
rtnValue = new BsonDocument(filteredElements);
}
// 현재 이벤트 정보를 새 BsonDocument로 준비합니다.
BsonDocument bufDocument = new BsonDocument();
bufDocument.Add("gameTime", item["eventDocument"]["gameTime"].ToInt32());
bufDocument.Add("teams", item["eventDocument"]["teams"].AsBsonArray);
bufDocument.Add("playback", item["eventDocument"]["playbackID"].ToString());
bufDocument.Add("parentGameID", item["eventDocument"]["parentGameID"]);
// sequenceIndex 값을 Key로 하여 해당 이벤트를 rtnValue에 추가합니다.
rtnValue.Add(item["eventDocument"]["sequenceIndex"].ToString(), bufDocument);
// 다음 반복을 위해 이전 RequestGameID를 업데이트합니다.
previousRequestGameID = currentRequestGameID;
}
catch(Exception ex)
{
Console.WriteLine(ex.Message);
}
}
return rtnValue;
}
}
}

133
lck_cl_data_solution/LolDataRequestLib/ResponseData/없는데이터/룬데이터.cs Normal file
View File

@@ -0,0 +1,133 @@
using MongoDB.Bson;
using MongoDB.Driver;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LolDataRequestLib.ResponseData
{
internal class 룬데이터 : AResponseData
{
protected override DataTable buildDataForResponse(BsonDocument recvDocument)
{
BsonArray bufPlayerDataList = null;
DataTable 룬데이터테이블 = new DataTable();
룬데이터테이블.TableName = DBDefine.요청데이터분류.룬데이터.ToString();
룬데이터테이블.Columns.Add("팀");
룬데이터테이블.Columns.Add("선수이름");
룬데이터테이블.Columns.Add("챔피언이름");
룬데이터테이블.Columns.Add("메인룬스타일");
룬데이터테이블.Columns.Add("메인룬이름");
룬데이터테이블.Columns.Add("서브룬스타일");
룬데이터테이블.Columns.Add("서브룬이름");
룬데이터테이블.Columns.Add("룬1");
룬데이터테이블.Columns.Add("룬2");
룬데이터테이블.Columns.Add("룬3");
룬데이터테이블.Columns.Add("룬4");
룬데이터테이블.Columns.Add("룬5");
룬데이터테이블.Columns.Add("룬6");
룬데이터테이블.Columns.Add("룬7");
룬데이터테이블.Columns.Add("룬8");
룬데이터테이블.Columns.Add("룬9");
룬데이터테이블.Columns.Add("룬10");
룬데이터테이블.Columns.Add("룬배열");
if (recvDocument == null)
{
return 룬데이터테이블;
}
bufPlayerDataList = recvDocument["eventDocument"]["participants"].AsBsonArray;
foreach (BsonValue item in bufPlayerDataList)
{
DataRow bufRow = 룬데이터테이블.NewRow();
bufRow["팀"] = (DBDefine.팀구분)item["teamID"].ToInt32();
bufRow["선수이름"] = item["summonerName"].ToString();
bufRow["챔피언이름"] = item["championName"].ToString();
if (!item.AsBsonDocument.Contains("perks"))
{
continue;
}
int 메인룬 = item["perks"][0]["perkStyle"].ToInt32();
bufRow["메인룬스타일"] = 메인룬;
if (DataManager.getInstance().mRuneTable.ContainsKey(메인룬))
{
bufRow["메인룬이름"] = DataManager.getInstance().mRuneTable[메인룬];
}
int 서브룬 = item["perks"][0]["perkSubStyle"].ToInt32();
bufRow["서브룬스타일"] = 서브룬;
if (DataManager.getInstance().mRuneTable.ContainsKey(서브룬))
{
bufRow["서브룬이름"] = DataManager.getInstance().mRuneTable[서브룬];
}
bufRow["룬배열"] = item["perks"][0]["perkIds"].ToString();
BsonArray runeArray = item["perks"][0]["perkIds"].AsBsonArray;
if (runeArray.Count != 0)
{
for (int i = 1; i < runeArray.Count + 1; i++)
{
int runeID = runeArray[i - 1].ToInt32();
if (DataManager.getInstance().mRuneTable.ContainsKey(runeID))
{
bufRow["룬" + i] = DataManager.getInstance().mRuneTable[runeID];
}
}
}
룬데이터테이블.Rows.Add(bufRow);
}
return 룬데이터테이블;
}
protected override BsonDocument getDataFromMongo()
{
//var filter = Builders<BsonDocument>.Filter.Eq("RequestGameID", DataManager.getInstance().mPlatformGameID);
var projection = Builders<BsonDocument>.Projection
.Exclude("_id")
.Include("eventDocument");
List<BsonDocument> documents = mEventDataBase.GetCollection<BsonDocument>("game_info")
.Find(new BsonDocument()) //.Find(filter)
.SortByDescending(x => x["sequenceIndex"])
.Project(projection)
.Limit(1)
.ToList();
if (documents.Count == 0)
{
return null;
}
return documents.Last();
}
}
}

400
lck_cl_data_solution/LolDataRequestLib/ResponseData/없는데이터/팟지선수.cs Normal file
View File

@@ -0,0 +1,400 @@
using MongoDB.Bson;
using MongoDB.Driver;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LolDataRequestLib.ResponseData
{
internal class 팟지선수 : AResponseData
{
private int nullToZero(string value)
{
try
{
return Convert.ToInt32(value);
}
catch(Exception e)
{
return 0;
}
}
private double nullToZeroD(string value)
{
try
{
return Convert.ToDouble(value);
}
catch (Exception e)
{
return 0;
}
}
protected override DataTable buildDataForResponse(BsonDocument recvDocument)
{
DataTable 팟지데이터테이블 = new DataTable();
팟지데이터테이블.TableName = DBDefine.요청데이터분류.팟지.ToString();
//선수관련
팟지데이터테이블.Columns.Add("게임시간");
팟지데이터테이블.Columns.Add("누적된분");
팟지데이터테이블.Columns.Add("팀구분");
팟지데이터테이블.Columns.Add("선수아이디");
팟지데이터테이블.Columns.Add("챔피언");
//KDA
팟지데이터테이블.Columns.Add("킬");
팟지데이터테이블.Columns.Add("데스");
팟지데이터테이블.Columns.Add("어시스트");
//데미지관련
팟지데이터테이블.Columns.Add("가한데미지");
팟지데이터테이블.Columns.Add("받은데미지");
팟지데이터테이블.Columns.Add("팀원에게준힐량");
팟지데이터테이블.Columns.Add("팀원의데미지를막아낸실드량");
//분당데미지관련
팟지데이터테이블.Columns.Add("분당가한데미지");
팟지데이터테이블.Columns.Add("분당받은데미지");
팟지데이터테이블.Columns.Add("분당팀원에게준힐량");
팟지데이터테이블.Columns.Add("분당팀원의데미지를막아낸실드량");
///스코어관련
팟지데이터테이블.Columns.Add("크립스코어");
팟지데이터테이블.Columns.Add("경험치");
팟지데이터테이블.Columns.Add("분당크립스코어");
팟지데이터테이블.Columns.Add("비전스코어");
팟지데이터테이블.Columns.Add("설치한와드수");
팟지데이터테이블.Columns.Add("부순와드수");
팟지데이터테이블.Columns.Add("골드획득량");
팟지데이터테이블.Columns.Add("분당골드획득량");
//CC
팟지데이터테이블.Columns.Add("군중제어점수");
팟지데이터테이블.Columns.Add("다른챔피언에CC기를건시간");
//추가
팟지데이터테이블.Columns.Add("킬관여율");
팟지데이터테이블.Columns.Add("골드당데미지");
팟지데이터테이블.Columns.Add("팀내데미지비중");
//2022 데이터 추가 중립크립스코어
팟지데이터테이블.Columns.Add("라인크립스코어");
팟지데이터테이블.Columns.Add("정글크립스코어");
//2022 데이터 추가 현상금
팟지데이터테이블.Columns.Add("현재현상금");
if (m팟지데이터들.Count == 0 || m팀데이터들.Count == 0)
{
return 팟지데이터테이블;
}
Dictionary<int, int> 블루팀_킬_수 = new Dictionary<int, int>();
Dictionary<int, int> 퍼플팀_킬_수 = new Dictionary<int, int>();
foreach (BsonDocument item in m팀데이터들)
{
BsonArray bufTeamArray = item.Values.Last().AsBsonArray;
foreach (BsonValue itemTeam in bufTeamArray)
{
if (itemTeam["teamID"].ToInt32() == (int)DBDefine.팀구분.블루)
{
블루팀_킬_수.Add(Convert.ToInt32(item.Names.Last()), nullToZero(itemTeam["championsKills"].ToString()));
}
else
{
퍼플팀_킬_수.Add(Convert.ToInt32(item.Names.Last()), nullToZero(itemTeam["championsKills"].ToString()));
}
}
}
Dictionary<int, double> 블루팀_데미지_합 = new Dictionary<int, double>();
Dictionary<int, double> 퍼플팀_데미지_합 = new Dictionary<int, double>();
foreach (BsonDocument item in m팟지데이터들)
{
int gameTime = Convert.ToInt32(item.Names.Last());
double gameTimeMin = Convert.ToDouble(gameTime) / 60.0;
BsonArray bufPlayersData = item.Values.Last().AsBsonArray;
foreach (var itemPlayer in bufPlayersData)
{
DataRow bufRow = 팟지데이터테이블.NewRow();
bufRow["게임시간"] = gameTime;
bufRow["누적된분"] = gameTimeMin;
bufRow["팀구분"] = (DBDefine.팀구분)itemPlayer["teamID"].ToInt32();
bufRow["선수아이디"] = itemPlayer["playerName"].ToString();
bufRow["챔피언"] = itemPlayer["championName"].ToString();
//스텟이 아닌 선수정보에 있는 것들
bufRow["경험치"] = itemPlayer["XP"].ToInt32();
bufRow["골드획득량"] = itemPlayer["totalGold"].ToInt32();
bufRow["분당골드획득량"] = itemPlayer["totalGold"].ToDouble() / (gameTimeMin);
bufRow["현재현상금"] = itemPlayer["shutdownValue"].ToInt32();
BsonArray bufStats = itemPlayer["stats"].AsBsonArray;
foreach (BsonValue itemStats in bufStats)
{
switch (itemStats["name"].ToString())
{
case "CHAMPIONS_KILLED":
try { bufRow["킬"] = itemStats["value"].ToString(); }
catch (Exception ex) { bufRow["킬"] = "0"; }
break;
case "NUM_DEATHS":
try { bufRow["데스"] = itemStats["value"].ToString(); }
catch (Exception ex) { bufRow["데스"] = "0"; }
break;
case "ASSISTS":
try { bufRow["어시스트"] = itemStats["value"].ToString(); }
catch (Exception ex) { bufRow["어시스트"] = "0"; }
break;
//데미지관련
case "TOTAL_DAMAGE_DEALT_TO_CHAMPIONS":
bufRow["가한데미지"] = itemStats["value"].ToInt32();
bufRow["분당가한데미지"] = itemStats["value"].ToDouble() / (gameTimeMin);
bufRow["골드당데미지"] = itemStats["value"].ToDouble() / itemPlayer["totalGold"].ToDouble();
if ((DBDefine.팀구분)itemPlayer["teamID"].ToInt32() == DBDefine.팀구분.블루)
{
if (!블루팀_데미지_합.ContainsKey(Convert.ToInt32(bufRow["게임시간"])))
{
블루팀_데미지_합.Add(Convert.ToInt32(bufRow["게임시간"]), itemStats["value"].ToInt32());
}
else
{
블루팀_데미지_합[Convert.ToInt32(bufRow["게임시간"])] += itemStats["value"].ToInt32();
}
}
else
{
if (!퍼플팀_데미지_합.ContainsKey(Convert.ToInt32(bufRow["게임시간"])))
{
퍼플팀_데미지_합.Add(Convert.ToInt32(bufRow["게임시간"]), itemStats["value"].ToInt32());
}
else
{
퍼플팀_데미지_합[Convert.ToInt32(bufRow["게임시간"])] += itemStats["value"].ToInt32();
}
}
break;
case "TOTAL_DAMAGE_TAKEN":
bufRow["받은데미지"] = itemStats["value"].ToInt32();
bufRow["분당받은데미지"] = itemStats["value"].ToDouble() / (gameTimeMin);
break;
case "TOTAL_HEAL_ON_TEAMMATES":
bufRow["팀원에게준힐량"] = itemStats["value"].ToInt32();
bufRow["분당팀원에게준힐량"] = itemStats["value"].ToDouble() / (gameTimeMin);
break;
case "TOTAL_DAMAGE_SHIELDED_ON_TEAMMATES":
bufRow["팀원의데미지를막아낸실드량"] = itemStats["value"].ToInt32();
bufRow["분당팀원의데미지를막아낸실드량"] = itemStats["value"].ToDouble() / (gameTimeMin);
break;
///스코어관련
case "MINIONS_KILLED":
bufRow["라인크립스코어"] = nullToZero(itemStats["value"].ToString());
//bufRow["분당크립스코어수급량"] = itemStats["value"].ToDouble()/(gameTimeMin);
break;
case "NEUTRAL_MINIONS_KILLED":
bufRow["정글크립스코어"] = itemStats["value"].ToInt32();
break;
case "VISION_SCORE":
bufRow["비전스코어"] = itemStats["value"].ToInt32();
break;
case "WARD_PLACED":
bufRow["설치한와드수"] = itemStats["value"].ToString();
break;
case "WARD_KILLED":
bufRow["부순와드수"] = itemStats["value"].ToString();
break;
case "TOTAL_TIME_CROWD_CONTROL_DEALT":
bufRow["군중제어점수"] = itemStats["value"].ToString();
break;
case "TIME_CCING_OTHERS":
bufRow["다른챔피언에CC기를건시간"] = itemStats["value"].ToString();
break;
}
}
//bufRow["크립스코어"] = Convert.ToInt32(bufRow["라인크립스코어"]) + Convert.ToInt32(bufRow["정글크립스코어"]);
//bufRow["분당크립스코어"] = Convert.ToDouble(bufRow["크립스코어"]) / (gameTimeMin);
bufRow["크립스코어"] = nullToZero(bufRow["라인크립스코어"].ToString()) + nullToZero(bufRow["정글크립스코어"].ToString());
bufRow["분당크립스코어"] = nullToZeroD(bufRow["크립스코어"].ToString()) / (gameTimeMin);
팟지데이터테이블.Rows.Add(bufRow);
}
}
foreach (DataRow bufRow in 팟지데이터테이블.Rows)
{
if (bufRow["팀구분"].ToString() == "블루")
{
try
{
bufRow["팀내데미지비중"] = Convert.ToDouble(bufRow["가한데미지"]) / 블루팀_데미지_합[Convert.ToInt32(bufRow["게임시간"])] * 100.0;
}
catch(Exception ex)
{
bufRow["팀내데미지비중"] = "Err";
}
try
{
bufRow["킬관여율"] = (nullToZeroD(bufRow["킬"].ToString()) + nullToZeroD(bufRow["어시스트"].ToString())) / 블루팀_킬_수[Convert.ToInt32(bufRow["게임시간"])] * 100.0;
}
catch(Exception ex)
{
bufRow["킬관여율"] = "Err";
}
}
else
{
try
{
bufRow["팀내데미지비중"] = Convert.ToDouble(bufRow["가한데미지"]) / 퍼플팀_데미지_합[Convert.ToInt32(bufRow["게임시간"])] * 100.0;
}
catch(Exception ex)
{
bufRow["팀내데미지비중"] = "Err";
}
try
{
bufRow["킬관여율"] = (nullToZeroD(bufRow["킬"].ToString()) + nullToZeroD(bufRow["어시스트"].ToString())) / 퍼플팀_킬_수[Convert.ToInt32(bufRow["게임시간"])] * 100.0;
}
catch(Exception ex)
{
bufRow["킬관여율"] = "Err";
}
}
}
팟지데이터테이블.Columns.Remove("게임시간");
return 팟지데이터테이블;
}
List<BsonDocument> m팟지데이터들 = new List<BsonDocument>();
List<BsonDocument> m팀데이터들 = new List<BsonDocument>();
protected override BsonDocument getDataFromMongo()
{
//팟지데이터는 5분단위로 누적.
//ex ~5 ~10 ~15 ~20 ~25 ~30... 마지막데이터는 0
//맨 처음 전체데이터로 경기시간을 구한다음 시간으로 나눈다?
if (DataManager.getInstance().경기데이터 == null)
{
return null;
}
int 경기시간 = DataManager.getInstance().경기데이터["gameTime"].ToInt32() / 1000;
int 앞에서부터초 = 0;
m팟지데이터들 = new List<BsonDocument>();
m팀데이터들 = new List<BsonDocument>();
while (경기시간 - 앞에서부터초 > 0)
{
앞에서부터초 += 5 * 60;
BsonDocument rtnValue = new BsonDocument();
//var subfilter1 = Builders<BsonDocument>.Filter.Eq("RequestGameID", DataManager.getInstance().mPlatformGameID);
var subFilter2 = MongoDB.Bson.Serialization.BsonSerializer.Deserialize<BsonDocument>("{'eventDocument.gameTime' : {$lt : " + 앞에서부터초 * 1000 + " }}");
var filter1 = Builders<BsonDocument>.Filter.And(subFilter2); //var filter1 = Builders<BsonDocument>.Filter.And(subfilter1, subFilter2);
var projectionFilter = MongoDB.Bson.Serialization.BsonSerializer.Deserialize<BsonDocument>("{'eventDocument.participants' : 1, 'eventDocument.teams' : 1}");
List<BsonDocument> documents = mEventDataBase.GetCollection<BsonDocument>("stats_update")
.Find(filter1)
.SortByDescending(x => x["sequenceIndex"])
.Limit(1)
.ToList();
///경기의 마지막정보는 경기시간으로 리턴.
if (앞에서부터초 > 경기시간)
{
rtnValue.Add(경기시간.ToString(), documents.Last()["eventDocument"]["participants"].AsBsonArray);
}
else
{
rtnValue.Add(앞에서부터초.ToString(), documents.Last()["eventDocument"]["participants"].AsBsonArray);
}
m팟지데이터들.Add(rtnValue);
rtnValue = new BsonDocument();
if (앞에서부터초 > 경기시간)
{
rtnValue.Add(경기시간.ToString(), documents.Last()["eventDocument"]["teams"].AsBsonArray);
}
else
{
rtnValue.Add(앞에서부터초.ToString(), documents.Last()["eventDocument"]["teams"].AsBsonArray);
}
m팀데이터들.Add(rtnValue);
}
//구조를 위해 리턴은 하지만 이 상속클래스는 BsonDocument를 멤버변수 kv페어로 관리한다.
return new BsonDocument();
}
}
}

145
lck_cl_data_solution/LolDataRequestLib/ResponseData/없는데이터/한타딜량범위.cs Normal file
View File

@@ -0,0 +1,145 @@
using MongoDB.Bson;
using MongoDB.Driver;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace LolDataRequestLib.ResponseData
{
internal class 한타딜량범위 : AResponseData
{
int 시작초 = 0;
int 종료초 = 0;
internal 한타딜량범위(int 받아온시작초, int 받아온종료초)
{
시작초 = 받아온시작초;
종료초 = 받아온종료초;
}
protected override DataTable buildDataForResponse(BsonDocument recvDocument)
{
DataTable 한타딜량범위 = new DataTable();
한타딜량범위.TableName = DBDefine.요청데이터분류.한타딜량범위.ToString();
//선수관련
한타딜량범위.Columns.Add("팀구분");
한타딜량범위.Columns.Add("선수아이디");
한타딜량범위.Columns.Add("챔피언");
//데미지관련
한타딜량범위.Columns.Add("데미지차이");
한타딜량범위.Columns.Add("시작데미지량");
한타딜량범위.Columns.Add("종료데미지량");
한타딜량범위.Columns.Add("딜량백분율");
if (m시작데이터.Count() == 0 || m종료데이터.Count() == 0)
{
return 한타딜량범위;
}
BsonArray 시작데이터선수리스트 = m시작데이터["participants"].AsBsonArray;
foreach (BsonDocument itemPlayer in 시작데이터선수리스트)
{
DataRow bufRow = 한타딜량범위.NewRow();
bufRow["팀구분"] = (DBDefine.팀구분)itemPlayer["teamID"].ToInt32();
bufRow["선수아이디"] = itemPlayer["playerName"].ToString();
bufRow["챔피언"] = itemPlayer["championName"].ToString();
bufRow["시작데미지량"] = itemPlayer["stats"].AsBsonArray.ToList().Where(v => v["name"] == "TOTAL_DAMAGE_DEALT_TO_CHAMPIONS").ToList()[0]["value"];
한타딜량범위.Rows.Add(bufRow);
}
BsonArray 종료데이터선수리스트 = m종료데이터["participants"].AsBsonArray;
foreach (BsonDocument itemPlayer in 종료데이터선수리스트)
{
DataRow bufPlayerRow = 한타딜량범위.AsEnumerable().Where(r => r.Field<String>("선수아이디") == itemPlayer["playerName"].ToString()).Last();
bufPlayerRow["종료데미지량"] = itemPlayer["stats"].AsBsonArray.ToList().Where(v => v["name"] == "TOTAL_DAMAGE_DEALT_TO_CHAMPIONS").ToList()[0]["value"];
bufPlayerRow["데미지차이"] = Convert.ToDouble(bufPlayerRow["종료데미지량"]) - Convert.ToDouble(bufPlayerRow["시작데미지량"]);
}
double 최대딜량 = Convert.ToDouble(한타딜량범위.AsEnumerable().OrderByDescending(r => Convert.ToDouble(r.Field<string>("데미지차이"))).First()["데미지차이"]);
foreach (DataRow item in 한타딜량범위.Rows)
{
double 딜량차이값 = Convert.ToDouble(item["데미지차이"]);
if (딜량차이값 != 0)
{
item["딜량백분율"] = 딜량차이값 / 최대딜량 * 100.0;
}
else
{
item["딜량백분율"] = 0.0;
}
}
return 한타딜량범위;
}
BsonDocument m시작데이터 = new BsonDocument();
BsonDocument m종료데이터 = new BsonDocument();
protected override BsonDocument getDataFromMongo()
{
//var subfilter1 = Builders<BsonDocument>.Filter.Eq("RequestGameID", DataManager.getInstance().mPlatformGameID);
var subFilter2 = MongoDB.Bson.Serialization.BsonSerializer.Deserialize<BsonDocument>("{'eventDocument.gameTime' : {$lt : " + 시작초 * 1000 + " }}");
var filter1 = Builders<BsonDocument>.Filter.And(subFilter2); //var filter1 = Builders<BsonDocument>.Filter.And(subfilter1, subFilter2);
var projectionFilter = MongoDB.Bson.Serialization.BsonSerializer.Deserialize<BsonDocument>("{'eventDocument.participants' : 1 , 'eventDocument.gameTime' : 1 }");
List<BsonDocument> documents = mEventDataBase.GetCollection<BsonDocument>("stats_update")
.Find(filter1)
.Project(projectionFilter)
.SortByDescending(x => x["sequenceIndex"])
.Limit(1)
.ToList();
m시작데이터 = documents.Last()["eventDocument"].AsBsonDocument;
subFilter2 = MongoDB.Bson.Serialization.BsonSerializer.Deserialize<BsonDocument>("{'eventDocument.gameTime' : {$lt : " + 종료초 * 1000 + " }}");
filter1 = Builders<BsonDocument>.Filter.And(subFilter2); //filter1 = Builders<BsonDocument>.Filter.And(subfilter1, subFilter2);
List<BsonDocument> documents2 = mEventDataBase.GetCollection<BsonDocument>("stats_update")
.Find(filter1)
.SortByDescending(x => x["sequenceIndex"])
.Project(projectionFilter)
.Limit(1)
.ToList();
m종료데이터 = documents2.Last()["eventDocument"].AsBsonDocument;
//구조를 위해 리턴은 하지만 이 상속클래스는 BsonDocument를 멤버변수 kv페어로 관리한다.
return new BsonDocument();
}
}
}

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 픽리스트테이블;
}
}
}