jachoo
/
minetest-jachoo
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge from celeron, many new features and bugs fixed

master
jachoo 2011-10-30 16:45:00 +01:00
parent 0d367550bc
commit b8c0827434
13 changed files with 622 additions and 162 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/auth.cpp
View File

@ -44,6 +44,8 @@ std::string privsToString(u64 privs)
os<<"ban,";
if(privs & PRIV_CLANS)
os<<"clans,";
if(privs & PRIV_CLANS_ADMIN)
os<<"clans_admin,";
if(os.tellp())
{
// Drop the trailing comma. (Why on earth can't
@ -78,6 +80,8 @@ u64 stringToPrivs(std::string str)
privs |= PRIV_BAN;
else if(s == "clans")
privs |= PRIV_CLANS;
else if(s == "clans_admin")
privs |= PRIV_CLANS_ADMIN;
else
return PRIV_INVALID;
}

3
src/auth.h
View File

@ -39,7 +39,8 @@ const u64 PRIV_SERVER = 16; // Can manage the server (e.g. shutodwn
const u64 PRIV_SHOUT = 32; // Can broadcast chat messages to all
// players
const u64 PRIV_BAN = 64; // Can ban players
const u64 PRIV_CLANS = 128; // Can create clans
const u64 PRIV_CLANS = 128; // Can create clans
const u64 PRIV_CLANS_ADMIN = 256; // Can delete clans
// Default privileges - these can be overriden for new players using the
// config option "default_privs" - however, this value still applies for

105
src/clans.cpp
View File

@ -36,8 +36,7 @@ u16 ClansManager::newClan(const std::string& name, Player* player)
if(clanExists(name)) return 0;
if(m_maxId == 0xFFFF) return 0; //j: szukanie jakiegos wolnego?
u16 id = ++m_maxId;
m_idName[id] = name;
m_nameId[name] = id;
setClan(id,name,false);
if(player){
player->clanOwner = id;
player->clans.insert(id);
@ -49,18 +48,18 @@ void ClansManager::deleteClan(u16 id)
{
if(!clanExists(id))return;
m_deleted.insert(id);
m_nameId.erase( clanNameNoEx(id) );
m_idName.erase(id);
m_names.erase( clanNameNoEx(id) );
m_ids.erase(id);
}
bool ClansManager::clanExists(u16 id) const
{
return m_idName.find(id) != m_idName.end();
return m_ids.find(id) != m_ids.end();
}
bool ClansManager::clanExists(const std::string& name) const
{
return m_nameId.find(name) != m_nameId.end();
return m_names.find(name) != m_names.end();
}
bool ClansManager::clanDeleted(u16 id) const
@ -70,16 +69,16 @@ bool ClansManager::clanDeleted(u16 id) const
u16 ClansManager::clanId(const std::string& name) const
{
std::map<std::string,u16>::const_iterator it = m_nameId.find(name);
if(it==m_nameId.end()) return 0;
return it->second;
std::map<std::string,Clan*>::const_iterator it = m_names.find(name);
if(it==m_names.end()) return 0;
return it->second->id;
}
const std::string& ClansManager::clanName(u16 id) const
{
std::map<u16,std::string>::const_iterator it = m_idName.find(id);
if(it==m_idName.end()) throw BaseException("Clan doesn't exist");
return it->second;
std::map<u16,Clan>::const_iterator it = m_ids.find(id);
if(it==m_ids.end()) throw BaseException("Clan doesn't exist");
return it->second.name;
}
const std::string& ClansManager::clanNameNoEx(u16 id) const
@ -92,33 +91,41 @@ const std::string& ClansManager::clanNameNoEx(u16 id) const
}
}
const std::map<u16,std::string>& ClansManager::getNames() const
const std::map<u16,Clan>& ClansManager::getClans() const
{
return m_idName;
return m_ids;
}
void ClansManager::setClan(u16 id, const std::string& name)
const std::set<u16>& ClansManager::getDeleted() const
{
m_idName[id] = name;
m_nameId[name] = id;
return m_deleted;
}
void ClansManager::save(Settings& args) const
{
args.setS32("clans-maxId",m_maxId);
std::ostringstream os;
for(std::map<u16,std::string>::const_iterator it=m_idName.begin(); it!=m_idName.end(); it++){
os << it->first << ' ' << it->second << ' ';
for(std::map<u16,Clan>::const_iterator it=m_ids.begin(); it!=m_ids.end(); it++){
os << it->first << ' ' << it->second.name << ' ';
}
args.set("clans-names",os.str());
std::ostringstream os2;
for(std::set<u16>::const_iterator it=m_deleted.begin(); it!=m_deleted.end(); it++){
os2 << *it << ' ';
for(std::map<u16,Clan>::const_iterator it=m_ids.begin(); it!=m_ids.end(); it++){
if(!it->second.hasSpawnPoint) continue;
os2 << it->first << ' '
<< it->second.spawnPoint.X << ' '
<< it->second.spawnPoint.Y << ' '
<< it->second.spawnPoint.Z << ' ';
}
args.set("clans-deleted",os2.str());
args.set("clans-spawn",os2.str());
std::ostringstream os3;
for(std::set<u16>::const_iterator it=m_deleted.begin(); it!=m_deleted.end(); it++){
os3 << *it << ' ';
}
args.set("clans-deleted",os3.str());
}
void ClansManager::load(Settings& args)
@ -133,8 +140,22 @@ void ClansManager::load(Settings& args)
std::string name;
is >> id >> name;
if(id == 0 || name.length() == 0) continue;
m_idName[id] = name;
m_nameId[name] = id;
setClan(id,name,false);
}
if(args.exists("clans-spawn")){
s = args.get("clans-spawn");
std::istringstream is3(s);
while(is3.good() && !is3.eof()){
u16 id;
v3f spawn;
is3 >> id >> spawn.X >> spawn.Y >> spawn.Z;
if(id == 0) continue;
Clan* clan = getClan(id);
if(!clan) continue;
clan->hasSpawnPoint = true;
clan->spawnPoint = spawn;
}
}
s = args.get("clans-deleted");
@ -143,15 +164,45 @@ void ClansManager::load(Settings& args)
u16 id;
is2 >> id;
if(id == 0 ) continue;
deleteClan(id);
m_deleted.insert(id);
}
}catch(...){
//TODO: what to do?
m_maxId = 0;
m_idName.clear();
m_nameId.clear();
m_names.clear();
m_ids.clear();
m_deleted.clear();
}
}
Clan* ClansManager::getClan(u16 id)
{
std::map<u16,Clan>::iterator it = m_ids.find(id);
if(it==m_ids.end()) return NULL;
return &it->second;
}
const Clan* ClansManager::getClan(u16 id) const
{
std::map<u16,Clan>::const_iterator it = m_ids.find(id);
if(it==m_ids.end()) return NULL;
return &it->second;
}
void ClansManager::setClan(u16 id, const std::string& name, bool hasSpawnPoint, v3f spawnPoint)
{
Clan& clan = m_ids[id];
clan.name = name;
clan.id = id;
clan.hasSpawnPoint = hasSpawnPoint;
clan.spawnPoint = spawnPoint;
m_names[name] = &clan;
}
void ClansManager::addDeleted(u16 id)
{
m_deleted.insert(id);
}

