What's new

-Tibia 7.60 [76] Huczu Yellow Skuls

Volde

Banned
Joined
Feb 26, 2017
Messages
33
Reaction score
0
Yellow Skuls Skrypt


Usuwamy wszystko co dotyczy
TLM_PARTY_SKULLS.
Zacznijmy od komend:
Otwieramy commands.cpp:
Pod:
#ifdef TRS_GM_INVISIBLE
{"/invisible",&Commands::gmInvisible},
#endif //TRS_GM_INVISIBLE

Dodajemy:
#ifdef HUCZU_SKULLS
{"!frags",&Commands::pokazFragi},
{"!rs",&Commands::pokazRs},
#endif //HUCZU_SKULLS

Na ko?cu tego pliku dodajemy:
#ifdef HUCZU_SKULLS
bool Commands::pokazFragi(Creature* c, const std::string &cmd, const std::string &param)
{
Player* player = dynamic_cast<Player*>(c);
if (player)
{
std::eek:stringstream frag;
frag << "You have " << player->skullKills
<< " unjustified kills. You will lose a frag in " << tickstr(player->absolveTicks) << "." << std::ends;
player->sendTextMessage(MSG_BLUE_TEXT, frag.str().c_str());
}
return true;
}

bool Commands::pokazRs(Creature* c, const std::string &cmd, const std::string &param)
{
Player* player = dynamic_cast<Player*>(c);
if (player && player->skullType==SKULL_RED)
{
std::eek:stringstream rs;
rs << "Redskull zniknie za " << tickstr(player->skullTicks) << '.';
player->sendTextMessage(MSG_BLUE_TEXT, rs.str().c_str());
}
else
{
std::eek:stringstream rs;
rs << "Nie masz Red Skull'a.";
player->sendTextMessage(MSG_BLUE_TEXT, rs.str().c_str());
}
return true;
}
#endif //HUCZU_SKULLS

Nast?pnie w pliku commands.h:
Pod:
#ifdef TRS_GM_INVISIBLE
bool gmInvisible(Creature* c, const std::string &cmd, const std::string &param);
#endif //TRS_GM_INVISIBLE

Dodajemy:
#ifdef HUCZU_SKULLS
bool PokazRs(Creature* c, const std::string &cmd, const std::string &param);
bool PokazFragi(Creature* c, const std::string &cmd, const std::string &param);
#endif //HUCZU_SKULLS

Przechodzimy do pliku const76.h:
NAD:
#ifdef TJ_MONSTER_BLOOD
enum bloodcolor_t // for dmg string
{
COLOR_NONE = 255,
COLOR_WHITE_EXP = 215,
COLOR_WHITE = 208,
COLOR_BLUE = 2,
COLOR_RED = 180,
COLOR_GREEN = 50,
};

Dodajemy:
#ifdef HUCZU_SKULLS
enum skull_t {
SKULL_NONE = 0,
SKULL_YELLOW = 1,
SKULL_GREEN = 2,
SKULL_WHITE = 3,
SKULL_RED = 4
};
#endif //HUCZU_SKULLS

Kolejny plik to creature.cpp:
Pod:
#ifdef YUR_RINGS_AMULETS
timeRing = false;
#endif //YUR_RINGS_AMULETS

Dodaj:
#ifdef HUCZU_SKULLS
skullType = SKULL_NONE;
#endif //HUCZU_SKULLS

Nast?pnie w creature.h:
Pod:
virtual int getInflicatedDamage(unsigned long id);

Dodaj:
#ifdef HUCZU_SKULLS
skull_t skullType;
#endif //HUCZU_SKULLS

No to teraz najtrudniejsze plik game.cpp:
Pod:
stopEvent(c->eventCheckAttacking);

