Lonca İstatistikleri (guild stats)

DNA · 27 Ara 2020

guild guide.cpp:

war_map.h

search

private:
TWarMapInfo m_kMapInfo;
bool m_bEnded;

LPEVENT m_pkBeginEvent;
LPEVENT m_pkTimeoutEvent;
LPEVENT m_pkEndEvent;
LPEVENT m_pkResetFlagEvent;

add under

#ifndef DISABLE_WAR_BOARD
public:
typedef struct SMemberStats
{
std::string strPlayerName;
DWORD dwGuildId;

BYTE byLevel;
DWORD dwKills;
DWORD dwDeaths;
unsigned long long ullDamage;

SMemberStats() :
dwGuildId(0), byLevel(0), dwKills(0),
dwDeaths(0), ullDamage(0) {}
} TMemberStats;

typedef std::map<DWORD, TMemberStats *> TMemberStatsMap;

TMemberStats * RegisterMemberStats(CHARACTER * ch);
TMemberStats * GetMemberStats(CHARACTER * ch);
void SendStats(TMemberStats * pStats);
void SendStatusBoard(CHARACTER * ch);

private:
TMemberStatsMap map_MemberStats;
#endif

search

#include "locale_service.h"

add under

#include <boost/algorithm/string/replace.hpp>

search

void CWarMap::UpdateUserCount()
{
FSendUserCount f(
m_TeamData[0].dwID,
m_TeamData[0].GetAccumulatedJoinerCount(),
m_TeamData[1].dwID,
m_TeamData[1].GetAccumulatedJoinerCount(),
m_iObserverCount);

std::for_each(m_set_pkChr.begin(), m_set_pkChr.end(), f);
}

add under

#ifndef DISABLE_WAR_BOARD
CWarMap::TMemberStats * CWarMap::RegisterMemberStats(CHARACTER * ch)
{
DWORD dwPlayerID = ch->GetPlayerID();

CWarMap::TMemberStats * pStats = M2_NEW CWarMap::TMemberStats;
pStats->strPlayerName = ch->GetName();
pStats->byLevel = ch->GetLevel();

CGuild * pGuild = ch->GetGuild();

if (pGuild)
pStats->dwGuildId = pGuild->GetID();

boost::algorithm::replace_all(pStats->strPlayerName, " ", "_");
map_MemberStats.insert(CWarMap::TMemberStatsMap::value_type(dwPlayerID, pStats));

return pStats;
}

CWarMap::TMemberStats * CWarMap::GetMemberStats(CHARACTER * ch)
{
CWarMap::TMemberStats * pStats;

if (!ch)
return pStats;

DWORD dwPlayerID = ch->GetPlayerID();
CWarMap::TMemberStatsMap::iterator entry = map_MemberStats.find(dwPlayerID);

if (entry == map_MemberStats.end())
pStats = RegisterMemberStats(ch);
else
pStats = entry->second;

return pStats;
}

namespace
{
struct FScoreBoard
{
FScoreBoard(CWarMap::TMemberStats * pStats) : m_pStats(pStats) {}

void operator() (LPCHARACTER ch)
{
if (!ch || !m_pStats)
return;

ch->ChatPacket(CHAT_TYPE_COMMAND, "warboard update|%u|%s|%u|%u|%d|%llu", m_pStats->dwGuildId, m_pStats->strPlayerName.c_str(), m_pStats->dwKills, m_pStats->dwDeaths, m_pStats->byLevel, m_pStats->ullDamage);
}

CWarMap::TMemberStats * m_pStats;
};
}

void CWarMap::SendStats(CWarMap::TMemberStats * pStats)
{
FScoreBoard f(pStats);
std::for_each(m_set_pkChr.begin(), m_set_pkChr.end(), f);
}

void CWarMap::SendStatusBoard(CHARACTER * ch)
{
if (!ch)
return;

for (CWarMap::TMemberStatsMap::iterator it = map_MemberStats.begin(); it != map_MemberStats.end(); ++it)
{
CWarMap::TMemberStats * pStats = it->second;

if (!pStats)
continue;

ch->ChatPacket(CHAT_TYPE_COMMAND, "warboard update|%u|%s|%u|%u|%d|%llu", pStats->dwGuildId, pStats->strPlayerName.c_str(), pStats->dwKills, pStats->dwDeaths, pStats->byLevel, pStats->ullDamage);
}
}
#endif

search

if (isWarMember && gid != m_TeamData[0].dwID && gid != m_TeamData[1].dwID)
{
ch->SetQuestFlag("war.is_war_member", 0);
isWarMember = false;
}

add under