26
src/clans.h
View File

@ -35,6 +35,18 @@ with this program; if not, write to the Free Software Foundation, Inc.,
class Player;
class Settings;
struct Clan {
u16 id;
std::string name;
v3f spawnPoint;
bool hasSpawnPoint;
Clan():id(0),name("?"),spawnPoint(0,0,0),hasSpawnPoint(false){}
inline void deleteSpawnPoint(){hasSpawnPoint=false;}
inline void setSpawnPoint(const v3f& pos){spawnPoint=pos;hasSpawnPoint=true;}
};
class ClansManager {
public:
@ -51,17 +63,23 @@ public:
u16 clanId(const std::string& name) const;
const std::string& clanName(u16 id) const; //throws if not existing clan
const std::string& clanNameNoEx(u16 id) const;
Clan* getClan(u16 id);
const Clan* getClan(u16 id) const;
const std::map<u16,std::string>& getNames() const;
void setClan(u16 id, const std::string& name);
const std::map<u16,Clan>& getClans() const;
const std::set<u16>& getDeleted() const;
void setClan(u16 id, const std::string& name, bool hasSpawnPoint, v3f spawnPoint = v3f());
void addDeleted(u16 id);
void save(Settings& args) const;
void load(Settings& args);
protected:
std::map<u16,std::string> m_idName;
std::map<std::string,u16> m_nameId;
std::map<u16,Clan> m_ids;
std::map<std::string,Clan*> m_names;
std::set<u16> m_deleted;
u16 m_maxId;

63
src/client.cpp
View File

@ -1544,13 +1544,53 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
std::string name;
for(u8 j=0; j<len; j++)
name += (char)readU8(is);
m_env.clansManager.setClan(id,name);
m_env.clansManager.setClan(id,name,false);
}
dstream<<"Client got TOCLIENT_CLAN_NAMES - count="
<< count
<<std::endl;
}
else if(command == TOCLIENT_CLANS) //j
{
std::string datastring((char*)&data[2], datasize-2);
std::istringstream is(datastring, std::ios_base::binary);
/*
u16 command
u16 count
u16 clan id
u8 clan name lenght (NOTE: if = 0 -> clan is deleted!!!)
string clan name
#v3f1000 clan spawn point (NOTE: if > X 32000 -> spawn point not set!)
...
*/
const u16 count = readU16(is);
for(u16 i=0; i<count; i++){
u16 id = readU16(is);
u8 len = readU8(is);
if(len>0){
std::string name;
for(u8 j=0; j<len; j++)
name += (char)readU8(is);
m_env.clansManager.setClan(id,name,false);
}else{
//clan deleted
m_env.clansManager.deleteClan(id);
m_env.clansManager.addDeleted(id);
}
/*v3f spawn = readV3F1000(is);
if(spawn.X > 32000) m_env.clansManager.getClan(id)->deleteSpawnPoint();
else m_env.clansManager.getClan(id)->setSpawnPoint(spawn);*/
}
dstream<<"Client got TOCLIENT_CLANS - count="
<< count
<<std::endl;
}
else if(command == TOCLIENT_CLAN_DELETED) //j
{
std::string datastring((char*)&data[2], datasize-2);
@ -1576,6 +1616,27 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
<< clan
<<std::endl;
}
else if(command == TOCLIENT_CLAN_SPAWNPOINT) //j
{
std::string datastring((char*)&data[2], datasize-2);
std::istringstream is(datastring, std::ios_base::binary);
/*
u16 command
u16 clan id
v3f1000 clan spawn point X,Y,Z (NOTE: if X > 32000 -> spawn point not set!)
*/
const u16 clan = readU16(is);
if(clan>0 && m_env.clansManager.clanExists(clan)){
v3f spawn = readV3F1000(is);
if(spawn.X > 32000) m_env.clansManager.getClan(clan)->deleteSpawnPoint();
else m_env.clansManager.getClan(clan)->setSpawnPoint(spawn);
}
dstream<<"Client got TOCLIENT_SPAWNPOINT"
<<std::endl;
}
else
{
infostream<<"Client: Ignoring unknown command "

22
src/clientserver.h
View File

@ -214,11 +214,33 @@ enum ToClientCommand
u16 command
u16 clan id
*/
TOCLIENT_CLANS = 0x3B,
/*
u16 command
u16 count
u16 clan id
u8 clan name lenght (NOTE: if = 0 -> clan is deleted!!!)
string clan name
#v3f1000 clan spawn point X,Y,Z (NOTE: if X > 32000 -> spawn point not set!)
...
*/
TOCLIENT_CLAN_SPAWNPOINT = 0x3C,
/*
u16 command
u16 clan id
v3f1000 clan spawn point X,Y,Z (NOTE: if X > 32000 -> spawn point not set!)
*/
#else //def CELERON55_COMPATIBLE
TOCLIENT_DEATHSCREEN = 0x3A,
TOCLIENT_PLAYER_CLAN = 0x37,
TOCLIENT_CLAN_NAMES = 0x38,
TOCLIENT_CLAN_DELETED = 0x39,
TOCLIENT_CLANS = 0x3B,
TOCLIENT_CLAN_SPAWNPOINT = 0x3C,
#endif
};