Player* player = dynamic_cast<Player*>(c);
if(player){
Dodaj:
#ifdef HUCZU_SKULLS
if(player->party != 0)
LeaveParty(player);
#endif //HUCZU_SKULLS
Pod:
#ifdef YUR_RINGS_AMULETS
damage = applyAmulets(targetPlayer, damage, me->attackType);
#endif //YUR_RINGS_AMULETS
TO:
if (damage > 0) {
if(attackPlayer && attackPlayer->access < g_config.ACCESS_PROTECT) {
if(targetPlayer && targetPlayer != attackPlayer && game->getWorldType() != WORLD_TYPE_NO_PVP)
attackPlayer->pzLocked = true;
}
Zamie? na to:
if (damage > 0) {
if(attackPlayer && attackPlayer->access < g_config.ACCESS_PROTECT) {
if(targetPlayer && targetPlayer != attackPlayer && game->getWorldType() != WORLD_TYPE_NO_PVP){
attackPlayer->pzLocked = true;
#ifdef HUCZU_SKULLS
if(!targetPlayer->hasAttacked(attackPlayer)){
if(game->getWorldType() == WORLD_TYPE_PVP){
bool sendYellowSkull = false;
if(!attackPlayer->hasAttacked(targetPlayer) && (attackPlayer->skullType == SKULL_NONE || (attackPlayer->skullType == SKULL_NONE && attackPlayer->getMaster()))){
//pokaz yellow skulla
sendYellowSkull = true;
}
attackPlayer->addAttacked(targetPlayer);
if(sendYellowSkull){
targetPlayer->onSkull(attackPlayer);
}
}
}
}
#endif //HUCZU_SKULLS
}
Pod:
#ifdef YUR_INVISIBLE
if (targetCreature && !targetPlayer)
{
targetCreature->setInvisible(0);
game->creatureChangeOutfit(targetCreature);
}
#endif //YUR_INVISIBLE
}

Dodaj:
#ifdef HUCZU_SKULLS
if (me->offensive && game->getWorldType() == WORLD_TYPE_PVP)
game->onPvP(attacker, targetCreature, targetCreature->health <= 0);
#endif //HUCZU_SKULLS
NAD:
blood = true;

Dodaj:
#ifdef HUCZU_SKULLS
if (game->getWorldType() == WORLD_TYPE_PVP)
game->onPvP(attacker, attackedCreature, attackedCreature->health <= 0);
#endif //HUCZU_SKULLS

Nad:
if(player->tradePartner != 0) {
playerCloseTrade(player);
}

Dodaj:
#ifdef HUCZU_SKULLS
if(player->party != 0)
LeaveParty(player);
#endif //HUCZU_SKULLS

Znajd?:
#ifdef YUR_CVS_MODS
player->inFightTicks = std::max(g_config.PZ_LOCKED, player->inFightTicks);
#else
player->inFightTicks = (long)g_config.getGlobalNumber("pzlocked", 0);
#endif //YUR_CVS_MODS

player->sendIcons();
I to:
if(attackedPlayer)
player->pzLocked = true;
}
Zamie? na:
if(attackedPlayer){
player->pzLocked = true;
#ifdef HUCZU_SKULLS
if(!attackedPlayer->hasAttacked(player)){
if(getWorldType() == WORLD_TYPE_PVP){
bool sendYellowSkull = false;
if(!player->hasAttacked(attackedPlayer)&& (player->skullType == SKULL_NONE || (player->skullType == SKULL_NONE && player->getMaster()))) {
//pokaz YS
sendYellowSkull = true;
}
player->addAttacked(attackedPlayer);
if(sendYellowSkull){
attackedPlayer->onSkull(player);
}
}
}
}
#endif //HUCZU_SKULLS
}

Pod:
#ifdef YUR_LIGHT_ITEM
player->checkLightItem(thinkTicks);
#endif //YUR_LIGHT_ITEM

Dodaj:
#ifdef HUCZU_SKULLS
if (player->checkSkull(thinkTicks))
Skull(player);
#endif //HUCZU_SKULLS

Pod:
#ifdef YUR_INVISIBLE
if (player->checkInvisible(thinkTicks))
creatureChangeOutfit(player);
#endif //YUR_INVISIBLE
Dodaj:
#ifdef HUCZU_SKULLS
checkSkullTime(player);
#endif //HUCZU_SKULLS

Na ko?cu pliku dodaj:
#ifdef HUCZU_SKULLS
void Game::Skull(Player* player)
{
OTSYS_THREAD_LOCK_CLASS lockClass(gameLock, "Game::Skull()");
if (player)
{
SpectatorVec list;
SpectatorVec::iterator it;
getSpectators(Range(player->pos, true), list);

for(it = list.begin(); it != list.end(); ++it)
{
Player* spectator = dynamic_cast<Player*>(*it);
if(spectator)
if(player->skullType == SKULL_NONE ||
player->skullType == SKULL_WHITE ||
player->skullType == SKULL_RED ||
player->skullType == SKULL_YELLOW && player->isYellowTo(spectator) ||
player->skullType == SKULL_YELLOW && !player->isYellowTo(spectator))
spectator->onSkull(player);
}
}
}