#ifndef DISABLE_WAR_BOARD
ch->ChatPacket(CHAT_TYPE_COMMAND, "warboard versus|%u|%s|%u|%s", m_TeamData[0].dwID, m_TeamData[0].pkGuild->GetName(), m_TeamData[1].dwID, m_TeamData[1].pkGuild->GetName());
#endif

search

m_set_pkChr.insert(ch);

add under

#ifndef DISABLE_WAR_BOARD
if (isWarMember)
{
CWarMap::TMemberStats * pStats = RegisterMemberStats(ch);
SendStats(pStats);
}

SendStatusBoard(ch);

ch->ChatPacket(CHAT_TYPE_COMMAND, "warboard toggle|1");
#endif

search

if (!GetTeamIndex(dwDeadGuild, idx))
return;

add under

#ifndef DISABLE_WAR_BOARD
if (killer)
{
TMemberStats * pStats = GetMemberStats(killer);
pStats->dwKills++;
SendStats(pStats);
}

if (ch)
{
TMemberStats * pStats = GetMemberStats(ch);
pStats->dwDeaths++;
SendStats(pStats);
}
#endif

char_battle.cpp

search

if (!cannot_dead)
{
PointChange(POINT_HP, -dam, false);
}

add upper

#ifndef DISABLE_WAR_BOARD
if (pAttacker)
{
CWarMap * pWarMap = pAttacker->GetWarMap();

if (pWarMap && pWarMap == GetWarMap())
{
CWarMap::TMemberStats * pStats = pWarMap->GetMemberStats(pAttacker);
pStats->ullDamage += (unsigned long long) dam;
pWarMap->SendStats(pStats);
}
}
#endif

char.cpp

search