7
src/content_sao.cpp
View File

@ -1069,6 +1069,13 @@ static void explodeSquare(Map *map, v3s16 p0, v3s16 size)
MapNode n = map->getNodeNoEx(p);
if(n.getContent() == CONTENT_IGNORE)
continue;
//j
//disallow mobs to destroy clans' terrain
MapBlock* block = map->getBlockNoCreateNoEx( getNodeBlockPos(p) );
if(!block || block->getOwner() != 0)
continue;
//map->removeNodeWithEvent(p);
map->removeNodeAndUpdate(p, modified_blocks);
}

6
src/game.cpp
View File

@ -1759,6 +1759,9 @@ void the_game(
u16 block_owner = block ? block->getOwner() : 0;
u16 block2_owner = block2 ? block2->getOwner() : 0;
bool canModifyNeighbour = player->canModify(&client.getEnv()->clansManager,NULL,block2,NULL,NULL);
bool canModify = canModifyNeighbour && player->canModify(&client.getEnv()->clansManager,NULL,block,NULL,NULL);
if(block_owner || block2_owner )
ownershiptext = L"Property of clan ";
@ -1770,9 +1773,6 @@ void the_game(
ownershiptext += narrow_to_wide(clansManager->clanNameNoEx(block2_owner));
}
bool canModifyNeighbour = player->canModify(&client.getEnv()->clansManager,NULL,block2,NULL,NULL);
bool canModify = canModifyNeighbour && player->canModify(&client.getEnv()->clansManager,NULL,block,NULL,NULL);
if(!canModify) ownershiptext += narrow_to_wide(std::string(" [X] "));
//jTODO: remove it

104
src/player.cpp
View File

@ -26,6 +26,8 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include <ITextSceneNode.h>
#endif
#include "settings.h"
#include "content_mapnode.h"
#include "content_nodemeta.h"
#include <sstream>
@ -118,12 +120,20 @@ void Player::serialize(std::ostream &os)
args.setV3F("position", m_position);
args.setBool("craftresult_is_preview", craftresult_is_preview);
args.setS32("hp", hp);
//j
//j CLANS
args.setS32("clanOwner",clanOwner);
std::ostringstream clansStrStream;
for(std::set<int>::const_iterator it=clans.begin(); it!=clans.end(); it++)
for(std::set<u16>::const_iterator it=clans.begin(); it!=clans.end(); it++)
clansStrStream << *it << ' ';
args.set("clans",clansStrStream.str());
args.setS32("clanOwner",clanOwner);
std::ostringstream clansModeratorStrStream;
for(std::set<u16>::const_iterator it=clansModerator.begin(); it!=clansModerator.end(); it++)
clansModeratorStrStream << *it << ' ';
args.set("clansModerator",clansModeratorStrStream.str());
args.writeLines(os);
@ -190,6 +200,8 @@ void Player::deSerialize(std::istream &is)
}*/
//j
try{
clanOwner = args.getU16("clanOwner");
std::string clansStr = args.get("clans");
std::istringstream clansStrStream(clansStr);
while(clansStrStream.good() && !clansStrStream.eof()){
@ -199,7 +211,18 @@ void Player::deSerialize(std::istream &is)
int i = atoi(s.c_str());
if(i>=0 && i<=0xFFFF) clans.insert(i);
}
clanOwner = args.getU16("clanOwner");
if(args.exists("clansModerator")){
std::string clansModeratorStr = args.get("clansModerator");
std::istringstream clansModeratorStrStream(clansModeratorStr);
while(clansModeratorStrStream.good() && !clansModeratorStrStream.eof()){
std::string s;
clansModeratorStrStream >> s;
if(s.length() == 0) continue;
int i = atoi(s.c_str());
if(i>=0 && i<=0xFFFF) clansModerator.insert(i);
}
}
}catch(SettingNotFoundException& e){}
inventory.deSerialize(is);
@ -208,7 +231,7 @@ void Player::deSerialize(std::istream &is)
//j
inline bool canModifyNoCheck(const Player* player, const MapBlock* block) {
u16 owner = block->getOwner();
return owner == 0 || player->clans.find(owner) != player->clans.end();
return owner == 0 || player->isClanMember(owner);
}
inline bool canModifyCheck(const Player* player, const MapBlock* block) {
@ -233,6 +256,49 @@ bool Player::canModify(const ClansManager* clansManager, Map* map, MapBlock* blo
return false;
}
std::pair<bool,v3f> Player::findSpawnPos(const ClansManager& clansManager)
{
if(clans.size() == 0) return std::make_pair(false,v3f());
/*std::vector<v3f> positions;
for(std::set<u16>::const_iterator it=clans.begin(); it!=clans.end(); it++){
const Clan* clan = clansManager.getClan(*it);
if(clan && clan->hasSpawnPoint) positions.push_back(clan->spawnPoint);
}
if(positions.size()==0)return std::make_pair(false,v3f());
int i = rand() % positions.size();
return std::make_pair(true,positions[i]);*/
v3f p;
f32 p_dist = 99999999;
v3f playerPos = getPosition();
for(std::set<u16>::const_iterator it=clans.begin(); it!=clans.end(); it++){
const Clan* clan = clansManager.getClan(*it);
if(clan && clan->hasSpawnPoint){
f32 d = playerPos.getDistanceFrom(clan->spawnPoint);
if(d < p_dist){
p_dist = d;
p = clan->spawnPoint;
}
}
}
if(p_dist==99999999)return std::make_pair(false,v3f());
return std::make_pair(true,p);
}
void Player::actualizeClans(const ClansManager& clansManager)
{
if(!clansManager.clanExists(clanOwner))clanOwner = 0;
std::set<u16> del;
for(std::set<u16>::const_iterator it=clans.begin(); it!=clans.end(); it++)
if(!clansManager.clanExists(*it))del.insert(*it);
for(std::set<u16>::const_iterator it=del.begin(); it!=del.end(); it++)
clans.erase(*it);
del.clear();
for(std::set<u16>::const_iterator it=clansModerator.begin(); it!=clansModerator.end(); it++)
if(!clansManager.clanExists(*it))del.insert(*it);
for(std::set<u16>::const_iterator it=del.begin(); it!=del.end(); it++)
clansModerator.erase(*it);
}
/*
RemotePlayer
*/
@ -564,7 +630,7 @@ void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d,
is_unloaded = true;
// Doing nothing here will block the player from
// walking over map borders
}
}
core::aabbox3d<f32> nodebox = getNodeBox(v3s16(x,y,z), BS);
@ -777,6 +843,32 @@ void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d,
collision_info->push_back(info);
}
}
/*
Check if standing on a teleport
TODO: should it be at the beginning or at the end of this func?
*/
v3s16 standPos = floatToInt(position - v3f(0,BS/2,0), BS);
MapNode standNode = map.getNodeNoEx(standPos);
if(standNode.getContent() == CONTENT_TELEPORT){
SignNodeMetadata* meta = (SignNodeMetadata*)map.getNodeMetadata(standPos);
if(meta){
v3f t;
std::string text = meta->getText();
str_replace_char(text,',',' ');
std::istringstream is(text);
is >> t.X >> t.Y >> t.Z;
//TODO: map limits!
if( t.X > 32000 || t.X < -32000 ||
t.Y > 32000 || t.Y < -32000 ||
t.Z > 32000 || t.Z < -32000 ||
(t.X == 0 && t.Y == 0 && t.Z == 0)
) return;
setPosition(t*BS);
}
}
}
void LocalPlayer::move(f32 dtime, Map &map, f32 pos_max_d)