void Game::eek:nPvP(Creature* creature, Creature* attacked, bool murder)
{
OTSYS_THREAD_LOCK_CLASS lockClass(gameLock, "Game::eek:nPvP()");

if (creature && creature->getMaster())
creature = creature->getMaster(); // pk-ing with summons fix

Player* player = dynamic_cast<Player*>(creature);
Player* attackedPlayer = dynamic_cast<Player*>(attacked);

if (player == attackedPlayer)
return;
if(!player || !attackedPlayer)
return;
if (player && player->access >= g_config.ACCESS_PROTECT || attackedPlayer && attackedPlayer->access >= g_config.ACCESS_PROTECT)
return;


player->pzLocked = true;
if (!murder)
{
if(!player->hasAttacked(attackedPlayer)){
player->attackedSet;
}

if(attackedPlayer->skullType == SKULL_NONE || attackedPlayer->skullType == SKULL_YELLOW && attackedPlayer->isYellowTo(player) == 0)
{
if(player->skullType != SKULL_RED && player->skullType != SKULL_WHITE){
player->skullType = SKULL_WHITE;
Skull(player);
}
}
else if(attackedPlayer->skullType == SKULL_WHITE || attackedPlayer->skullType == SKULL_RED)
{
if(player->skullType != SKULL_RED && player->skullType != SKULL_WHITE){
if(!attackedPlayer->hasAttacked(player)){
player->skullType = SKULL_YELLOW;
attackedPlayer->hasAsYellow.push_back(player);
attackedPlayer->onSkull(player);
}
}
}
if(player->inFightTicks < (long)g_config.getGlobalNumber("pzlocked", 0))
player->inFightTicks = (long)g_config.getGlobalNumber("pzlocked", 0);
if(player->skullTicks < (long)g_config.getGlobalNumber("pzlocked", 0))
player->skullTicks = (long)g_config.getGlobalNumber("pzlocked", 0);
}
else // zaatakowany zginal
{
if (attackedPlayer->skullType == SKULL_NONE || attackedPlayer->skullType == SKULL_YELLOW && player->isYellowTo(attackedPlayer) == 0) //Ofiara nie miala skulla oraz miala yellow ale nie na graczu ktora go zabil.
{
player->skullKills++;
std::string justice(std::string("Warning! The murder of ") + attackedPlayer->getName() + " was not justified!");
player->sendTextMessage(MSG_RED_INFO, justice.c_str());
attackedPlayer->clearAttacked();//czyszczenie listy zaatakowanych
attackedPlayer->removeFromYellowList(player);//usuwanie gracza z Yellow skull z listy atakowanych z ys
#ifdef HUCZU_BAN_SYSTEM
if (player->skullKills >= g_config.BAN_UNJUST)
{
banPlayer(player, "Przekroczono limit zabijania graczy", "AccountBan", "2", 0);
}else
#endif //HUCZU_BAN_SYSTEM
if (player->skullKills >= g_config.RED_UNJUST)
{
player->skullType = SKULL_RED;
if(player->skullTicks < g_config.getGlobalNumber("redtime",24*60)*60000)
player->skullTicks = g_config.getGlobalNumber("redtime",24*60)*60000;
if(player->inFightTicks < g_config.getGlobalNumber("whitetime",15)*60000)
player->inFightTicks = g_config.getGlobalNumber("whitetime",15)*60000;
Skull(player);
}
else
{
player->skullType = SKULL_WHITE;
if(player->skullTicks < g_config.getGlobalNumber("whitetime",15)*60000)
player->skullTicks = g_config.getGlobalNumber("whitetime",15)*60000;
if(player->inFightTicks < g_config.getGlobalNumber("whitetime",15)*60000)
player->inFightTicks = g_config.getGlobalNumber("whitetime",15)*60000;
Skull(player);
}
}
else if (attackedPlayer->skullType == SKULL_RED)//victim had red skull..(fair kill)
{
//we aren't removin his skull..are we?
attackedPlayer->removeFromYellowList(player); //usuwanie gracza z Yellow skull z listy atakowanych z ys
attackedPlayer->clearAttacked(); //czyszczenie listy zaatakowanych
attackedPlayer->skullType = SKULL_RED;
if(player->inFightTicks < g_config.getGlobalNumber("whitetime",15)*60000)
player->inFightTicks = g_config.getGlobalNumber("whitetime",15)*60000;//not giving him a skull.. just setting the murder time.
}
else if (attackedPlayer->skullType == SKULL_WHITE) //victim had white skull.. (fair kill)
{
attackedPlayer->skullType = SKULL_NONE;
attackedPlayer->skullTicks = 0;
attackedPlayer->inFightTicks = 0;
attackedPlayer->removeFromYellowList(player); //usuwanie gracza z Yellow skull z listy atakowanych z ys
attackedPlayer->clearAttacked(); //czyszczenie listy zaatakowanych
Skull(attackedPlayer);
if(player->inFightTicks < g_config.getGlobalNumber("whitetime",15)*60000)
player->inFightTicks = g_config.getGlobalNumber("whitetime",15)*60000;//not giving him a skull.. just setting the murder time.
}
else if (attackedPlayer->skullType == SKULL_YELLOW && attackedPlayer->isYellowTo(player))//el que murio era yellow skull para el que lo mato.
{
attackedPlayer->skullType = SKULL_NONE;
attackedPlayer->skullTicks = 0;
attackedPlayer->inFightTicks = 0;
attackedPlayer->removeFromYellowList(player);//usuwanie gracza z Yellow skull z listy atakowanych z ys
attackedPlayer->clearAttacked(); //czyszczenie listy zaatakowanych
Skull(attackedPlayer);
if(player->inFightTicks < g_config.getGlobalNumber("whitetime",15)*60000)
player->inFightTicks = g_config.getGlobalNumber("whitetime",15)*60000;//not giving him a skull.. just setting the murder time.
}
attackedPlayer->clearAttacked();//czyszczenie listy zaatakowanych
attackedPlayer->removeFromYellowList(player);//usuwanie gracza z Yellow skull z listy atakowanych z ys
}
}