void CHARACTER::SetWarMap(CWarMap * pWarMap)
{

change for

void CHARACTER::SetWarMap(CWarMap * pWarMap)
{
#ifndef DISABLE_WAR_BOARD
ChatPacket(CHAT_TYPE_COMMAND, "warboard toggle|0");
#endif

////////////////

clientpart

root -> constinfo.py

add

wndWarBoard = None
CanOpen = 0

root -> game.py

search import interfaceModule

add under

import uiWarBoard

search

self.playerGauge = None

add under

constInfo.wndWarBoard = uiWarBoard.WarBoardWindow()

search

def OnPressEscapeKey(self):

add on this function

if constInfo.wndWarBoard.IsShow():
constInfo.wndWarBoard.Close()
return

search

"ConsoleEnable" : self.__Console_Enable,

add under

"warboard" : self.__WarBoard,
"CanOpenWarBoard" : self.CanOpenWarBoard,
"CantOpenWarBoard" : self.CantOpenWarBoard,

search

def __ProcessPreservedServerCommand(self):

add under function

def __WarBoard(self, input):
constInfo.wndWarBoard.Handle(input)

def CanOpenWarBoard(self):
constInfo.CanOpen = 1

def CantOpenWarBoard(self):
constInfo.CanOpen = 0

def OnKeyDown(self, key):

edit like this:

def OnKeyDown(self, key):
if self.interface.wndWeb and self.interface.wndWeb.IsShow():
return

if key == app.DIK_ESC:
self.RequestDropItem(False)
constInfo.SET_ITEM_QUESTION_DIALOG_STATUS(0)

if key == app.DIK_TAB and constInfo.wndWarBoard: // war board
if not constInfo.wndWarBoard.Open():
self.teleport.Open()
return True

try:
self.onPressKeyDict[key]()
except KeyError:
pass
except:
raise

return True

and uiwarboard.py paste on /root/

uiwarboard.py:

#
# Copyright (c) 2017 by Adams
#
# Niniejszy kod jest chroniony prawem autorskim.
# Wszelkie kopiowanie oraz u¿ytkowanie bez zgody autora
# zabronione pod piecz¹ Kodeksu Karnego - ustaw o prawie autorskim.
#

import ui
import net
import grp
import uiToolTip
import component
import constInfo
import item
import player
import chr
import chat
import localeInfo

BOARD_WIDTH = 465
PLAYER_LIMIT = 10

class GuildWarPlayer(ui.Window):

NEGATIVE_COLOR = grp.GenerateColor(0.9, 0.4745, 0.4627, 1.0)
POSITIVE_COLOR = grp.GenerateColor(0.5411, 0.7254, 0.5568, 1.0)
TITLE_COLOR = grp.GenerateColor(0.9490, 0.9058, 0.7568, 1.0)
SPECIAL_POSITIVE_COLOR = grp.GenerateColor(0.8824, 0.9804, 0.8824, 1.0)

def __init__(self):
ui.Window.__init__(self)

self.name = ""
self.kills = 0
self.deaths = 0
self.balance = 0
self.damage = "0"
self.level = 0

self.__BuildWindow()

def __del(self):
ui.Window.__del__(self)

def __TextLine(self, text, x, color = None, centered = False):
element = self.component.TextLine(self, "", x, 0, None)
element.SetFontName("Tahoma:14")
element.SetText(text)

if centered:
element.SetHorizontalAlignCenter()

if color:
element.SetPackedFontColor(color)

return element

def __BuildWindow(self):
c = component.Component()
self.component = c

self.nameLine = self.__TextLine(self.GetName(), 5)
self.killsLine = self.__TextLine(self.GetKills(), 126, self.POSITIVE_COLOR, True)
self.deathsLine = self.__TextLine(self.GetDeaths(), 185, self.NEGATIVE_COLOR, True)
self.levelLine = self.__TextLine(self.GetLevel(), 239, None, True)
self.damageLine = self.__TextLine(self.GetDamage(), 358, None, True)

self.Show()

def SetName(self, name):
self.name = str(name)

def GetName(self):
return self.name

def SetKills(self, kills):
self.kills = int(kills)
self.CalculateBalance()

def GetKills(self):
return self.kills

def SetDeaths(self, deaths):
self.deaths = int(deaths)
self.CalculateBalance()

def GetDeaths(self):
return self.deaths

def CalculateBalance(self):
self.balance = max(0, int(self.GetKills() - self.GetDeaths()))

def GetBalance(self):
return self.balance

def SetDamage(self, damage):
self.damage = int(damage)

def GetDamage(self):
return self.damage

def SetLevel(self, level):
self.level = int(level)

def GetLevel(self):
return self.level

def Render(self):
name = self.GetName()
self.killsLine.SetText(str(self.GetKills()))
self.deathsLine.SetText(str(self.GetDeaths()))
self.levelLine.SetText(str(self.GetLevel()))

n = self.GetDamage()
self.damageLine.SetText("%s" % ('.'.join([ i-3<0 and str(n)[:i] or str(n)[i-3:i] for i in range(len(str(n))%3, len(str(n))+1, 3) if i ])))

if player.GetName() == name:
self.nameLine.SetText("> %s <" % name)
self.nameLine.SetPackedFontColor(self.SPECIAL_POSITIVE_COLOR)
else:
self.nameLine.SetText(name)
self.nameLine.SetPackedFontColor(self.TITLE_COLOR)

class GuildWarBoard(ui.Window):

GOLD_COLOR = grp.GenerateColor(1.0, 0.7843, 0.0, 1.0)

def __init__(self, parent):
self.players = []
self.guild_id = 0
self.guild_name = "Guild"

ui.Window.__init__(self)
self.SetParent(parent)
self.__BuildWindow()

def __del__(self):
ui.Window.__del__(self)

def SetGuildName(self, name):
self.guild_name = name
self.title.SetText("%s" % name)

def GetGuildName(self):
return self.guild_name

def SetGuildId(self, id):
self.guild_id = int(id)

if self.mark:
self.mark.SetIndex(id)

def GetGuildId(self):
return self.guild_id

def __CreatePlayer(self, name):
for player in self.players:
if player.GetName() == name:
return player

player = GuildWarPlayer()
player.SetParent(self)
player.SetName(name)
player.Show()

self.players.append(player)
return player

def AddPlayer(self, name, kills = 0, deaths = 0, level = 0, damage = 0):
player = self.__CreatePlayer(name)

player.SetKills(kills)
player.SetDeaths(deaths)
player.SetLevel(level)
player.SetDamage(damage)

self.Render()

def ClearPlayers(self):
self.players = []

def GetMVP(self):
players = sorted(self.players, key = lambda player: (player.balance, player.damage), reverse = True)

if len(players) == 0:
return "~"

return players[0].GetName()

def GetTotalKills(self):
x = 0
for player in self.players:
x += player.GetKills()
return x

def Render(self):
players = sorted(self.players, key = lambda player: (player.balance, player.damage), reverse = True)
players = players[

LAYER_LIMIT]

y = 29

for player in players:
player.SetPosition(0, y)
player.Render()
y += 20

self.SetSize(BOARD_WIDTH - 22, y + 5)

def __BuildWindow(self):
c = component.Component()
self.SetPosition(11, 15)

mark = ui.MarkBox()
mark.SetParent(self)
mark.SetPosition(3, 3)
mark.SetIndex(self.guild_id)
mark.SetScale(1)
mark.Show()
self.mark = mark

title = c.TextLine(self, "", 22, 0, None)
title.SetPackedFontColor(self.GOLD_COLOR)
title.SetFontName("Tahoma:14")
title.SetText("")
self.title = title

kills = c.TextLine(self, "", 100, 0, None)
kills.SetFontName("Tahoma:14")
kills.SetText("Kills")
self.kills = kills

deaths = c.TextLine(self, "", 170, 0, None)
deaths.SetFontName("Tahoma:14")
deaths.SetText("Death")
self.deaths = deaths

level = c.TextLine(self, "", 223, 0, None)
level.SetFontName("Tahoma:14")
level.SetText("Level")
self.level = level

damage = c.TextLine(self, "", 310, 0, None)
damage.SetFontName("Tahoma:14")
damage.SetText("Total Damage")
self.damage = damage

separator = ui.Line()
separator.SetParent(self)
separator.SetPosition(0, 25)
separator.SetColor(-1124073473)
separator.SetSize(BOARD_WIDTH - 22, 0)
separator.Show()
self.separator = separator

self.Render()

self.component = c
self.Show()

class WarVersusBox(ui.Window):

GOLD_COLOR = grp.GenerateColor(1.0, 0.7843, 0.0, 1.0)
POSITIVE_COLOR = grp.GenerateColor(0.5411, 0.7254, 0.5568, 1.0)

def __init__(self):
self.boards = []
self.marks = []
self.names = []
self.mvps = []

ui.Window.__init__(self)
self.__BuildWindow()

def __del__(self):
del self.boards
del self.marks
del self.names
del self.mvps

ui.Window.__del__(self)

def __MarkBox(self, x):
mark = ui.MarkBox()
mark.SetParent(self)
mark.SetPosition(x, 0)
mark.SetIndex(0)
mark.SetScale(3)
mark.Show()

self.marks.append(mark)

def __TextLine(self, text, x, color = None, centered = False):
element = self.component.TextLine(self, "", x, 0, None)
element.SetFontName("Tahoma:14")
element.SetText(text)

if centered:
element.SetHorizontalAlignCenter()

if color:
element.SetPackedFontColor(color)

return element

def __BuildWindow(self):
c = component.Component()

self.__MarkBox(16)
self.__MarkBox(237)

self.names.append(c.TextLine(self, "", 68, 1, None))
self.names.append(c.TextLine(self, "", 289, 1, None))

for name in self.names:
name.SetPackedFontColor(self.GOLD_COLOR)
name.SetFontName("Tahoma:14")

self.mvps.append(c.TextLine(self, "", 68, 17, None))
self.mvps.append(c.TextLine(self, "", 289, 17, None))

for mvp in self.mvps:
mvp.SetPackedFontColor(self.POSITIVE_COLOR)
mvp.SetFontName("Tahoma:14")

self.component = c
self.Show()

def Render(self, y):
self.SetPosition(0, y)

for i, board in enumerate(self.boards):
self.marks.SetIndex(board.GetGuildId())
self.marks.SetScale(3)
self.names.SetText("%s (%d kills)" % (board.GetGuildName(), board.GetTotalKills()))
self.mvps.SetText("MVP: %s" % board.GetMVP())

def SetBoards(self, boards):
self.boards = boards

class WarBoardWindow(ui.ThinBoard):

def __init__(self):
ui.ThinBoard.__init__(self)
self.__BuildWindow()

self.toggle = False

def __del__(self):
ui.ThinBoard.__del__(self)

def __BuildWindow(self):
self.boards = []

self.boards.append(GuildWarBoard(self))
self.boards.append(GuildWarBoard(self))

versus = WarVersusBox()
versus.SetParent(self)
versus.SetBoards(self.boards)
self.versus = versus

self.Render()

def Render(self):
y = self.boards[0].GetHeight()
self.boards[1].SetPosition(11, 15 + y + 5)

height = y + self.boards[1].GetHeight() + 20
self.versus.Render(height)

height += 15 * 2 + 15
self.SetSize(BOARD_WIDTH, height)

def AddPlayer(self, guildId, player):
for board in self.boards:
if board.GetGuildId() == guildId:
board.AddPlayer(*player)
return

def Handle(self, input):
input = input.split("|")

if len(input) == 0:
return

if input[0] == "toggle":
self.toggle = bool(input[1])
return

if input[0] == "versus":
self.boards[0].SetGuildId(int(input[1]))
self.boards[0].SetGuildName(input[2])
self.boards[1].SetGuildId(int(input[3]))
self.boards[1].SetGuildName(input[4])
self.versus.SetBoards(self.boards)

for board in self.boards:
board.ClearPlayers()

self.Render()
return

if input[0] == "update":
self.AddPlayer(int(input[1]), input[2:])
self.Render()
return

def IsOnWar(self):
return self.toggle

def Open(self):
if not self.IsOnWar():
return False

self.SetTop()
self.SetCenterPosition()
self.Show()
return True

def Close(self):
if not self.IsShow():
return False

self.Hide()
return True

def OnPressEscapeKey(self):
self.Close()
return True