17
src/player.h
View File

@ -168,9 +168,24 @@ public:
u16 peer_id;
//j
std::set<int> clans;
std::set<u16> clans;
std::set<u16> clansModerator;
u16 clanOwner;
bool canModify(const ClansManager* clansManager, Map* map, MapBlock* block, MapNode* node, v3s16* nodepos) const;
inline bool isClanMember(u16 clan) const {
if(clan==0)return false; //do we need this?
return clans.find(clan) != clans.end();
}
inline bool isClanModerator(u16 clan) const {
if(clan==0)return false; //do we need this?
return clan==clanOwner || clansModerator.find(clan) != clansModerator.end();
}
inline bool isClanOwner(u16 clan) const {
if(clan==0)return false; //do we need this?
return clan == clanOwner;
}
std::pair<bool,v3f> findSpawnPos(const ClansManager& clansManager);
void actualizeClans(const ClansManager& clansManager);
protected:
char m_name[PLAYERNAME_SIZE];

109
src/server.cpp
View File

@ -2068,8 +2068,9 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id)
// Send HP & clans
SendPlayerHP(player);
player->actualizeClans(m_env.clansManager);
SendPlayerClan(player,false,0);
SendClanNames(player->peer_id,m_env.clansManager.getNames());
SendClans(player->peer_id,m_env.clansManager.getClans(),m_env.clansManager.getDeleted());
// Send time of day
{
@ -3007,7 +3008,7 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id)
}
//player must be in this clan or clan is null
if(clan && player->clans.find(clan) == player->clans.end())
if(clan && !player->isClanMember(clan))
return;
block->setOwner(clan);
@ -3882,10 +3883,11 @@ void Server::SendPlayerClan(Player *player, bool kick = false, u16 clan = 0)
//send all clans
u16 count = (u16)player->clans.size();
writeU16(os,count);
for(std::set<int>::const_iterator it=player->clans.begin(); it!=player->clans.end(); it++){
for(std::set<u16>::const_iterator it=player->clans.begin(); it!=player->clans.end(); it++){
writeU8(os,false);
writeU16(os,*it);
}
//TODO: send admin/moderator/member info // hmm... do we need that?
}
// Make data buffer
@ -3903,11 +3905,11 @@ void writeClanIdName(std::ostringstream& os, u16 id, const std::string& name){
u8 clan name lenght
string clan name
*/
if(name.length() > 0xFFFF) throw BaseException("too long clan name");
if(name.length() > 0xFF) throw BaseException("too long clan name");
writeU16(os,id);
u16 len = (u16)name.length();
u8 len = (u8)name.length();
writeU8(os,len);
//for(int i=0; i<len; i++) writeU8(name[i]);
@ -3948,7 +3950,36 @@ void Server::SendClanName(u16 peer_id, u16 clan, const std::string& name)
}
//j
void Server::SendClanNames(u16 peer_id, const std::map<u16,std::string>& clans)
//if clan = NULL -> clan is deleted
void writeClan(std::ostringstream& os, u16 id, const Clan* clan){
/*
u16 clan id
u8 clan name lenght (NOTE: if = 0 -> clan is deleted!!!)
string clan name
#v3f1000 clan spawn point (NOTE: if > X 32000 -> spawn point not set!)
*/
if(clan==NULL){
writeU16(os,id);
writeU8(os,0);
//writeV3F1000(os,v3f(32500));
}else{
if(clan->name.length() > 0xFF) throw BaseException("too long clan name");
writeU16(os,id);
u8 len = (u8)clan->name.length();
writeU8(os,len);
os << clan->name;
/*if(clan->hasSpawnPoint) writeV3F1000(os,clan->spawnPoint);
else writeV3F1000(os,v3f(32500));*/
}
}
//j
void Server::SendClans(u16 peer_id, const std::map<u16,Clan>& clans, const std::set<u16>& deleted)
{
DSTACK(__FUNCTION_NAME);
/*
@ -3956,22 +3987,27 @@ void Server::SendClanNames(u16 peer_id, const std::map<u16,std::string>& clans)
u16 count
u16 clan id
u8 clan name lenght
u8 clan name lenght (NOTE: if = 0 -> clan is deleted!!!)
string clan name
#v3f1000 clan spawn point (NOTE: if > X 32000 -> spawn point not set!)
...
*/
u16 count = (u16)clans.size();
u16 count = (u16)clans.size() + (u16)deleted.size();
if(count==0) return;
std::ostringstream os(std::ios_base::binary);
writeU16(os, TOCLIENT_CLAN_NAMES);
writeU16(os, TOCLIENT_CLANS);
writeU16(os,count);
for(std::map<u16,std::string>::const_iterator it=clans.begin(); it!=clans.end(); it++)
writeClanIdName(os,it->first,it->second);
for(std::map<u16,Clan>::const_iterator it=clans.begin(); it!=clans.end(); it++)
writeClan(os,it->first,&it->second);
dstream<<"Server sending TOCLIENT_CLAN_NAMES - "
for(std::set<u16>::const_iterator it=deleted.begin(); it!=deleted.end(); it++)
writeClan(os,*it,NULL);
dstream<<"Server sending TOCLIENT_CLANS - "
<< "count=" << count
<<std::endl;
@ -3983,7 +4019,7 @@ void Server::SendClanNames(u16 peer_id, const std::map<u16,std::string>& clans)
}
//j
void Server::BroadcastPlayerClan(u16 clan, const std::string& name)
void Server::BroadcastClanName(u16 clan, const std::string& name)
{
for(core::map<u16, RemoteClient*>::Iterator
i = m_clients.getIterator();
@ -4039,6 +4075,48 @@ void Server::BroadcastClanDeleted(u16 clan)
}
}
//j
//void Server::SendClanSpawn(u16 peer_id, u16 clan, v3f spawn)
//{
// DSTACK(__FUNCTION_NAME);
// std::ostringstream os(std::ios_base::binary);
// /*
// u16 command
// u16 clan id
// v3f1000 clan spawn point X,Y,Z (NOTE: if X > 32000 -> spawn point not set!)
// */
// writeU16(os, TOCLIENT_CLAN_SPAWNPOINT);
// writeU16(os, clan);
// writeV3F1000(os, spawn);
//
// dstream<<"Server sending TOCLIENT_CLAN_DELETED - "
// << "id=" << clan
// <<std::endl;
//
// // Make data buffer
// std::string s = os.str();
// SharedBuffer<u8> data((u8*)s.c_str(), s.size());
// // Send as reliable
// m_con.Send(peer_id, 0, data, true);
//}
//
////j
//void Server::BroadcastClanSpawn(u16 clan, v3f spawn)
//{
// for(core::map<u16, RemoteClient*>::Iterator
// i = m_clients.getIterator();
// i.atEnd() == false; i++)
// {
// // Get client and check that it is valid
// RemoteClient *client = i.getNode()->getValue();
// assert(client->peer_id == i.getNode()->getKey());
// if(client->serialization_version == SER_FMT_VER_INVALID)
// continue;
//
// SendClanSpawn(client->peer_id,clan,spawn);
// }
//}
void Server::sendRemoveNode(v3s16 p, u16 ignore_id,
core::list<u16> *far_players, float far_d_nodes)
{
@ -4310,8 +4388,9 @@ void Server::HandlePlayerHP(Player *player, s16 damage)
void Server::RespawnPlayer(Player *player)
{
v3f pos = findSpawnPos(m_env.getServerMap());
player->setPosition(pos);
std::pair<bool,v3f> pos = player->findSpawnPos(m_env.clansManager);
if(!pos.first) pos.second = findSpawnPos(m_env.getServerMap());
player->setPosition(pos.second);
player->hp = 20;
SendMovePlayer(player);
SendPlayerHP(player);

6
src/server.h
View File

@ -428,10 +428,12 @@ public:
void BroadcastChatMessage(const std::wstring &message); //j - moved from private
void SendPlayerClan(Player *player, bool kick, u16 clan); //j; if clan=0, all clans are sent
void SendClanName(u16 peer_id, u16 clan, const std::string& name); //j
void SendClanNames(u16 peer_id, const std::map<u16,std::string>& clans); //j
void BroadcastPlayerClan(u16 clan, const std::string& name); //j
void SendClans(u16 peer_id, const std::map<u16,Clan>& clans, const std::set<u16>& deleted); //j
void BroadcastClanName(u16 clan, const std::string& name); //j
void SendClanDeleted(u16 peer_id,u16 clan); //j
void BroadcastClanDeleted(u16 clan); //j
//void SendClanSpawn(u16 peer_id,u16 clan, v3f spawn); //j
//void BroadcastClanSpawn(u16 clan, v3f spawn); //j
u64 getPlayerAuthPrivs(const std::string &name)
{

312
src/servercommand.cpp
View File

@ -310,106 +310,98 @@ void cmd_clearobjects(std::wostringstream &os,
void cmd_clanNew(std::wostringstream &os,
ServerCommandContext *ctx)
{
if((ctx->privs & PRIV_CLANS) == 0)
{
os<<L"-!- You don't have permission to do that";
return;
try{
if((ctx->privs & PRIV_CLANS) == 0)
throw BaseException("You don't have permission to do that");
if(ctx->parms.size() != 2)
throw BaseException("Missing parameter(s) - should be /clan-new clan");
if(ctx->player->clanOwner)
throw BaseException("You can define only one clan!");
//TODO: show actual player's owned clan (so he can delete it and create new)
std::string clanName = wide_to_narrow(ctx->parms[1]);
u16 clanId = ctx->env->clansManager.newClan(clanName,ctx->player);
if(clanId>0){
ctx->server->BroadcastClanName(clanId,clanName);
ctx->server->SendPlayerClan(ctx->player,false,clanId);
os<< L"-!- Clan '"<<ctx->parms[1]<<"' added.";
}
else throw BaseException("Clan already exists or other error");
}catch(BaseException& ex){
std::wstring msg = narrow_to_wide(std::string(ex.what()));
os << L"-!- Error - clan NOT added (" << msg << L")";
}
if(ctx->parms.size() != 2)
{
os<<L"-!- Bad parameter(s)";
return;
}
if(ctx->player->clanOwner){
os<< L"-!- Error - you can define only one clan!";
return;
}
std::string clanName = wide_to_narrow(ctx->parms[1]);
u16 clanId = ctx->env->clansManager.newClan(clanName,ctx->player);
if(clanId>0){
ctx->server->BroadcastPlayerClan(clanId,clanName);
ctx->server->SendPlayerClan(ctx->player,false,clanId);
os<< L"-!- Clan '"<<ctx->parms[1]<<"' added.";
}
else os<< L"-!- Error - clan '"<<ctx->parms[1]<<"' NOT added.";
}
//j
void cmd_clanDelete(std::wostringstream &os,
ServerCommandContext *ctx)
{
if((ctx->privs & PRIV_CLANS) == 0)
{
os<<L"-!- You don't have permission to do that";
return;
try{
if((ctx->privs & PRIV_CLANS) == 0)
throw BaseException("You don't have permission to do that");
if(ctx->parms.size() != 2)
throw BaseException("Missing parameter(s) - should be /clan-delete clan");
std::string clanName = wide_to_narrow(ctx->parms[1]);
u16 clanId = ctx->env->clansManager.clanId(clanName);
if(!clanId)
throw BaseException("Bad clan name or clan deleted");
if( (ctx->privs & PRIV_CLANS_ADMIN) == 0 && clanId != ctx->player->clanOwner)
throw BaseException("Only clan's owner may delete it!");
ctx->env->clansManager.deleteClan(clanId);
if(ctx->player->clanOwner == clanId) ctx->player->clanOwner = 0;
else; //TODO: find clan's real owner and inform reset his clanOwner variable
ctx->server->BroadcastClanDeleted(clanId);
os<< L"-!- Clan '"<<ctx->parms[1]<<"' deleted.";
}catch(BaseException& ex){
std::wstring msg = narrow_to_wide(std::string(ex.what()));
os << L"-!- Error - clan not deleted (" << msg << L")";
}
if(ctx->parms.size() != 2)
{
os<<L"-!- Bad parameter(s)";
return;
}
std::string clanName = wide_to_narrow(ctx->parms[1]);
u16 clanId = ctx->env->clansManager.clanId(clanName);
if(!clanId || clanId != ctx->player->clanOwner){
os<< L"-!- Error - only clan's admin may delete it!";
return;
}
ctx->env->clansManager.deleteClan(clanId);
ctx->player->clanOwner = 0; //only clan owner can exec this func
ctx->server->BroadcastClanDeleted(clanId);
os<< L"-!- Clan '"<<ctx->parms[1]<<"' deleted.";
}
void cmd_clanJoin(std::wostringstream &os,
ServerCommandContext *ctx)
{
if((ctx->privs & PRIV_CLANS) == 0)
{
os<<L"-!- You don't have permission to do that";
return;
}
if(ctx->parms.size() != 3)
{
os<<L"-!- Missing parameter(s)";
return;
}
try{
/*int clan_i = stoi(ctx->parms[1]);
if( clan_i < 0 || clan_i > 0xFFFF ) throw 0;
u16 clan = (u16)clan_i;*/
if((ctx->privs & PRIV_CLANS) == 0) throw BaseException("You don't have permission to do that");
if(ctx->parms.size() != 3) throw BaseException("Missing parameter(s) - should be /clan-join clan player");
std::string clanName = wide_to_narrow(ctx->parms[1]);
u16 clan = ctx->env->clansManager.clanId(clanName);
if(!clan) throw 0;
if(!clan) throw BaseException("Bad clan name or clan deleted");
std::string playerName = wide_to_narrow(ctx->parms[2]);
if(playerName.length()==0) throw 0;
if(playerName.length()==0) throw BaseException("Bad player name");
if(ctx->player->clans.find(clan) == ctx->player->clans.end()) throw 0; //j!
if(!ctx->player->isClanModerator(clan)) throw BaseException("Only clan moderator can do this");
Player* player = ctx->env->getPlayer(playerName.c_str());
if(!player) throw 0;
if(!player) throw BaseException("Bad player name or player disconnected");
player->clans.insert(clan);
ctx->server->SendPlayerClan(player,false,clan);
os<< L"-!- clan-join - success";
ctx->server->BroadcastChatMessage(L"-!- Player " + ctx->parms[2] + L" joined clan " + ctx->parms[1]);
}catch(...){
os<< L"-!- Error - player not added to clan.";
}catch(BaseException& ex){
std::wstring msg = narrow_to_wide(std::string(ex.what()));
os << L"-!- Error - player not added to clan (" << msg << L")";
}
}
@ -417,47 +409,163 @@ void cmd_clanJoin(std::wostringstream &os,
void cmd_clanKick(std::wostringstream &os,
ServerCommandContext *ctx)
{
if((ctx->privs & PRIV_CLANS) == 0)
{
os<<L"-!- You don't have permission to do that";
return;
}
if(ctx->parms.size() != 3)
{
os<<L"-!- Missing parameter(s)";
return;
}
try{
/*int clan_i = stoi(ctx->parms[1]);
if( clan_i < 0 || clan_i > 0xFFFF ) throw 0;
u16 clan = (u16)clan_i;*/
if((ctx->privs & PRIV_CLANS) == 0) throw BaseException("You don't have permission to do that");
if(ctx->parms.size() != 3) throw BaseException("Missing parameter(s) - should be /clan-kick clan player");
std::string clanName = wide_to_narrow(ctx->parms[1]);
u16 clan = ctx->env->clansManager.clanId(clanName);
if(!clan) throw 0; //clan must exist
if(!clan) throw BaseException("Bad clan name or clan deleted"); //clan must exist
if(ctx->player->clans.find(clan) == ctx->player->clans.end()) throw 0; //sender must be in this clan
if(!ctx->player->isClanModerator(clan)) throw BaseException("Only clan moderator can do this"); //sender must be moderator of this clan
std::string playerName = wide_to_narrow(ctx->parms[2]);
if(playerName.length()==0) throw 0;
if(playerName.length()==0) throw BaseException("Bad player name");
Player* player = ctx->env->getPlayer(playerName.c_str());
if(!player) throw 0; //player must exist
if(!player) throw BaseException("Bad player name or player disconnected"); //player must exist
if(player->clanOwner == clan) throw 0; //player can't be owner of that clan
if(player->clanOwner == clan) throw BaseException("Clan's owner cannot be kicked out"); //player can't be owner of that clan
player->clans.erase(clan);
player->clansModerator.erase(clan);
ctx->server->SendPlayerClan(player,true,clan);
os<< L"-!- clan-kick - success";
ctx->server->BroadcastChatMessage(L"-!- Player " + ctx->parms[2] + L" kicked from clan " + ctx->parms[1]);
}catch(...){
os<< L"-!- Error - player not kicked from clan.";
}catch(BaseException& ex){
std::wstring msg = narrow_to_wide(std::string(ex.what()));
os << L"-!- Error - player not kicked from clan. (" << msg << L")";
}
}
void cmd_clanPromote(std::wostringstream &os,
ServerCommandContext *ctx)
{
try{
if((ctx->privs & PRIV_CLANS) == 0) throw BaseException("You don't have permission to do that");
if(ctx->parms.size() != 3) throw BaseException("Missing parameter(s) - should be /clan-promote clan player");
std::string clanName = wide_to_narrow(ctx->parms[1]);
u16 clan = ctx->env->clansManager.clanId(clanName);
if(!clan) throw BaseException("Bad clan name or clan deleted"); //clan must exist
if(!ctx->player->isClanOwner(clan)) throw BaseException("Only clan owner can do this"); //must be admin
std::string playerName = wide_to_narrow(ctx->parms[2]);
if(playerName.length()==0) throw BaseException("Bad player name");
Player* player = ctx->env->getPlayer(playerName.c_str());
if(!player) throw BaseException("Bad player name or player disconnected"); //player must exist
if(!player->isClanMember(clan)){
player->clans.insert(clan);
ctx->server->SendPlayerClan(player,false,clan);
}
player->clansModerator.insert(clan);
os<< L"-!- clan-promote - success";
ctx->server->BroadcastChatMessage(L"-!- Player " + ctx->parms[2] + L" was promoted in clan " + ctx->parms[1]);
}catch(BaseException& ex){
std::wstring msg = narrow_to_wide(std::string(ex.what()));
os << L"-!- Error - can't promote player. (" << msg << L")";
}
}
void cmd_clanDegrade(std::wostringstream &os,
ServerCommandContext *ctx)
{
try{
if((ctx->privs & PRIV_CLANS) == 0) throw BaseException("You don't have permission to do that");
if(ctx->parms.size() != 3) throw BaseException("Missing parameter(s) - should be /clan-degrade clan player");
std::string clanName = wide_to_narrow(ctx->parms[1]);
u16 clan = ctx->env->clansManager.clanId(clanName);
if(!clan) throw BaseException("Bad clan name or clan deleted"); //clan must exist
if(!ctx->player->isClanOwner(clan)) throw BaseException("Only clan owner can do this"); //must be admin
std::string playerName = wide_to_narrow(ctx->parms[2]);
if(playerName.length()==0) throw BaseException("Bad player name");
Player* player = ctx->env->getPlayer(playerName.c_str());
if(!player) throw BaseException("Bad player name or player disconnected"); //player must exist
if(!player->isClanModerator(clan)) throw BaseException("Player is not a moderator");
player->clansModerator.erase(clan);
os<< L"-!- clan-degrade - success";
ctx->server->BroadcastChatMessage(L"-!- Player " + ctx->parms[2] + L" was degraded in clan " + ctx->parms[1]);
}catch(BaseException& ex){
std::wstring msg = narrow_to_wide(std::string(ex.what()));
os << L"-!- Error - can't degrade player. (" << msg << L")";
}
}
void cmd_clanSpawn(std::wostringstream &os,
ServerCommandContext *ctx)
{
try{
if((ctx->privs & PRIV_CLANS) == 0) throw BaseException("You don't have permission to do that");
if(ctx->parms.size() != 2) throw BaseException("Missing parameter(s) - should be /clan-spawn clan");
std::string clanName = wide_to_narrow(ctx->parms[1]);
u16 clan = ctx->env->clansManager.clanId(clanName);
if(!clan) throw BaseException("Bad clan name or clan deleted"); //clan must exist
if(!ctx->player->isClanModerator(clan)) throw BaseException("Only clan moderator can do this"); //must be admin
v3f pos = ctx->player->getPosition();
ctx->env->clansManager.getClan(clan)->setSpawnPoint(pos);
//ctx->server->BroadcastClanSpawn(clan,pos);
os << L"-!- clan-spawn - success";
}catch(BaseException& ex){
std::wstring msg = narrow_to_wide(std::string(ex.what()));
os << L"-!- Error - can't change clan's spawn point. (" << msg << L")";
}
}
void cmd_clanInfo(std::wostringstream &os,
ServerCommandContext *ctx)
{
try{
if((ctx->privs & PRIV_CLANS) == 0) throw BaseException("You don't have permission to do that");
const ClansManager& cm = ctx->env->clansManager;
const Player& p = *ctx->player;
if(p.clans.size()>0){
os << L"-!- Your clans: ";
for(std::set<u16>::const_iterator it=p.clans.begin(); it!=p.clans.end(); it++){
if(!cm.clanExists(*it))continue;
if(it!=p.clans.begin()) os << L", ";
os << narrow_to_wide(cm.clanNameNoEx(*it));
if(p.isClanOwner(*it)) os << L" (owner)";
else if(p.isClanModerator(*it)) os << L" (moderator)";
}
}else os << L"You don't belong to any clan.";
}catch(BaseException& ex){
std::wstring msg = narrow_to_wide(std::string(ex.what()));
os << L"-!- Error - can't get clans info. (" << msg << L")";
}
}
std::wstring processServerCommand(ServerCommandContext *ctx)
{
@ -503,21 +611,21 @@ std::wstring processServerCommand(ServerCommandContext *ctx)
else if(ctx->parms[0] == L"clearobjects")
cmd_clearobjects(os, ctx);
else if(ctx->parms[0] == L"clan-new")
{
cmd_clanNew(os, ctx);
}
else if(ctx->parms[0] == L"clan-delete")
{
cmd_clanDelete(os, ctx);
}
else if(ctx->parms[0] == L"clan-join")
{
cmd_clanJoin(os, ctx);
}
else if(ctx->parms[0] == L"clan-kick")
{
cmd_clanKick(os, ctx);
}
else if(ctx->parms[0] == L"clan-promote")
cmd_clanPromote(os, ctx);
else if(ctx->parms[0] == L"clan-degrade")
cmd_clanDegrade(os, ctx);
else if(ctx->parms[0] == L"clan-spawn")
cmd_clanSpawn(os, ctx);
else if(ctx->parms[0] == L"clan-info")
cmd_clanInfo(os, ctx);
else
os<<L"-!- Invalid command: " + ctx->parms[0];