void Game::LeaveParty(Player *player)
{
int members = 0;
std::stringstream bericht1;
bericht1 << player->getName() << " has left the party";
if(player->getID() == player->party)
{
disbandParty(player->party);
return;
}
for(AutoList<Player>::listiterator it = Player::listPlayer.list.begin(); it != Player::listPlayer.list.end(); ++it)
{
if((*it).second->party == player->party)
{
members++;
if((*it).second->getID() != player->getID())
(*it).second->sendTextMessage(MSG_INFO, bericht1.str().c_str());
(*it).second->onPartyIcons(player, 0, false, true);
player->onPartyIcons((*it).second, 0, false, true);
}
}
if(members <= 2)
{
disbandParty(player->party);
return;
}
player->sendTextMessage(MSG_INFO, "You have left the party.");
player->party = 0;
}

void Game::disbandParty(unsigned long partyID)
{
for(AutoList<Player>::listiterator cit = Player::listPlayer.list.begin(); cit != Player::listPlayer.list.end(); ++cit)
{
if((*cit).second->party == partyID)
{
(*cit).second->party = 0;
for(AutoList<Player>::listiterator it = Player::listPlayer.list.begin(); it != Player::listPlayer.list.end(); ++it)
{
(*cit).second->onPartyIcons((*it).second, 0, false, true);
if((*it).second->skullType == SKULL_NONE ||
(*it).second->skullType == SKULL_WHITE ||
(*it).second->skullType == SKULL_RED ||
(*it).second->skullType == SKULL_YELLOW &&
(*it).second->isYellowTo((*cit).second))
(*cit).second->onSkull((*it).second);
}
(*cit).second->sendTextMessage(MSG_INFO, "Your party has been disbanded.");
}
}
}
void Game::checkSkullTime(Player* player)
{
if(player->skullType == SKULL_NONE)//just in case
return;

if(player->skullTicks < player->inFightTicks)
player->skullTicks = player->inFightTicks;

if(player->skullType != SKULL_RED && player->skullTicks > player->inFightTicks) //we don't want to do that if the player has a red skull...
player->inFightTicks = player->skullTicks;

}
#endif //HUCZU_SKULLS

Teraz w game.h:
Pod:
#ifdef TRS_GM_INVISIBLE
void creatureBroadcastTileUpdated(const Position& pos);
#endif //TRS_GM_INVISIBLE

Dodaj:
#ifdef HUCZU_SKULLS
void onPvP(Creature* creature, Creature* attacked, bool murder = false);
void Skull(Player* player);
void checkSkullTime(Player* player);
void disbandParty(unsigned long partyID);
void LeaveParty(Player *player);
#endif //HUCZU_SKULLS

Teraz w pliku ioplayerxml.cpp:
Pod:
else if(str=="temple")
{
nodeValue = (char*)xmlGetProp(p, (const xmlChar *) "x");
if(nodeValue) {
player->masterPos.x=atoi(nodeValue);
xmlFreeOTSERV(nodeValue);
}
else
isLoaded = false;

nodeValue = (char*)xmlGetProp(p, (const xmlChar *) "y");
if(nodeValue) {
player->masterPos.y=atoi(nodeValue);
xmlFreeOTSERV(nodeValue);
}
else
isLoaded = false;

nodeValue = (char*)xmlGetProp(p, (const xmlChar *) "z");
if(nodeValue) {
player->masterPos.z=atoi(nodeValue);
xmlFreeOTSERV(nodeValue);
}
else
isLoaded = false;
}
Dodaj:
#ifdef HUCZU_SKULLS
else if(str=="skull")
{
nodeValue = (char*)xmlGetProp(p, (const xmlChar *) "type");
if(nodeValue) {
player->skullType=(skull_t)atoi(nodeValue);
xmlFreeOTSERV(nodeValue);
}
else
isLoaded = false;

nodeValue = (char*)xmlGetProp(p, (const xmlChar *) "kills");
if(nodeValue) {
player->skullKills=atoi(nodeValue);
xmlFreeOTSERV(nodeValue);
}
else
isLoaded = false;

nodeValue = (char*)xmlGetProp(p, (const xmlChar *) "ticks");
if(nodeValue) {
player->skullTicks=atoi(nodeValue);
xmlFreeOTSERV(nodeValue);
}
else
isLoaded = false;

nodeValue = (char*)xmlGetProp(p, (const xmlChar *) "absolve");
if(nodeValue) {
player->absolveTicks=atoi(nodeValue);
xmlFreeOTSERV(nodeValue);
}
else
isLoaded = false;
}
#endif //HUCZU_SKULLS

Pod:
pn = xmlNewNode(NULL,(const xmlChar*)"temple");
sb << player->masterPos.x; xmlSetProp(pn, (const xmlChar*) "x", (const xmlChar*)sb.str().c_str()); sb.str("");
sb << player->masterPos.y; xmlSetProp(pn, (const xmlChar*) "y", (const xmlChar*)sb.str().c_str()); sb.str("");
sb << player->masterPos.z; xmlSetProp(pn, (const xmlChar*) "z", (const xmlChar*)sb.str().c_str()); sb.str("");
xmlAddChild(root, pn);

Dodaj:
#ifdef HUCZU_SKULLS
pn = xmlNewNode(NULL,(const xmlChar*)"skull");
sb << (int)player->skullType; xmlSetProp(pn, (const xmlChar*) "type", (const xmlChar*)sb.str().c_str()); sb.str("");
sb << player->skullKills; xmlSetProp(pn, (const xmlChar*) "kills", (const xmlChar*)sb.str().c_str()); sb.str("");
sb << player->skullTicks; xmlSetProp(pn, (const xmlChar*) "ticks", (const xmlChar*)sb.str().c_str()); sb.str("");
sb << player->absolveTicks; xmlSetProp(pn, (const xmlChar*) "absolve", (const xmlChar*)sb.str().c_str()); sb.str("");
xmlAddChild(root , pn);
#endif //HUCZU_SKULLS

Teraz plik luascript.cpp:
Pod:
#ifdef TLM_HOUSE_SYSTEM
ACCESS_HOUSE = getGlobalNumber("accesshouse",3);
MAX_HOUSE_TILE_ITEMS = getGlobalNumber("maxhousetileitems",10);
#endif //TLM_HOUSE_SYSTEM

Dodaj:
#ifdef HUCZU_SKULLS
HIT_TIME = getGlobalNumber("hittime",1)*60000;
WHITE_TIME = getGlobalNumber("whitetime",15)*60000;
RED_TIME = getGlobalNumber("redtime",5*60)*60000;
FRAG_TIME = getGlobalNumber("fragtime",10*60)*60000;
RED_UNJUST = getGlobalNumber("redunjust",3);
BAN_UNJUST = getGlobalNumber("banunjust",6);
#endif //HUCZU_SKULLS
Nast?pnie w luascript.h:
Pod:
#ifdef TLM_HOUSE_SYSTEM
int ACCESS_HOUSE;
int MAX_HOUSE_TILE_ITEMS;
#endif //TLM_HOUSE_SYSTEM

Dodaj:
#ifdef HUCZU_SKULLS
int HIT_TIME;
int WHITE_TIME;
int RED_TIME;
int FRAG_TIME;
int RED_UNJUST;
int BAN_UNJUST;
#endif //HUCZU_SKULLS
Kolejno w player.cpp:
Pod:
#ifdef TRS_GM_INVISIBLE
gmInvisible = false;
oldlookhead = 0;
oldlookbody = 0;
oldlooklegs = 0;
oldlookfeet = 0;
oldlookmaster = 0;
oldlooktype = PLAYER_MALE_1;
oldlookcorpse = ITEM_HUMAN_CORPSE;
#endif //TRS_GM_INVISIBLE

Dodaj:
#ifdef HUCZU_SKULLS
party = 0;
skullTicks = 0;
skullKills = 0;
absolveTicks = 0;
#endif //HUCZU_SKULLS

Pod:
void Player::dropLoot(Container *corpse)
{
Dodaj:
#ifdef HUCZU_SKULLS
if (skullType == SKULL_RED)
{
for (int slot = 0; slot < 11; slot++)
{
if (items[slot])
{
corpse->addItem(items[slot]);
items[slot] = NULL;
}
}
return;
}
#endif //HUCZU_SKULLS

Pod:
void Player::die()
{

Dodaj:
#ifdef HUCZU_SKULLS
if(skullType != SKULL_RED){
skullType = SKULL_NONE;
skullTicks = 0;
inFightTicks = 0;
}
#endif //HUCZU_SKULLS

Oraz na ko?cu pliku dodaj:
#ifdef HUCZU_SKULLS
bool Player::checkSkull(int thinkTicks)
{
bool skullChanged = false;
if (skullTicks > 0)
{
skullTicks -= thinkTicks;
if (skullTicks <= 0)
{
skullTicks = 0;
skullType = SKULL_NONE;
skullChanged = true;

for(AutoList<Player>::listiterator it = Player::listPlayer.list.begin(); it != Player::listPlayer.list.end(); ++it)
{
if(this->isYellowTo((*it).second)){
(*it).second->removeFromYellowList(this);
}
if((*it).second->hasAttacked(this)){
(*it).second->clearAttacked();
}
}
clearAttacked();
clearYellowList();
}
}
if (skullKills > 0)
{
if (absolveTicks > 0)
{
absolveTicks -= thinkTicks;
if (absolveTicks <= 0)
{
skullKills--;
if (skullKills > 0)
absolveTicks = g_config.FRAG_TIME;
else
absolveTicks = 0;
}
}
else
absolveTicks = g_config.FRAG_TIME;
}
return skullChanged;
}

void Player::eek:nSkull(Player* player)
{
client->sendSkull(player);
}

void Player::eek:nPartyIcons(const Player *playa, int icontype, bool skull, bool removeskull)
{
client->sendPartyIcons(playa, icontype, skull, removeskull);
}

void Player::clearAttacked()
{
attackedSet.clear();
}

void Player::clearYellowList()
{
hasAsYellow.clear();
}

void Player::removeFromYellowList(Player* player)
{
if(!player)
return;
if(!hasAsYellow.empty())
for(std::vector<Player*>::iterator yellowPlayer = hasAsYellow.begin(); yellowPlayer != hasAsYellow.end(); ++yellowPlayer)
{
if((*yellowPlayer) == player)//found!
hasAsYellow.erase(yellowPlayer);//erase him!
break;
}
}

bool Player::hasAttacked(const Player* attacked) const
{
if(access >= 2)
return false;
if(!attacked)
return false;

AttackedSet::const_iterator it;
unsigned long attacked_id = attacked->getID();
it = attackedSet.find(attacked_id);
if(it != attackedSet.end()){
return true;
}
else{
return false;
}
}

void Player::addAttacked(const Player* attacked)
{
if(access >= 2)
return;

if(!attacked || attacked == this)
return;
AttackedSet::iterator it;
unsigned long attacked_id = attacked->getID();
it = attackedSet.find(attacked_id);
if(it == attackedSet.end()){
attackedSet.insert(attacked_id);
}
}

bool Player::isYellowTo(Player* player)
{
if(!player || this == player)
return false;
if(!hasAsYellow.empty())
for(std::vector<Player*>::iterator yellowPlayer = hasAsYellow.begin(); yellowPlayer != hasAsYellow.end(); ++yellowPlayer)
{
if((*yellowPlayer) == player){//found!
return true;
}
}
return false;
}
#endif //HUCZU_SKULLS

W player.h:
Pod:
#ifdef TRS_GM_INVISIBLE
int oldlookhead, oldlookbody, oldlooklegs, oldlookfeet, oldlooktype, oldlookcorpse, oldlookmaster;
bool gmInvisible;
#endif //TRS_GM_INVISIBLE

Dodaj:
#ifdef HUCZU_SKULLS
int skullTicks, skullKills, absolveTicks;
unsigned long party;
void onPartyIcons(const Player *playa, int icontype, bool skull, bool removeskull);
void onSkull(Player* player);
bool checkSkull(int thinkTics);
std::vector<Player*> inviterplayers;
std::vector<Player*> invitedplayers;

typedef std::set<long> AttackedSet;
AttackedSet attackedSet;
std::vector<Player*> hasAsYellow;
bool isYellowTo(Player* player);
void removeFromYellowList(Player* player);
bool hasAttacked(const Player* attacked) const;
void addAttacked(const Player* attacked);
void clearAttacked();
void clearYellowList();
#endif //HUCZU_SKULLS
Nast?pnie w protocol.h:
Pod:
#ifdef BD_HOUSE_WINDOW
virtual void sendHouseWindow(std::string members) = 0;
virtual void parseHouseWindow(NetworkMessage& msg) = 0;
virtual Game* getGame() = 0;
#endif //BD_HOUSE_WINDOW

Dodaj:
#ifdef HUCZU_SKULLS
virtual void sendSkull(const Player *player) = 0;
virtual void sendPartyIcons(const Player *playa, int icontype, bool skull, bool removeskull) = 0;
#endif //HUCZU_SKULLS

Przedostatni plik protocol76.cpp:
Pod:
case 0xA1: // attack
parseAttack(msg);
break;
Dodajemy:
case 0xA3: // invite party
parseInviteParty(msg);
break;

case 0xA5: // revoke party
parseRevokeParty(msg);
break;

case 0xA7: // leave party
game->LeaveParty(player);
break;

case 0xA4: // join party
parseJoinParty(msg);
break;

case 0xA6: // pass leadership
parsePassLeadership(msg);
break;
Na ko?cu tego pliku dodajemy:
#ifdef HUCZU_SKULLS
void Protocol76::sendSkull(const Player *player)
{
NetworkMessage msg;
msg.AddByte(0x90);
msg.AddU32(player->getID());
msg.AddByte(player->skullType);
WriteBuffer(msg);
}

void Protocol76::sendPartyIcons(const Player *playa, int icontype, bool skull, bool removeskull)
{
NetworkMessage msg;
msg.AddByte(0x91);
msg.AddU32(playa->getID());
msg.AddByte(icontype);
WriteBuffer(msg);
msg.Reset();
if(skull || removeskull){
msg.AddByte(0x90);
msg.AddU32(playa->getID());
if(skull){
if(playa->skullType == SKULL_WHITE || playa->skullType == SKULL_RED)
msg.AddByte(playa->skullType);
else
msg.AddByte(2);
}
if(removeskull){
if(playa->skullType == SKULL_WHITE || playa->skullType == SKULL_RED)
msg.AddByte(playa->skullType);
else
msg.AddByte(0);
}
WriteBuffer(msg);
}
}

void Protocol76::parseInviteParty(NetworkMessage &msg)
{
unsigned long creatureid = msg.GetU32();
Creature* creature = game->getCreatureByID(creatureid);
Player* target = dynamic_cast<Player*>(creature);

if (!target)
return;

if (target->party != 0)
{
std::stringstream bericht;
bericht << target->getName() << " is already a member of a party.";
player->sendTextMessage(MSG_INFO, bericht.str().c_str());
return;
}

player->party = player->getID();
target->inviterplayers.push_back(player);
player->invitedplayers.push_back(target);

std::stringstream bericht1;
bericht1 << target->getName() << " has been invited.";
player->sendTextMessage(MSG_INFO, bericht1.str().c_str());

std::stringstream bericht2;
if(player->getSex() == PLAYERSEX_MALE){
bericht2 << player->getName() <<" invites you to his party.";
}else{
bericht2 << player->getName() <<" invites you to her party.";}

target->sendTextMessage(MSG_INFO, bericht2.str().c_str());
target->onPartyIcons(player, 2, false, false);
sendPartyIcons(player, 1, true, false);
sendPartyIcons(player, 4, true, false);
sendPartyIcons(target, 2, false, false);
target->onPartyIcons(player, 1, false, false);
}

void Protocol76::parseRevokeParty(NetworkMessage &msg)
{
int members;
unsigned long creatureid = msg.GetU32();
Creature* creature = game->getCreatureByID(creatureid);
Player* target = dynamic_cast<Player*>(creature);
std::vector<Player*>::iterator invited = std::find(player->invitedplayers.begin(), player->invitedplayers.end(), target);
if(invited != player->invitedplayers.end())
player->invitedplayers.erase(invited);
std::stringstream bericht1;
bericht1 << "Invitation for " << target->getName() << " has been revoked.";
player->sendTextMessage(MSG_INFO, bericht1.str().c_str());
std::stringstream bericht2;
bericht2 << player->getName() << " has revoked his invitation.";
target->sendTextMessage(MSG_INFO, bericht2.str().c_str());
target->onPartyIcons(player, 0, false, false);
sendPartyIcons(target, 0, false, false);
for(AutoList<Player>::listiterator it = Player::listPlayer.list.begin(); it != Player::listPlayer.list.end(); ++it)
{
if((*it).second->party == player->party)
members++;
}
if(members < 2)
game->disbandParty(player->party);
}

void Protocol76::parseJoinParty(NetworkMessage &msg)
{
unsigned long creatureid = msg.GetU32();
Creature* creature = game->getCreatureByID(creatureid);
Player* target = dynamic_cast<Player*>(creature);
player->party = target->party;
std::vector<Player*>::iterator invited = std::find(target->invitedplayers.begin(), target->invitedplayers.end(), player);
if(invited != target->invitedplayers.end())
target->invitedplayers.erase(invited);
player->inviterplayers.clear();
std::stringstream bericht1;
bericht1 << "You have joined "<< target->getName() << "'s party.";
player->sendTextMessage(MSG_INFO, bericht1.str().c_str());
std::stringstream bericht2;
bericht2 << player->getName() << " has joined the party.";
for(AutoList<Player>::listiterator it = Player::listPlayer.list.begin(); it != Player::listPlayer.list.end(); ++it)
{
if((*it).second->party == target->party){
if((*it).second->getID() != player->getID()){
(*it).second->sendTextMessage(MSG_INFO, bericht2.str().c_str());
(*it).second->onPartyIcons(player, 3, true, false);
}
player->onPartyIcons((*it).second, 3, true, false);
}
if((*it).second->getID() == player->party)
{
player->onPartyIcons((*it).second, 4, true, false);
}
}
}

void Protocol76::parsePassLeadership(NetworkMessage &msg)
{
unsigned long creatureid = msg.GetU32();
Creature* creature = game->getCreatureByID(creatureid);
Player* target = dynamic_cast<Player*>(creature);
target->sendTextMessage(MSG_INFO, "You are now leader of your party.");
std::stringstream bericht;
bericht << target->getName() << " is now the leader of your party.";
int oldpartyid = player->getID();
for(AutoList<Player>::listiterator it = Player::listPlayer.list.begin(); it != Player::listPlayer.list.end(); ++it)
{
if((*it).second->party == oldpartyid){
if((*it).second->getID() != target->getID())
(*it).second->sendTextMessage(MSG_INFO, bericht.str().c_str());
(*it).second->onPartyIcons(target, 4, true, false);
(*it).second->onPartyIcons(player, 3, true, false);
(*it).second->party = target->getID();
}
}
}
#endif //HUCZU_SKULLS

Pod:
msg.AddU16(creature->getSpeed());

Dodajemy:
#ifdef HUCZU_SKULLS
Creature *ctarget = game->getCreatureByID(creature->getID());
Player*target=dynamic_cast<Player*>(ctarget);
std::vector<Player*>::iterator invited = std::find(player->invitedplayers.begin(), player->invitedplayers.end(), target);
std::vector<Player*>::iterator inviter = std::find(player->inviterplayers.begin(), player->inviterplayers.end(), target);

if(creature->skullType == SKULL_WHITE || creature->skullType == SKULL_RED)
msg.AddByte(creature->skullType);
else if(target && target->skullType == SKULL_NONE && target->party != 0 && player->party == target->party)
msg.AddByte(2);
else if(target && target->skullType == SKULL_YELLOW && player->isYellowTo(target))
msg.AddByte(1);
else
msg.AddByte(0x00);

if(target && target->party != 0 && player->party != 0 && target->party == player->party)
{
if(target->getID() == player->party)
msg.AddByte(4);
else
msg.AddByte(3);
}
else if(invited != player->invitedplayers.end())
msg.AddByte(2);
else if(inviter != player->inviterplayers.end())
msg.AddByte(1);
else
msg.AddByte(0x00);
#else
msg.AddByte(0x00); // skull
msg.AddByte(0x00); // shield
#endif //HUCZU_SKULLS
Oraz ostatni plik protocol76.h:
Pod:
#ifdef BD_HOUSE_WINDOW
void sendHouseWindow(std::string members);
void parseHouseWindow(NetworkMessage& msg);
Game* getGame() { return game; }
#endif //BD_HOUSE_WINDOW
Dodajemy:
#ifdef HUCZU_SKULLS
virtual void sendSkull(const Player *player);
void sendPartyIcons(const Player *playa, int icontype, bool skull, bool removeskull);
void parseInviteParty(NetworkMessage &msg);
void parseRevokeParty(NetworkMessage &msg);
void parseJoinParty(NetworkMessage &msg);
void parsePassLeadership(NetworkMessage &msg);
#endif //HUCZU_SKULLS

No i teraz w opcjach kompilatora dodajemy:
-DHUCZU_SKULLS

Oraz w config.lua:
-------------------------------- HUCZU SKULLS SYSTEM ----------------------------------

-- Ile fragow trzeba zdobyc by otrzymac Red skulla
redunjust = 4

-- Ile fragow trzeba zdobyc by otrzymac bana
banunjust = 6

-- Pz po zaatakowaniu gracza (1 = 1min)
hittime = 3

-- Pz po zabiciu gracza (1 = 1min)
whitetime = 10

-- Czas red skulla (1 = 1min)
redtime = 6*60

-- Czas fraga (1 = 1min)
fragtime = 60

-- Dlugosc bana za przekroczenie limitu zabijania graczy, jesli masz BAN_SYSTEM (1 = 1 dzien)
pkbandays = 2
 
Top