Context Navigation

Level2.cpp @ 79

Revision 79, 118.6 kB (checked in by yumileroy, 17 years ago)

[svn] * Minor code fixes
* Move account related functions from ObjectMgr? to AccountMgr? and drop duplicate functions - source mangos
* recognize the dummy spells 38637, 38638 and 38639 as negative - source mangos
* added new command ".reload all_locales". Now all locales_* tables can be reloaded - source mangos

Original author: KingPin?
Date: 2008-10-20 12:59:45-05:00

Rev	Line
[37]	1	/*
[44]	2	* Copyright (C) 2008 Trinity <http://www.trinitycore.org/>
[37]	3	*
[44]	4	* Thanks to the original authors: MaNGOS <http://www.mangosproject.org/>
	5	*
[37]	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
[44]	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
[37]	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
[44]	18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
[37]	19	*/
	20
	21	#include "Common.h"
	22	#include "Database/DatabaseEnv.h"
	23	#include "WorldPacket.h"
	24	#include "WorldSession.h"
	25	#include "World.h"
	26	#include "ObjectMgr.h"
	27	#include "Player.h"
	28	#include "Item.h"
	29	#include "GameObject.h"
	30	#include "Opcodes.h"
	31	#include "Chat.h"
	32	#include "ObjectAccessor.h"
	33	#include "MapManager.h"
	34	#include "Language.h"
	35	#include "World.h"
	36	#include "GameEvent.h"
	37	#include "SpellMgr.h"
	38	#include "AccountMgr.h"
	39	#include "WaypointManager.h"
	40	#include "Util.h"
	41	#include <cctype>
	42	#include <iostream>
	43	#include <fstream>
	44	#include <map>
	45
	46	static uint32 ReputationRankStrIndex[MAX_REPUTATION_RANK] =
	47	{
	48	LANG_REP_HATED, LANG_REP_HOSTILE, LANG_REP_UNFRIENDLY, LANG_REP_NEUTRAL,
	49	LANG_REP_FRIENDLY, LANG_REP_HONORED, LANG_REP_REVERED, LANG_REP_EXALTED
	50	};
	51
	52	//mute player for some times
	53	bool ChatHandler::HandleMuteCommand(const char* args)
	54	{
	55	if (!*args)
	56	return false;
	57
	58	char charname = strtok((char)args, " ");
	59	if (!charname)
	60	return false;
	61
	62	std::string cname = charname;
	63
	64	char *timetonotspeak = strtok(NULL, " ");
	65	if(!timetonotspeak)
	66	return false;
	67
	68	uint32 notspeaktime = (uint32) atoi(timetonotspeak);
	69
	70	if(!normalizePlayerName(cname))
	71	{
	72	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	73	SetSentErrorMessage(true);
	74	return false;
	75	}
	76
	77	uint64 guid = objmgr.GetPlayerGUIDByName(cname.c_str());
	78	if(!guid)
	79	{
	80	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	81	SetSentErrorMessage(true);
	82	return false;
	83	}
	84
	85	Player *chr = objmgr.GetPlayer(guid);
	86
	87	// check security
	88	uint32 account_id = 0;
	89	uint32 security = 0;
	90
	91	if (chr)
	92	{
	93	account_id = chr->GetSession()->GetAccountId();
	94	security = chr->GetSession()->GetSecurity();
	95	}
	96	else
	97	{
	98	account_id = objmgr.GetPlayerAccountIdByGUID(guid);
[79]	99	security = accmgr.GetSecurity(account_id);
[37]	100	}
	101
	102	if(security >= m_session->GetSecurity())
	103	{
	104	SendSysMessage(LANG_YOURS_SECURITY_IS_LOW);
	105	SetSentErrorMessage(true);
	106	return false;
	107	}
	108
	109	time_t mutetime = time(NULL) + notspeaktime*60;
	110
	111	if (chr)
	112	chr->GetSession()->m_muteTime = mutetime;
	113
	114	loginDatabase.PExecute("UPDATE account SET mutetime = " I64FMTD " WHERE id = '%u'",uint64(mutetime), account_id );
	115
	116	if(chr)
	117	ChatHandler(chr).PSendSysMessage(LANG_YOUR_CHAT_DISABLED, notspeaktime);
	118
	119	PSendSysMessage(LANG_YOU_DISABLE_CHAT, cname.c_str(), notspeaktime);
	120
	121	return true;
	122	}
	123
	124	//unmute player
	125	bool ChatHandler::HandleUnmuteCommand(const char* args)
	126	{
	127	if (!*args)
	128	return false;
	129
	130	char charname = strtok((char)args, " ");
	131	if (!charname)
	132	return false;
	133
	134	std::string cname = charname;
	135
	136	if(!normalizePlayerName(cname))
	137	{
	138	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	139	SetSentErrorMessage(true);
	140	return false;
	141	}
	142
	143	uint64 guid = objmgr.GetPlayerGUIDByName(cname.c_str());
	144	if(!guid)
	145	{
	146	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	147	SetSentErrorMessage(true);
	148	return false;
	149	}
	150
	151	Player *chr = objmgr.GetPlayer(guid);
	152
	153	// check security
	154	uint32 account_id = 0;
	155	uint32 security = 0;
	156
	157	if (chr)
	158	{
	159	account_id = chr->GetSession()->GetAccountId();
	160	security = chr->GetSession()->GetSecurity();
	161	}
	162	else
	163	{
	164	account_id = objmgr.GetPlayerAccountIdByGUID(guid);
[79]	165	security = accmgr.GetSecurity(account_id);
[37]	166	}
	167
	168	if(security >= m_session->GetSecurity())
	169	{
	170	SendSysMessage(LANG_YOURS_SECURITY_IS_LOW);
	171	SetSentErrorMessage(true);
	172	return false;
	173	}
	174
	175	if (chr)
	176	{
	177	if(chr->CanSpeak())
	178	{
	179	SendSysMessage(LANG_CHAT_ALREADY_ENABLED);
	180	SetSentErrorMessage(true);
	181	return false;
	182	}
	183
	184	chr->GetSession()->m_muteTime = 0;
	185	}
	186
	187	loginDatabase.PExecute("UPDATE account SET mutetime = '0' WHERE id = '%u'", account_id );
	188
	189	if(chr)
	190	ChatHandler(chr).PSendSysMessage(LANG_YOUR_CHAT_ENABLED);
	191
	192	PSendSysMessage(LANG_YOU_ENABLE_CHAT, cname.c_str());
	193	return true;
	194	}
	195
	196	bool ChatHandler::HandleTargetObjectCommand(const char* args)
	197	{
	198	Player* pl = m_session->GetPlayer();
	199	QueryResult *result;
	200	GameEvent::ActiveEvents const& activeEventsList = gameeventmgr.GetActiveEventList();
	201	if(*args)
	202	{
	203	int32 id = atoi((char*)args);
	204	if(id)
	205	result = WorldDatabase.PQuery("SELECT guid, id, position_x, position_y, position_z, orientation, map, (POW(position_x - '%f', 2) + POW(position_y - '%f', 2) + POW(position_z - '%f', 2)) AS order_ FROM gameobject WHERE map = '%i' AND id = '%u' ORDER BY order_ ASC LIMIT 1",
	206	pl->GetPositionX(), pl->GetPositionY(), pl->GetPositionZ(), pl->GetMapId(),id);
	207	else
	208	{
	209	std::string name = args;
	210	WorldDatabase.escape_string(name);
	211	result = WorldDatabase.PQuery(
	212	"SELECT guid, id, position_x, position_y, position_z, orientation, map, (POW(position_x - %f, 2) + POW(position_y - %f, 2) + POW(position_z - %f, 2)) AS order_ "
	213	"FROM gameobject,gameobject_template WHERE gameobject_template.entry = gameobject.id AND map = %i AND name "_LIKE_" "_CONCAT3_("'%%'","'%s'","'%%'")" ORDER BY order_ ASC LIMIT 1",
	214	pl->GetPositionX(), pl->GetPositionY(), pl->GetPositionZ(), pl->GetMapId(),name.c_str());
	215	}
	216	}
	217	else
	218	{
	219	std::ostringstream eventFilter;
	220	eventFilter << " AND (event IS NULL ";
	221	bool initString = true;
	222
	223	for (GameEvent::ActiveEvents::const_iterator itr = activeEventsList.begin(); itr != activeEventsList.end(); ++itr)
	224	{
	225	if (initString)
	226	{
	227	eventFilter << "OR event IN (" <<*itr;
	228	initString =false;
	229	}
	230	else
	231	eventFilter << "," << *itr;
	232	}
	233
	234	if (!initString)
	235	eventFilter << "))";
	236	else
	237	eventFilter << ")";
	238
	239	result = WorldDatabase.PQuery("SELECT gameobject.guid, id, position_x, position_y, position_z, orientation, map, "
	240	"(POW(position_x - %f, 2) + POW(position_y - %f, 2) + POW(position_z - %f, 2)) AS order_ FROM gameobject "
	241	"LEFT OUTER JOIN game_event_gameobject on gameobject.guid=game_event_gameobject.guid WHERE map = '%i' %s ORDER BY order_ ASC LIMIT 1",
	242	m_session->GetPlayer()->GetPositionX(), m_session->GetPlayer()->GetPositionY(), m_session->GetPlayer()->GetPositionZ(), m_session->GetPlayer()->GetMapId(),eventFilter.str().c_str());
	243	}
	244
	245	if (!result)
	246	{
	247	SendSysMessage(LANG_COMMAND_TARGETOBJNOTFOUND);
	248	return true;
	249	}
	250
	251	Field *fields = result->Fetch();
	252	uint32 lowguid = fields[0].GetUInt32();
	253	uint32 id = fields[1].GetUInt32();
	254	float x = fields[2].GetFloat();
	255	float y = fields[3].GetFloat();
	256	float z = fields[4].GetFloat();
	257	float o = fields[5].GetFloat();
	258	int mapid = fields[6].GetUInt16();
	259	delete result;
	260
	261	GameObjectInfo const* goI = objmgr.GetGameObjectInfo(id);
	262
	263	if (!goI)
	264	{
	265	PSendSysMessage(LANG_GAMEOBJECT_NOT_EXIST,id);
	266	return false;
	267	}
	268
	269	GameObject* target = ObjectAccessor::GetGameObject(*m_session->GetPlayer(),MAKE_NEW_GUID(lowguid,id,HIGHGUID_GAMEOBJECT));
	270
	271	PSendSysMessage(LANG_GAMEOBJECT_DETAIL, lowguid, goI->name, lowguid, id, x, y, z, mapid, o);
	272
	273	if(target)
	274	{
	275	int32 curRespawnDelay = target->GetRespawnTimeEx()-time(NULL);
	276	if(curRespawnDelay < 0)
	277	curRespawnDelay = 0;
	278
	279	std::string curRespawnDelayStr = secsToTimeString(curRespawnDelay,true);
	280	std::string defRespawnDelayStr = secsToTimeString(target->GetRespawnDelay(),true);
	281
	282	PSendSysMessage(LANG_COMMAND_RAWPAWNTIMES, defRespawnDelayStr.c_str(),curRespawnDelayStr.c_str());
	283	}
	284	return true;
	285	}
	286
	287	//teleport to gameobject
	288	bool ChatHandler::HandleGoObjectCommand(const char* args)
	289	{
	290	if(!*args)
	291	return false;
	292
	293	Player* _player = m_session->GetPlayer();
	294
	295	// number or [name] Shift-click form \|color\|Hgameobject:go_guid\|h[name]\|h\|r
	296	char* cId = extractKeyFromLink((char*)args,"Hgameobject");
	297	if(!cId)
	298	return false;
	299
	300	int32 guid = atoi(cId);
	301	if(!guid)
	302	return false;
	303
	304	float x, y, z, ort;
	305	int mapid;
	306
	307	// by DB guid
	308	if (GameObjectData const* go_data = objmgr.GetGOData(guid))
	309	{
	310	x = go_data->posX;
	311	y = go_data->posY;
	312	z = go_data->posZ;
	313	ort = go_data->orientation;
	314	mapid = go_data->mapid;
	315	}
	316	else
	317	{
	318	SendSysMessage(LANG_COMMAND_GOOBJNOTFOUND);
	319	SetSentErrorMessage(true);
	320	return false;
	321	}
	322
	323	if(!MapManager::IsValidMapCoord(mapid,x,y,z,ort))
	324	{
	325	PSendSysMessage(LANG_INVALID_TARGET_COORD,x,y,mapid);
	326	SetSentErrorMessage(true);
	327	return false;
	328	}
	329
	330	// stop flight if need
	331	if(_player->isInFlight())
	332	{
	333	_player->GetMotionMaster()->MovementExpired();
	334	_player->m_taxi.ClearTaxiDestinations();
	335	}
	336	// save only in non-flight case
	337	else
	338	_player->SaveRecallPosition();
	339
	340	_player->TeleportTo(mapid, x, y, z, ort);
	341	return true;
	342	}
	343
	344	bool ChatHandler::HandleGoTriggerCommand(const char* args)
	345	{
	346	Player* _player = m_session->GetPlayer();
	347
	348	if (!*args)
	349	return false;
	350
	351	char atId = strtok((char)args, " ");
	352	if (!atId)
	353	return false;
	354
	355	int32 i_atId = atoi(atId);
	356
	357	if(!i_atId)
	358	return false;
	359
	360	AreaTriggerEntry const* at = sAreaTriggerStore.LookupEntry(i_atId);
	361	if (!at)
	362	{
	363	PSendSysMessage(LANG_COMMAND_GOAREATRNOTFOUND,i_atId);
	364	SetSentErrorMessage(true);
	365	return false;
	366	}
	367
	368	if(!MapManager::IsValidMapCoord(at->mapid,at->x,at->y,at->z))
	369	{
	370	PSendSysMessage(LANG_INVALID_TARGET_COORD,at->x,at->y,at->mapid);
	371	SetSentErrorMessage(true);
	372	return false;
	373	}
	374
	375	// stop flight if need
	376	if(_player->isInFlight())
	377	{
	378	_player->GetMotionMaster()->MovementExpired();
	379	_player->m_taxi.ClearTaxiDestinations();
	380	}
	381	// save only in non-flight case
	382	else
	383	_player->SaveRecallPosition();
	384
	385	_player->TeleportTo(at->mapid, at->x, at->y, at->z, _player->GetOrientation());
	386	return true;
	387	}
	388
	389	bool ChatHandler::HandleGoGraveyardCommand(const char* args)
	390	{
	391	Player* _player = m_session->GetPlayer();
	392
	393	if (!*args)
	394	return false;
	395
	396	char gyId = strtok((char)args, " ");
	397	if (!gyId)
	398	return false;
	399
	400	int32 i_gyId = atoi(gyId);
	401
	402	if(!i_gyId)
	403	return false;
	404
	405	WorldSafeLocsEntry const* gy = sWorldSafeLocsStore.LookupEntry(i_gyId);
	406	if (!gy)
	407	{
	408	PSendSysMessage(LANG_COMMAND_GRAVEYARDNOEXIST,i_gyId);
	409	SetSentErrorMessage(true);
	410	return false;
	411	}
	412
	413	if(!MapManager::IsValidMapCoord(gy->map_id,gy->x,gy->y,gy->z))
	414	{
	415	PSendSysMessage(LANG_INVALID_TARGET_COORD,gy->x,gy->y,gy->map_id);
	416	SetSentErrorMessage(true);
	417	return false;
	418	}
	419
	420	// stop flight if need
	421	if(_player->isInFlight())
	422	{
	423	_player->GetMotionMaster()->MovementExpired();
	424	_player->m_taxi.ClearTaxiDestinations();
	425	}
	426	// save only in non-flight case
	427	else
	428	_player->SaveRecallPosition();
	429
	430	_player->TeleportTo(gy->map_id, gy->x, gy->y, gy->z, _player->GetOrientation());
	431	return true;
	432	}
	433
	434	/** \brief Teleport the GM to the specified creature
	435	*
	436	* .gocreature <GUID> --> TP using creature.guid
	437	* .gocreature azuregos --> TP player to the mob with this name
	438	* Warning: If there is more than one mob with this name
	439	* you will be teleported to the first one that is found.
	440	* .gocreature id 6109 --> TP player to the mob, that has this creature_template.entry
	441	* Warning: If there is more than one mob with this "id"
	442	* you will be teleported to the first one that is found.
	443	*/
	444	//teleport to creature
	445	bool ChatHandler::HandleGoCreatureCommand(const char* args)
	446	{
	447	if(!*args)
	448	return false;
	449	Player* _player = m_session->GetPlayer();
	450
	451	// "id" or number or [name] Shift-click form \|color\|Hcreature_entry:creature_id\|h[name]\|h\|r
	452	char* pParam1 = extractKeyFromLink((char*)args,"Hcreature");
	453	if (!pParam1)
	454	return false;
	455
	456	std::ostringstream whereClause;
	457
	458	// User wants to teleport to the NPC's template entry
	459	if( strcmp(pParam1, "id") == 0 )
	460	{
	461	//sLog.outError("DEBUG: ID found");
	462
	463	// Get the "creature_template.entry"
	464	// number or [name] Shift-click form \|color\|Hcreature_entry:creature_id\|h[name]\|h\|r
	465	char* tail = strtok(NULL,"");
	466	if(!tail)
	467	return false;
	468	char* cId = extractKeyFromLink(tail,"Hcreature_entry");
	469	if(!cId)
	470	return false;
	471
	472	int32 tEntry = atoi(cId);
	473	//sLog.outError("DEBUG: ID value: %d", tEntry);
	474	if(!tEntry)
	475	return false;
	476
	477	whereClause << "WHERE id = '" << tEntry << "'";
	478	}
	479	else
	480	{
	481	//sLog.outError("DEBUG: ID not found");
	482
	483	int32 guid = atoi(pParam1);
	484
	485	// Number is invalid - maybe the user specified the mob's name
	486	if(!guid)
	487	{
	488	std::string name = pParam1;
	489	WorldDatabase.escape_string(name);
	490	whereClause << ", creature_template WHERE creature.id = creature_template.entry AND creature_template.name "_LIKE_" '" << name << "'";
	491	}
	492	else
	493	{
	494	whereClause << "WHERE guid = '" << guid << "'";
	495	}
	496	}
	497	//sLog.outError("DEBUG: %s", whereClause.c_str());
	498
	499	QueryResult *result = WorldDatabase.PQuery("SELECT position_x,position_y,position_z,orientation,map FROM creature %s", whereClause.str().c_str() );
	500	if (!result)
	501	{
	502	SendSysMessage(LANG_COMMAND_GOCREATNOTFOUND);
	503	SetSentErrorMessage(true);
	504	return false;
	505	}
	506	if( result->GetRowCount() > 1 )
	507	{
	508	SendSysMessage(LANG_COMMAND_GOCREATMULTIPLE);
	509	}
	510
	511	Field *fields = result->Fetch();
	512	float x = fields[0].GetFloat();
	513	float y = fields[1].GetFloat();
	514	float z = fields[2].GetFloat();
	515	float ort = fields[3].GetFloat();
	516	int mapid = fields[4].GetUInt16();
	517
	518	delete result;
	519
	520	if(!MapManager::IsValidMapCoord(mapid,x,y,z,ort))
	521	{
	522	PSendSysMessage(LANG_INVALID_TARGET_COORD,x,y,mapid);
	523	SetSentErrorMessage(true);
	524	return false;
	525	}
	526
	527	// stop flight if need
	528	if(_player->isInFlight())
	529	{
	530	_player->GetMotionMaster()->MovementExpired();
	531	_player->m_taxi.ClearTaxiDestinations();
	532	}
	533	// save only in non-flight case
	534	else
	535	_player->SaveRecallPosition();
	536
	537	_player->TeleportTo(mapid, x, y, z, ort);
	538	return true;
	539	}
	540
	541	bool ChatHandler::HandleGUIDCommand(const char* /args/)
	542	{
	543	uint64 guid = m_session->GetPlayer()->GetSelection();
	544
	545	if (guid == 0)
	546	{
	547	SendSysMessage(LANG_NO_SELECTION);
	548	SetSentErrorMessage(true);
	549	return false;
	550	}
	551
	552	PSendSysMessage(LANG_OBJECT_GUID, GUID_LOPART(guid), GUID_HIPART(guid));
	553	return true;
	554	}
	555
	556	bool ChatHandler::HandleLookupFactionCommand(const char* args)
	557	{
	558	if(!*args)
	559	return false;
	560
	561	Player *target = getSelectedPlayer();
	562	if (!target)
	563	{
	564	SendSysMessage(LANG_NO_CHAR_SELECTED);
	565	SetSentErrorMessage(true);
	566	return false;
	567	}
	568
	569	std::string namepart = args;
	570	std::wstring wnamepart;
	571
	572	if(!Utf8toWStr(namepart,wnamepart))
	573	return false;
	574
	575	// converting string that we try to find to lower case
	576	wstrToLower( wnamepart );
	577
	578	uint32 counter = 0; // Counter for figure out that we found smth.
	579
	580	for (uint32 id = 0; id < sFactionStore.GetNumRows(); id++)
	581	//for(FactionStateList::const_iterator itr = target->m_factions.begin(); itr != target->m_factions.end(); ++itr)
	582	{
	583	FactionEntry const *factionEntry = sFactionStore.LookupEntry(id);
	584	//FactionEntry const *factionEntry = sFactionStore.LookupEntry(itr->second.ID);
	585	if (factionEntry)
	586	{
	587	FactionStateList::const_iterator repItr = target->m_factions.find(factionEntry->reputationListID);
	588
	589	int loc = m_session->GetSessionDbcLocale();
	590	std::string name = factionEntry->name[loc];
	591	if(name.empty())
	592	continue;
	593
	594	if (!Utf8FitTo(name, wnamepart))
	595	{
	596	loc = 0;
	597	for(; loc < MAX_LOCALE; ++loc)
	598	{
	599	if(loc==m_session->GetSessionDbcLocale())
	600	continue;
	601
	602	name = factionEntry->name[loc];
	603	if(name.empty())
	604	continue;
	605
	606	if (Utf8FitTo(name, wnamepart))
	607	break;
	608	}
	609	}
	610
	611	if(loc < MAX_LOCALE)
	612	{
	613	// send faction in "id - [faction] rank reputation [visible] [at war] [own team] [unknown] [invisible] [inactive]" format
	614	// or "id - [faction] [no reputation]" format
	615	std::ostringstream ss;
	616	ss << id << " - \|cffffffff\|Hfaction:" << id << "\|h[" << name << " " << localeNames[loc] << "]\|h\|r";
	617
	618	if (repItr != target->m_factions.end())
	619	{
	620	ReputationRank rank = target->GetReputationRank(factionEntry);
[44]	621	std::string rankName = GetTrinityString(ReputationRankStrIndex[rank]);
[37]	622
	623	ss << " " << rankName << "\|h\|r (" << target->GetReputation(factionEntry) << ")";
	624
	625	if(repItr->second.Flags & FACTION_FLAG_VISIBLE)
[44]	626	ss << GetTrinityString(LANG_FACTION_VISIBLE);
[37]	627	if(repItr->second.Flags & FACTION_FLAG_AT_WAR)
[44]	628	ss << GetTrinityString(LANG_FACTION_ATWAR);
[37]	629	if(repItr->second.Flags & FACTION_FLAG_PEACE_FORCED)
[44]	630	ss << GetTrinityString(LANG_FACTION_PEACE_FORCED);
[37]	631	if(repItr->second.Flags & FACTION_FLAG_HIDDEN)
[44]	632	ss << GetTrinityString(LANG_FACTION_HIDDEN);
[37]	633	if(repItr->second.Flags & FACTION_FLAG_INVISIBLE_FORCED)
[44]	634	ss << GetTrinityString(LANG_FACTION_INVISIBLE_FORCED);
[37]	635	if(repItr->second.Flags & FACTION_FLAG_INACTIVE)
[44]	636	ss << GetTrinityString(LANG_FACTION_INACTIVE);
[37]	637	}
	638	else
[44]	639	ss << GetTrinityString(LANG_FACTION_NOREPUTATION);
[37]	640
	641	SendSysMessage(ss.str().c_str());
	642	counter++;
	643	}
	644	}
	645	}
	646
	647	if (counter == 0) // if counter == 0 then we found nth
	648	SendSysMessage(LANG_COMMAND_FACTION_NOTFOUND);
	649	return true;
	650	}
	651
	652	bool ChatHandler::HandleModifyRepCommand(const char * args)
	653	{
	654	if (!*args) return false;
	655
	656	Player* target = NULL;
	657	target = getSelectedPlayer();
	658
	659	if(!target)
	660	{
	661	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	662	SetSentErrorMessage(true);
	663	return false;
	664	}
	665
	666	char* factionTxt = extractKeyFromLink((char*)args,"Hfaction");
	667	if(!factionTxt)
	668	return false;
	669
	670	uint32 factionId = atoi(factionTxt);
	671
	672	int32 amount = 0;
	673	char *rankTxt = strtok(NULL, " ");
	674	if (!factionTxt \|\| !rankTxt)
	675	return false;
	676
	677	amount = atoi(rankTxt);
	678	if ((amount == 0) && (rankTxt[0] != '-') && !isdigit(rankTxt[0]))
	679	{
	680	std::string rankStr = rankTxt;
	681	std::wstring wrankStr;
	682	if(!Utf8toWStr(rankStr,wrankStr))
	683	return false;
	684	wstrToLower( wrankStr );
	685
	686	int r = 0;
	687	amount = -42000;
	688	for (; r < MAX_REPUTATION_RANK; ++r)
	689	{
[44]	690	std::string rank = GetTrinityString(ReputationRankStrIndex[r]);
[37]	691	if(rank.empty())
	692	continue;
	693
	694	std::wstring wrank;
	695	if(!Utf8toWStr(rank,wrank))
	696	continue;
	697
	698	wstrToLower(wrank);
	699
	700	if(wrank.substr(0,wrankStr.size())==wrankStr)
	701	{
	702	char *deltaTxt = strtok(NULL, " ");
	703	if (deltaTxt)
	704	{
	705	int32 delta = atoi(deltaTxt);
	706	if ((delta < 0) \|\| (delta > Player::ReputationRank_Length[r] -1))
	707	{
	708	PSendSysMessage(LANG_COMMAND_FACTION_DELTA, (Player::ReputationRank_Length[r]-1));
	709	SetSentErrorMessage(true);
	710	return false;
	711	}
	712	amount += delta;
	713	}
	714	break;
	715	}
	716	amount += Player::ReputationRank_Length[r];
	717	}
	718	if (r >= MAX_REPUTATION_RANK)
	719	{
	720	PSendSysMessage(LANG_COMMAND_FACTION_INVPARAM, rankTxt);
	721	SetSentErrorMessage(true);
	722	return false;
	723	}
	724	}
	725
	726	FactionEntry const *factionEntry = sFactionStore.LookupEntry(factionId);
	727
	728	if (!factionEntry)
	729	{
	730	PSendSysMessage(LANG_COMMAND_FACTION_UNKNOWN, factionId);
	731	SetSentErrorMessage(true);
	732	return false;
	733	}
	734
	735	if (factionEntry->reputationListID < 0)
	736	{
	737	PSendSysMessage(LANG_COMMAND_FACTION_NOREP_ERROR, factionEntry->name[m_session->GetSessionDbcLocale()], factionId);
	738	SetSentErrorMessage(true);
	739	return false;
	740	}
	741
	742	target->SetFactionReputation(factionEntry,amount);
	743	PSendSysMessage(LANG_COMMAND_MODIFY_REP, factionEntry->name[m_session->GetSessionDbcLocale()], factionId, target->GetName(), target->GetReputation(factionId));
	744	return true;
	745	}
	746
	747	bool ChatHandler::HandleNameCommand(const char* args)
	748	{
	749	/* Temp. disabled
	750	if(!*args)
	751	return false;
	752
	753	if(strlen((char*)args)>75)
	754	{
	755	PSendSysMessage(LANG_TOO_LONG_NAME, strlen((char*)args)-75);
	756	return true;
	757	}
	758
	759	for (uint8 i = 0; i < strlen(args); i++)
	760	{
	761	if(!isalpha(args[i]) && args[i]!=' ')
	762	{
	763	SendSysMessage(LANG_CHARS_ONLY);
	764	return false;
	765	}
	766	}
	767
	768	uint64 guid;
	769	guid = m_session->GetPlayer()->GetSelection();
	770	if (guid == 0)
	771	{
	772	SendSysMessage(LANG_NO_SELECTION);
	773	return true;
	774	}
	775
	776	Creature* pCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(), guid);
	777
	778	if(!pCreature)
	779	{
	780	SendSysMessage(LANG_SELECT_CREATURE);
	781	return true;
	782	}
	783
	784	pCreature->SetName(args);
	785	uint32 idname = objmgr.AddCreatureTemplate(pCreature->GetName());
	786	pCreature->SetUInt32Value(OBJECT_FIELD_ENTRY, idname);
	787
	788	pCreature->SaveToDB();
	789	*/
	790
	791	return true;
	792	}
	793
	794	bool ChatHandler::HandleSubNameCommand(const char* /args/)
	795	{
	796	/* Temp. disabled
	797
	798	if(!*args)
	799	args = "";
	800
	801	if(strlen((char*)args)>75)
	802	{
	803
	804	PSendSysMessage(LANG_TOO_LONG_SUBNAME, strlen((char*)args)-75);
	805	return true;
	806	}
	807
	808	for (uint8 i = 0; i < strlen(args); i++)
	809	{
	810	if(!isalpha(args[i]) && args[i]!=' ')
	811	{
	812	SendSysMessage(LANG_CHARS_ONLY);
	813	return false;
	814	}
	815	}
	816	uint64 guid;
	817	guid = m_session->GetPlayer()->GetSelection();
	818	if (guid == 0)
	819	{
	820	SendSysMessage(LANG_NO_SELECTION);
	821	return true;
	822	}
	823
	824	Creature* pCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(), guid);
	825
	826	if(!pCreature)
	827	{
	828	SendSysMessage(LANG_SELECT_CREATURE);
	829	return true;
	830	}
	831
	832	uint32 idname = objmgr.AddCreatureSubName(pCreature->GetName(),args,pCreature->GetUInt32Value(UNIT_FIELD_DISPLAYID));
	833	pCreature->SetUInt32Value(OBJECT_FIELD_ENTRY, idname);
	834
	835	pCreature->SaveToDB();
	836	*/
	837	return true;
	838	}
	839
	840	//move item to other slot
	841	bool ChatHandler::HandleItemMoveCommand(const char* args)
	842	{
	843	if(!*args)
	844	return false;
	845	uint8 srcslot, dstslot;
	846
	847	char* pParam1 = strtok((char*)args, " ");
	848	if (!pParam1)
	849	return false;
	850
	851	char* pParam2 = strtok(NULL, " ");
	852	if (!pParam2)
	853	return false;
	854
	855	srcslot = (uint8)atoi(pParam1);
	856	dstslot = (uint8)atoi(pParam2);
	857
	858	uint16 src = ((INVENTORY_SLOT_BAG_0 << 8) \| srcslot);
	859	uint16 dst = ((INVENTORY_SLOT_BAG_0 << 8) \| dstslot);
	860
	861	if(srcslot==dstslot)
	862	return true;
	863
	864	m_session->GetPlayer()->SwapItem( src, dst );
	865
	866	return true;
	867	}
	868
	869	//add spawn of creature
	870	bool ChatHandler::HandleAddSpwCommand(const char* args)
	871	{
	872	if(!*args)
	873	return false;
	874	char* charID = strtok((char*)args, " ");
	875	if (!charID)
	876	return false;
	877
	878	char* team = strtok(NULL, " ");
	879	int32 teamval = 0;
	880	if (team) { teamval = atoi(team); }
	881	if (teamval < 0) { teamval = 0; }
	882
	883	uint32 id = atoi(charID);
	884
	885	Player *chr = m_session->GetPlayer();
	886	float x = chr->GetPositionX();
	887	float y = chr->GetPositionY();
	888	float z = chr->GetPositionZ();
	889	float o = chr->GetOrientation();
	890	Map *map = chr->GetMap();
	891
	892	Creature* pCreature = new Creature;
	893	if (!pCreature->Create(objmgr.GenerateLowGuid(HIGHGUID_UNIT), map, id, (uint32)teamval))
	894	{
	895	delete pCreature;
	896	return false;
	897	}
	898
	899	pCreature->Relocate(x,y,z,o);
	900
	901	if(!pCreature->IsPositionValid())
	902	{
	903	sLog.outError("ERROR: Creature (guidlow %d, entry %d) not created. Suggested coordinates isn't valid (X: %f Y: %f)",pCreature->GetGUIDLow(),pCreature->GetEntry(),pCreature->GetPositionX(),pCreature->GetPositionY());
	904	delete pCreature;
	905	return false;
	906	}
	907
	908	pCreature->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()));
	909
	910	uint32 db_guid = pCreature->GetDBTableGUIDLow();
	911
	912	// To call _LoadGoods(); _LoadQuests(); CreateTrainerSpells();
	913	pCreature->LoadFromDB(db_guid, map);
	914
	915	map->Add(pCreature);
	916	objmgr.AddCreatureToGrid(db_guid, objmgr.GetCreatureData(db_guid));
	917	return true;
	918	}
	919
	920	bool ChatHandler::HandleDelCreatureCommand(const char* args)
	921	{
	922	Creature* unit = NULL;
	923
	924	if(*args)
	925	{
	926	// number or [name] Shift-click form \|color\|Hcreature:creature_guid\|h[name]\|h\|r
	927	char* cId = extractKeyFromLink((char*)args,"Hcreature");
	928	if(!cId)
	929	return false;
	930
	931	uint32 lowguid = atoi(cId);
	932	if(!lowguid)
	933	return false;
	934
	935	if (CreatureData const* cr_data = objmgr.GetCreatureData(lowguid))
	936	unit = ObjectAccessor::GetCreature(*m_session->GetPlayer(), MAKE_NEW_GUID(lowguid, cr_data->id, HIGHGUID_UNIT));
	937	}
	938	else
	939	unit = getSelectedCreature();
	940
	941	if(!unit \|\| unit->isPet() \|\| unit->isTotem())
	942	{
	943	SendSysMessage(LANG_SELECT_CREATURE);
	944	SetSentErrorMessage(true);
	945	return false;
	946	}
	947
	948	// Delete the creature
	949	unit->CombatStop();
	950	unit->DeleteFromDB();
	951	unit->CleanupsBeforeDelete();
	952	unit->AddObjectToRemoveList();
	953
	954	SendSysMessage(LANG_COMMAND_DELCREATMESSAGE);
	955
	956	return true;
	957	}
	958
	959	//delete object by selection or guid
	960	bool ChatHandler::HandleDelObjectCommand(const char* args)
	961	{
	962	// number or [name] Shift-click form \|color\|Hgameobject:go_guid\|h[name]\|h\|r
	963	char* cId = extractKeyFromLink((char*)args,"Hgameobject");
	964	if(!cId)
	965	return false;
	966
	967	uint32 lowguid = atoi(cId);
	968	if(!lowguid)
	969	return false;
	970
	971	GameObject* obj = NULL;
	972
	973	// by DB guid
	974	if (GameObjectData const* go_data = objmgr.GetGOData(lowguid))
	975	obj = GetObjectGlobalyWithGuidOrNearWithDbGuid(lowguid,go_data->id);
	976
	977	if(!obj)
	978	{
	979	PSendSysMessage(LANG_COMMAND_OBJNOTFOUND, lowguid);
	980	SetSentErrorMessage(true);
	981	return false;
	982	}
	983
	984	uint64 owner_guid = obj->GetOwnerGUID();
	985	if(owner_guid)
	986	{
	987	Unit* owner = ObjectAccessor::GetUnit(*m_session->GetPlayer(),owner_guid);
	988	if(!owner && !IS_PLAYER_GUID(owner_guid))
	989	{
	990	PSendSysMessage(LANG_COMMAND_DELOBJREFERCREATURE, GUID_LOPART(owner_guid), obj->GetGUIDLow());
	991	SetSentErrorMessage(true);
	992	return false;
	993	}
	994
	995	owner->RemoveGameObject(obj,false);
	996	}
	997
	998	obj->SetRespawnTime(0); // not save respawn time
	999	obj->Delete();
	1000	obj->DeleteFromDB();
	1001
	1002	PSendSysMessage(LANG_COMMAND_DELOBJMESSAGE, obj->GetGUIDLow());
	1003
	1004	return true;
	1005	}
	1006
	1007	//turn selected object
	1008	bool ChatHandler::HandleTurnObjectCommand(const char* args)
	1009	{
	1010	// number or [name] Shift-click form \|color\|Hgameobject:go_id\|h[name]\|h\|r
	1011	char* cId = extractKeyFromLink((char*)args,"Hgameobject");
	1012	if(!cId)
	1013	return false;
	1014
	1015	uint32 lowguid = atoi(cId);
	1016	if(!lowguid)
	1017	return false;
	1018
	1019	GameObject* obj = NULL;
	1020
	1021	// by DB guid
	1022	if (GameObjectData const* go_data = objmgr.GetGOData(lowguid))
	1023	obj = GetObjectGlobalyWithGuidOrNearWithDbGuid(lowguid,go_data->id);
	1024
	1025	if(!obj)
	1026	{
	1027	PSendSysMessage(LANG_COMMAND_OBJNOTFOUND, lowguid);
	1028	SetSentErrorMessage(true);
	1029	return false;
	1030	}
	1031
	1032	char* po = strtok(NULL, " ");
	1033	float o;
	1034
	1035	if (po)
	1036	{
	1037	o = (float)atof(po);
	1038	}
	1039	else
	1040	{
	1041	Player *chr = m_session->GetPlayer();
	1042	o = chr->GetOrientation();
	1043	}
	1044
	1045	float rot2 = sin(o/2);
	1046	float rot3 = cos(o/2);
	1047
	1048	Map* map = MapManager::Instance().GetMap(obj->GetMapId(),obj);
	1049	map->Remove(obj,false);
	1050
	1051	obj->Relocate(obj->GetPositionX(), obj->GetPositionY(), obj->GetPositionZ(), o);
	1052
	1053	obj->SetFloatValue(GAMEOBJECT_FACING, o);
	1054	obj->SetFloatValue(GAMEOBJECT_ROTATION+2, rot2);
	1055	obj->SetFloatValue(GAMEOBJECT_ROTATION+3, rot3);
	1056
	1057	map->Add(obj);
	1058
	1059	obj->SaveToDB();
	1060	obj->Refresh();
	1061
	1062	PSendSysMessage(LANG_COMMAND_TURNOBJMESSAGE, obj->GetGUIDLow(), o);
	1063
	1064	return true;
	1065	}
	1066
	1067	//move selected creature
	1068	bool ChatHandler::HandleMoveCreatureCommand(const char* args)
	1069	{
	1070	uint32 lowguid = 0;
	1071
	1072	Creature* pCreature = getSelectedCreature();
	1073
	1074	if(!pCreature)
	1075	{
	1076	// number or [name] Shift-click form \|color\|Hcreature:creature_guid\|h[name]\|h\|r
	1077	char* cId = extractKeyFromLink((char*)args,"Hcreature");
	1078	if(!cId)
	1079	return false;
	1080
	1081	uint32 lowguid = atoi(cId);
	1082
	1083	/* FIXME: impossibel without entry
	1084	if(lowguid)
	1085	pCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_GUID(lowguid,HIGHGUID_UNIT));
	1086	*/
	1087
	1088	// Attempting creature load from DB data
	1089	if(!pCreature)
	1090	{
	1091	CreatureData const* data = objmgr.GetCreatureData(lowguid);
	1092	if(!data)
	1093	{
	1094	PSendSysMessage(LANG_COMMAND_CREATGUIDNOTFOUND, lowguid);
	1095	SetSentErrorMessage(true);
	1096	return false;
	1097	}
	1098
	1099	uint32 map_id = data->mapid;
	1100
	1101	if(m_session->GetPlayer()->GetMapId()!=map_id)
	1102	{
	1103	PSendSysMessage(LANG_COMMAND_CREATUREATSAMEMAP, lowguid);
	1104	SetSentErrorMessage(true);
	1105	return false;
	1106	}
	1107	}
	1108	else
	1109	{
	1110	lowguid = pCreature->GetDBTableGUIDLow();
	1111	}
	1112	}
	1113	else
	1114	{
	1115	lowguid = pCreature->GetDBTableGUIDLow();
	1116	}
	1117
	1118	float x = m_session->GetPlayer()->GetPositionX();
	1119	float y = m_session->GetPlayer()->GetPositionY();
	1120	float z = m_session->GetPlayer()->GetPositionZ();
	1121	float o = m_session->GetPlayer()->GetOrientation();
	1122
	1123	if (pCreature)
	1124	{
	1125	if(CreatureData const* data = objmgr.GetCreatureData(pCreature->GetDBTableGUIDLow()))
	1126	{
	1127	const_cast<CreatureData*>(data)->posX = x;
	1128	const_cast<CreatureData*>(data)->posY = y;
	1129	const_cast<CreatureData*>(data)->posZ = z;
	1130	const_cast<CreatureData*>(data)->orientation = o;
	1131	}
	1132	MapManager::Instance().GetMap(pCreature->GetMapId(),pCreature)->CreatureRelocation(pCreature,x, y, z,o);
	1133	pCreature->GetMotionMaster()->Initialize();
	1134	if(pCreature->isAlive()) // dead creature will reset movement generator at respawn
	1135	{
	1136	pCreature->setDeathState(JUST_DIED);
	1137	pCreature->Respawn();
	1138	}
	1139	}
	1140
	1141	WorldDatabase.PExecuteLog("UPDATE creature SET position_x = '%f', position_y = '%f', position_z = '%f', orientation = '%f' WHERE guid = '%u'", x, y, z, o, lowguid);
	1142	PSendSysMessage(LANG_COMMAND_CREATUREMOVED);
	1143	return true;
	1144	}
	1145
	1146	//move selected object
	1147	bool ChatHandler::HandleMoveObjectCommand(const char* args)
	1148	{
	1149	// number or [name] Shift-click form \|color\|Hgameobject:go_guid\|h[name]\|h\|r
	1150	char* cId = extractKeyFromLink((char*)args,"Hgameobject");
	1151	if(!cId)
	1152	return false;
	1153
	1154	uint32 lowguid = atoi(cId);
	1155	if(!lowguid)
	1156	return false;
	1157
	1158	GameObject* obj = NULL;
	1159
	1160	// by DB guid
	1161	if (GameObjectData const* go_data = objmgr.GetGOData(lowguid))
	1162	obj = GetObjectGlobalyWithGuidOrNearWithDbGuid(lowguid,go_data->id);
	1163
	1164	if(!obj)
	1165	{
	1166	PSendSysMessage(LANG_COMMAND_OBJNOTFOUND, lowguid);
	1167	SetSentErrorMessage(true);
	1168	return false;
	1169	}
	1170
	1171	char* px = strtok(NULL, " ");
	1172	char* py = strtok(NULL, " ");
	1173	char* pz = strtok(NULL, " ");
	1174
	1175	if (!px)
	1176	{
	1177	Player *chr = m_session->GetPlayer();
	1178
	1179	Map* map = MapManager::Instance().GetMap(obj->GetMapId(),obj);
	1180	map->Remove(obj,false);
	1181
	1182	obj->Relocate(chr->GetPositionX(), chr->GetPositionY(), chr->GetPositionZ(), obj->GetOrientation());
	1183	obj->SetFloatValue(GAMEOBJECT_POS_X, chr->GetPositionX());
	1184	obj->SetFloatValue(GAMEOBJECT_POS_Y, chr->GetPositionY());
	1185	obj->SetFloatValue(GAMEOBJECT_POS_Z, chr->GetPositionZ());
	1186
	1187	map->Add(obj);
	1188	}
	1189	else
	1190	{
	1191	if(!py \|\| !pz)
	1192	return false;
	1193
	1194	float x = (float)atof(px);
	1195	float y = (float)atof(py);
	1196	float z = (float)atof(pz);
	1197
	1198	if(!MapManager::IsValidMapCoord(obj->GetMapId(),x,y,z))
	1199	{
	1200	PSendSysMessage(LANG_INVALID_TARGET_COORD,x,y,obj->GetMapId());
	1201	SetSentErrorMessage(true);
	1202	return false;
	1203	}
	1204
	1205	Map* map = MapManager::Instance().GetMap(obj->GetMapId(),obj);
	1206	map->Remove(obj,false);
	1207
	1208	obj->Relocate(x, y, z, obj->GetOrientation());
	1209	obj->SetFloatValue(GAMEOBJECT_POS_X, x);
	1210	obj->SetFloatValue(GAMEOBJECT_POS_Y, y);
	1211	obj->SetFloatValue(GAMEOBJECT_POS_Z, z);
	1212
	1213	map->Add(obj);
	1214	}
	1215
	1216	obj->SaveToDB();
	1217	obj->Refresh();
	1218
	1219	PSendSysMessage(LANG_COMMAND_MOVEOBJMESSAGE, obj->GetGUIDLow());
	1220
	1221	return true;
	1222	}
	1223
	1224	//demorph player or unit
	1225	bool ChatHandler::HandleDeMorphCommand(const char* /args/)
	1226	{
	1227	Unit *target = getSelectedUnit();
	1228	if(!target)
	1229	target = m_session->GetPlayer();
	1230
	1231	target->DeMorph();
	1232
	1233	return true;
	1234	}
	1235
	1236	//add item in vendorlist
	1237	bool ChatHandler::HandleAddVendorItemCommand(const char* args)
	1238	{
	1239	if (!*args)
	1240	return false;
	1241
	1242	char* pitem = extractKeyFromLink((char*)args,"Hitem");
	1243	if (!pitem)
	1244	{
	1245	SendSysMessage(LANG_COMMAND_NEEDITEMSEND);
	1246	SetSentErrorMessage(true);
	1247	return false;
	1248	}
	1249
	1250	uint32 itemId = atol(pitem);
	1251
	1252	char* fmaxcount = strtok(NULL, " "); //add maxcount, default: 0
	1253	uint32 maxcount = 0;
	1254	if (fmaxcount)
	1255	maxcount = atol(fmaxcount);
	1256
	1257	char* fincrtime = strtok(NULL, " "); //add incrtime, default: 0
	1258	uint32 incrtime = 0;
	1259	if (fincrtime)
	1260	incrtime = atol(fincrtime);
	1261
	1262	char* fextendedcost = strtok(NULL, " "); //add ExtendedCost, default: 0
	1263	uint32 extendedcost = fextendedcost ? atol(fextendedcost) : 0;
	1264
	1265	Creature* vendor = getSelectedCreature();
	1266
	1267	uint32 vendor_entry = vendor ? vendor->GetEntry() : 0;
	1268
	1269	if(!objmgr.IsVendorItemValid(vendor_entry,itemId,maxcount,incrtime,extendedcost,m_session->GetPlayer()))
	1270	{
	1271	SetSentErrorMessage(true);
	1272	return false;
	1273	}
	1274
	1275	objmgr.AddVendorItem(vendor_entry,itemId,maxcount,incrtime,extendedcost);
	1276
	1277	ItemPrototype const* pProto = objmgr.GetItemPrototype(itemId);
	1278
	1279	PSendSysMessage(LANG_ITEM_ADDED_TO_LIST,itemId,pProto->Name1,maxcount,incrtime,extendedcost);
	1280	return true;
	1281	}
	1282
	1283	//del item from vendor list
	1284	bool ChatHandler::HandleDelVendorItemCommand(const char* args)
	1285	{
	1286	if (!*args)
	1287	return false;
	1288
	1289	Creature* vendor = getSelectedCreature();
	1290	if (!vendor \|\| !vendor->isVendor())
	1291	{
	1292	SendSysMessage(LANG_COMMAND_VENDORSELECTION);
	1293	SetSentErrorMessage(true);
	1294	return false;
	1295	}
	1296
	1297	char* pitem = extractKeyFromLink((char*)args,"Hitem");
	1298	if (!pitem)
	1299	{
	1300	SendSysMessage(LANG_COMMAND_NEEDITEMSEND);
	1301	SetSentErrorMessage(true);
	1302	return false;
	1303	}
	1304	uint32 itemId = atol(pitem);
	1305
	1306
	1307	if(!objmgr.RemoveVendorItem(vendor->GetEntry(),itemId))
	1308	{
	1309	PSendSysMessage(LANG_ITEM_NOT_IN_LIST,itemId);
	1310	SetSentErrorMessage(true);
	1311	return false;
	1312	}
	1313
	1314	ItemPrototype const* pProto = objmgr.GetItemPrototype(itemId);
	1315
	1316	PSendSysMessage(LANG_ITEM_DELETED_FROM_LIST,itemId,pProto->Name1);
	1317	return true;
	1318	}
	1319
	1320	//add move for creature
	1321	bool ChatHandler::HandleAddMoveCommand(const char* args)
	1322	{
	1323	if(!*args)
	1324	return false;
	1325
	1326	char* guid_str = strtok((char*)args, " ");
	1327	char* wait_str = strtok((char*)NULL, " ");
	1328
	1329	uint32 lowguid = atoi((char*)guid_str);
	1330
	1331	Creature* pCreature = NULL;
	1332
	1333	/* FIXME: impossible without entry
	1334	if(lowguid)
	1335	pCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_GUID(lowguid,HIGHGUID_UNIT));
	1336	*/
	1337
	1338	// attempt check creature existence by DB data
	1339	if(!pCreature)
	1340	{
	1341	CreatureData const* data = objmgr.GetCreatureData(lowguid);
	1342	if(!data)
	1343	{
	1344	PSendSysMessage(LANG_COMMAND_CREATGUIDNOTFOUND, lowguid);
	1345	SetSentErrorMessage(true);
	1346	return false;
	1347	}
	1348	}
	1349	else
	1350	{
	1351	// obtain real GUID for DB operations
	1352	lowguid = pCreature->GetDBTableGUIDLow();
	1353	}
	1354
	1355	int wait = wait_str ? atoi(wait_str) : 0;
	1356
	1357	if(wait < 0)
	1358	wait = 0;
	1359
	1360	Player* player = m_session->GetPlayer();
	1361
	1362	WaypointMgr.AddLastNode(lowguid, player->GetPositionX(), player->GetPositionY(), player->GetPositionZ(), player->GetOrientation(), wait, 0);
	1363
	1364	// update movement type
	1365	WorldDatabase.PExecuteLog("UPDATE creature SET MovementType = '%u' WHERE guid = '%u'", WAYPOINT_MOTION_TYPE,lowguid);
	1366	if(pCreature)
	1367	{
	1368	pCreature->SetDefaultMovementType(WAYPOINT_MOTION_TYPE);
	1369	pCreature->GetMotionMaster()->Initialize();
	1370	if(pCreature->isAlive()) // dead creature will reset movement generator at respawn
	1371	{
	1372	pCreature->setDeathState(JUST_DIED);
	1373	pCreature->Respawn();
	1374	}
	1375	pCreature->SaveToDB();
	1376	}
	1377
	1378	SendSysMessage(LANG_WAYPOINT_ADDED);
	1379
	1380	return true;
	1381	}
	1382
	1383	/**
	1384	* Set the movement type for an NPC.<br/>
	1385	* <br/>
	1386	* Valid movement types are:
	1387	* <ul>
	1388	* <li> stay - NPC wont move </li>
	1389	* <li> random - NPC will move randomly according to the spawndist </li>
	1390	* <li> way - NPC will move with given waypoints set </li>
	1391	* </ul>
	1392	* additional parameter: NODEL - so no waypoints are deleted, if you
	1393	* change the movement type
	1394	*/
	1395	bool ChatHandler::HandleSetMoveTypeCommand(const char* args)
	1396	{
	1397	if(!*args)
	1398	return false;
	1399
	1400	// 3 arguments:
	1401	// GUID (optional - you can also select the creature)
	1402	// stay\|random\|way (determines the kind of movement)
	1403	// NODEL (optional - tells the system NOT to delete any waypoints)
	1404	// this is very handy if you want to do waypoints, that are
	1405	// later switched on/off according to special events (like escort
	1406	// quests, etc)
	1407	char* guid_str = strtok((char*)args, " ");
	1408	char* type_str = strtok((char*)NULL, " ");
	1409	char* dontdel_str = strtok((char*)NULL, " ");
	1410
	1411	bool doNotDelete = false;
	1412
	1413	if(!guid_str)
	1414	return false;
	1415
	1416	uint32 lowguid = 0;
	1417	Creature* pCreature = NULL;
	1418
	1419	if( dontdel_str )
	1420	{
	1421	//sLog.outError("DEBUG: All 3 params are set");
	1422
	1423	// All 3 params are set
	1424	// GUID
	1425	// type
	1426	// doNotDEL
	1427	if( stricmp( dontdel_str, "NODEL" ) == 0 )
	1428	{
	1429	//sLog.outError("DEBUG: doNotDelete = true;");
	1430	doNotDelete = true;
	1431	}
	1432	}
	1433	else
	1434	{
	1435	// Only 2 params - but maybe NODEL is set
	1436	if( type_str )
	1437	{
	1438	sLog.outError("DEBUG: Only 2 params ");
	1439	if( stricmp( type_str, "NODEL" ) == 0 )
	1440	{
	1441	//sLog.outError("DEBUG: type_str, NODEL ");
	1442	doNotDelete = true;
	1443	type_str = NULL;
	1444	}
	1445	}
	1446	}
	1447
	1448	if(!type_str) // case .setmovetype $move_type (with selected creature)
	1449	{
	1450	type_str = guid_str;
	1451	pCreature = getSelectedCreature();
[79]	1452	if(!pCreature \|\| pCreature->isPet())
[37]	1453	return false;
	1454	lowguid = pCreature->GetDBTableGUIDLow();
	1455	}
	1456	else // case .setmovetype #creature_guid $move_type (with selected creature)
	1457	{
	1458	lowguid = atoi((char*)guid_str);
	1459
	1460	/* impossible without entry
	1461	if(lowguid)
	1462	pCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_GUID(lowguid,HIGHGUID_UNIT));
	1463	*/
	1464
	1465	// attempt check creature existence by DB data
	1466	if(!pCreature)
	1467	{
	1468	CreatureData const* data = objmgr.GetCreatureData(lowguid);
	1469	if(!data)
	1470	{
	1471	PSendSysMessage(LANG_COMMAND_CREATGUIDNOTFOUND, lowguid);
	1472	SetSentErrorMessage(true);
	1473	return false;
	1474	}
	1475	}
	1476	else
	1477	{
	1478	lowguid = pCreature->GetDBTableGUIDLow();
	1479	}
	1480	}
	1481
	1482	// now lowguid is low guid really existed creature
	1483	// and pCreature point (maybe) to this creature or NULL
	1484
	1485	MovementGeneratorType move_type;
	1486
	1487	std::string type = type_str;
	1488
	1489	if(type == "stay")
	1490	move_type = IDLE_MOTION_TYPE;
	1491	else if(type == "random")
	1492	move_type = RANDOM_MOTION_TYPE;
	1493	else if(type == "way")
	1494	move_type = WAYPOINT_MOTION_TYPE;
	1495	else
	1496	return false;
	1497
	1498	// update movement type
	1499	if(doNotDelete == false)
	1500	WaypointMgr.DeletePath(lowguid);
	1501
	1502	if(pCreature)
	1503	{
	1504	pCreature->SetDefaultMovementType(move_type);
	1505	pCreature->GetMotionMaster()->Initialize();
	1506	if(pCreature->isAlive()) // dead creature will reset movement generator at respawn
	1507	{
	1508	pCreature->setDeathState(JUST_DIED);
	1509	pCreature->Respawn();
	1510	}
	1511	pCreature->SaveToDB();
	1512	}
	1513	if( doNotDelete == false )
	1514	{
	1515	PSendSysMessage(LANG_MOVE_TYPE_SET,type_str);
	1516	}
	1517	else
	1518	{
	1519	PSendSysMessage(LANG_MOVE_TYPE_SET_NODEL,type_str);
	1520	}
	1521
	1522	return true;
	1523	} // HandleSetMoveTypeCommand
	1524
	1525	//change level of creature or pet
	1526	bool ChatHandler::HandleChangeLevelCommand(const char* args)
	1527	{
	1528	if (!*args)
	1529	return false;
	1530
	1531	uint8 lvl = (uint8) atoi((char*)args);
	1532	if ( lvl < 1 \|\| lvl > sWorld.getConfig(CONFIG_MAX_PLAYER_LEVEL) + 3)
	1533	{
	1534	SendSysMessage(LANG_BAD_VALUE);
	1535	SetSentErrorMessage(true);
	1536	return false;
	1537	}
	1538
	1539	Creature* pCreature = getSelectedCreature();
	1540	if(!pCreature)
	1541	{
	1542	SendSysMessage(LANG_SELECT_CREATURE);
	1543	SetSentErrorMessage(true);
	1544	return false;
	1545	}
	1546
	1547	if(pCreature->isPet())
	1548	{
	1549	((Pet*)pCreature)->GivePetLevel(lvl);
	1550	}
	1551	else
	1552	{
	1553	pCreature->SetMaxHealth( 100 + 30*lvl);
	1554	pCreature->SetHealth( 100 + 30*lvl);
	1555	pCreature->SetLevel( lvl);
	1556	pCreature->SaveToDB();
	1557	}
	1558
	1559	return true;
	1560	}
	1561
	1562	//set npcflag of creature
	1563	bool ChatHandler::HandleNPCFlagCommand(const char* args)
	1564	{
	1565	if (!*args)
	1566	return false;
	1567
	1568	uint32 npcFlags = (uint32) atoi((char*)args);
	1569
	1570	Creature* pCreature = getSelectedCreature();
	1571
	1572	if(!pCreature)
	1573	{
	1574	SendSysMessage(LANG_SELECT_CREATURE);
	1575	SetSentErrorMessage(true);
	1576	return false;
	1577	}
	1578
	1579	pCreature->SetUInt32Value(UNIT_NPC_FLAGS, npcFlags);
	1580
	1581	WorldDatabase.PExecuteLog("UPDATE creature_template SET npcflag = '%u' WHERE entry = '%u'", npcFlags, pCreature->GetEntry());
	1582
	1583	SendSysMessage(LANG_VALUE_SAVED_REJOIN);
	1584
	1585	return true;
	1586	}
	1587
	1588	//set model of creature
	1589	bool ChatHandler::HandleSetModelCommand(const char* args)
	1590	{
	1591	if (!*args)
	1592	return false;
	1593
	1594	uint32 displayId = (uint32) atoi((char*)args);
	1595
	1596	Creature *pCreature = getSelectedCreature();
	1597
[79]	1598	if(!pCreature \|\| pCreature->isPet())
[37]	1599	{
	1600	SendSysMessage(LANG_SELECT_CREATURE);
	1601	SetSentErrorMessage(true);
	1602	return false;
	1603	}
	1604
	1605	pCreature->SetDisplayId(displayId);
	1606	pCreature->SetNativeDisplayId(displayId);
	1607
	1608	pCreature->SaveToDB();
	1609
	1610	return true;
	1611	}
	1612
	1613	//morph creature or player
	1614	bool ChatHandler::HandleMorphCommand(const char* args)
	1615	{
	1616	if (!*args)
	1617	return false;
	1618
	1619	uint16 display_id = (uint16)atoi((char*)args);
	1620
	1621	Unit *target = getSelectedUnit();
	1622	if(!target)
	1623	target = m_session->GetPlayer();
	1624
	1625	target->SetDisplayId(display_id);
	1626
	1627	return true;
	1628	}
	1629
	1630	//set faction of creature or go
	1631	bool ChatHandler::HandleFactionIdCommand(const char* args)
	1632	{
	1633	if (!*args)
	1634	return false;
	1635
	1636	uint32 factionId = (uint32) atoi((char*)args);
	1637
	1638	if (!sFactionTemplateStore.LookupEntry(factionId))
	1639	{
	1640	PSendSysMessage(LANG_WRONG_FACTION, factionId);
	1641	SetSentErrorMessage(true);
	1642	return false;
	1643	}
	1644
	1645	Creature* pCreature = getSelectedCreature();
	1646
	1647	if(!pCreature)
	1648	{
	1649	SendSysMessage(LANG_SELECT_CREATURE);
	1650	SetSentErrorMessage(true);
	1651	return false;
	1652	}
	1653
	1654	pCreature->setFaction(factionId);
	1655
	1656	// faction is set in creature_template - not inside creature
	1657
	1658	// update in memory
	1659	if(CreatureInfo const *cinfo = pCreature->GetCreatureInfo())
	1660	{
	1661	const_cast<CreatureInfo*>(cinfo)->faction_A = factionId;
	1662	const_cast<CreatureInfo*>(cinfo)->faction_H = factionId;
	1663	}
	1664
	1665	// and DB
	1666	WorldDatabase.PExecuteLog("UPDATE creature_template SET faction_A = '%u', faction_H = '%u' WHERE entry = '%u'", factionId, factionId, pCreature->GetEntry());
	1667
	1668	return true;
	1669	}
	1670
	1671	//kick player
	1672	bool ChatHandler::HandleKickPlayerCommand(const char *args)
	1673	{
	1674	char* kickName = strtok((char*)args, " ");
	1675	if (!kickName)
	1676	{
	1677	Player* player = getSelectedPlayer();
	1678
	1679	if(!player)
	1680	{
	1681	SendSysMessage(LANG_NO_CHAR_SELECTED);
	1682	SetSentErrorMessage(true);
	1683	return false;
	1684	}
	1685
	1686	if(player==m_session->GetPlayer())
	1687	{
	1688	SendSysMessage(LANG_COMMAND_KICKSELF);
	1689	SetSentErrorMessage(true);
	1690	return false;
	1691	}
	1692
	1693	player->GetSession()->KickPlayer();
	1694	}
	1695	else
	1696	{
	1697	std::string name = kickName;
	1698	if(!normalizePlayerName(name))
	1699	{
	1700	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	1701	SetSentErrorMessage(true);
	1702	return false;
	1703	}
	1704
	1705	if(name==m_session->GetPlayer()->GetName())
	1706	{
	1707	SendSysMessage(LANG_COMMAND_KICKSELF);
	1708	SetSentErrorMessage(true);
	1709	return false;
	1710	}
	1711
	1712	if(sWorld.KickPlayer(name))
	1713	{
	1714	PSendSysMessage(LANG_COMMAND_KICKMESSAGE,name.c_str());
	1715	}
	1716	else
	1717	PSendSysMessage(LANG_COMMAND_KICKNOTFOUNDPLAYER,name.c_str());
	1718	}
	1719
	1720	return true;
	1721	}
	1722
	1723	//show info of player
	1724	bool ChatHandler::HandlePInfoCommand(const char* args)
	1725	{
	1726	Player* target = NULL;
	1727	uint64 targetGUID = 0;
	1728
	1729	char* px = strtok((char*)args, " ");
	1730	char* py = NULL;
	1731
	1732	std::string name;
	1733
	1734	if (px)
	1735	{
	1736	name = px;
	1737
	1738	if(name.empty())
	1739	return false;
	1740
	1741	if(!normalizePlayerName(name))
	1742	{
	1743	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	1744	SetSentErrorMessage(true);
	1745	return false;
	1746	}
	1747
	1748	target = objmgr.GetPlayer(name.c_str());
	1749	if (target)
	1750	py = strtok(NULL, " ");
	1751	else
	1752	{
	1753	targetGUID = objmgr.GetPlayerGUIDByName(name);
	1754	if(targetGUID)
	1755	py = strtok(NULL, " ");
	1756	else
	1757	py = px;
	1758	}
	1759	}
	1760
	1761	if(!target && !targetGUID)
	1762	{
	1763	target = getSelectedPlayer();
	1764	}
	1765
	1766	if(!target && !targetGUID)
	1767	{
	1768	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	1769	SetSentErrorMessage(true);
	1770	return false;
	1771	}
	1772
	1773	uint32 accId = 0;
	1774	uint32 money = 0;
	1775	uint32 total_player_time = 0;
	1776	uint32 level = 0;
	1777	uint32 latency = 0;
	1778
	1779	// get additional information from Player object
	1780	if(target)
	1781	{
	1782	targetGUID = target->GetGUID();
	1783	name = target->GetName(); // re-read for case getSelectedPlayer() target
	1784	accId = target->GetSession()->GetAccountId();
	1785	money = target->GetMoney();
	1786	total_player_time = target->GetTotalPlayedTime();
	1787	level = target->getLevel();
	1788	latency = target->GetSession()->GetLatency();
	1789	}
	1790	// get additional information from DB
	1791	else
	1792	{
	1793	accId = objmgr.GetPlayerAccountIdByGUID(targetGUID);
	1794	Player plr(m_session); // use current session for temporary load
	1795	plr.MinimalLoadFromDB(NULL, targetGUID);
	1796	money = plr.GetMoney();
	1797	total_player_time = plr.GetTotalPlayedTime();
	1798	level = plr.getLevel();
	1799	}
	1800
[44]	1801	std::string username = GetTrinityString(LANG_ERROR);
	1802	std::string last_ip = GetTrinityString(LANG_ERROR);
[37]	1803	uint32 security = 0;
[44]	1804	std::string last_login = GetTrinityString(LANG_ERROR);
[37]	1805
	1806	QueryResult* result = loginDatabase.PQuery("SELECT username,gmlevel,last_ip,last_login FROM account WHERE id = '%u'",accId);
	1807	if(result)
	1808	{
	1809	Field* fields = result->Fetch();
	1810	username = fields[0].GetCppString();
	1811	security = fields[1].GetUInt32();
	1812	if(m_session->GetSecurity() >= security)
	1813	{
	1814	last_ip = fields[2].GetCppString();
	1815	last_login = fields[3].GetCppString();
	1816	}
	1817	else
	1818	{
	1819	last_ip = "-";
	1820	last_login = "-";
	1821	}
	1822
	1823	delete result;
	1824	}
	1825
[44]	1826	PSendSysMessage(LANG_PINFO_ACCOUNT, (target?"":GetTrinityString(LANG_OFFLINE)), name.c_str(), GUID_LOPART(targetGUID), username.c_str(), accId, security, last_ip.c_str(), last_login.c_str(), latency);
[37]	1827
	1828	std::string timeStr = secsToTimeString(total_player_time,true,true);
	1829	uint32 gold = money /GOLD;
	1830	uint32 silv = (money % GOLD) / SILVER;
	1831	uint32 copp = (money % GOLD) % SILVER;
	1832	PSendSysMessage(LANG_PINFO_LEVEL, timeStr.c_str(), level, gold,silv,copp );
	1833
	1834	if ( py && strncmp(py, "rep", 3) == 0 )
	1835	{
	1836	if(!target)
	1837	{
	1838	// rep option not implemented for offline case
	1839	SendSysMessage(LANG_PINFO_NO_REP);
	1840	SetSentErrorMessage(true);
	1841	return false;
	1842	}
	1843
	1844	char* FactionName;
	1845	for(FactionStateList::const_iterator itr = target->m_factions.begin(); itr != target->m_factions.end(); ++itr)
	1846	{
	1847	FactionEntry const *factionEntry = sFactionStore.LookupEntry(itr->second.ID);
	1848	if (factionEntry)
	1849	FactionName = factionEntry->name[m_session->GetSessionDbcLocale()];
	1850	else
	1851	FactionName = "#Not found#";
	1852	ReputationRank rank = target->GetReputationRank(factionEntry);
[44]	1853	std::string rankName = GetTrinityString(ReputationRankStrIndex[rank]);
[37]	1854	std::ostringstream ss;
	1855	ss << itr->second.ID << ": \|cffffffff\|Hfaction:" << itr->second.ID << "\|h[" << FactionName << "]\|h\|r " << rankName << "\|h\|r (" << target->GetReputation(factionEntry) << ")";
	1856
	1857	if(itr->second.Flags & FACTION_FLAG_VISIBLE)
[44]	1858	ss << GetTrinityString(LANG_FACTION_VISIBLE);
[37]	1859	if(itr->second.Flags & FACTION_FLAG_AT_WAR)
[44]	1860	ss << GetTrinityString(LANG_FACTION_ATWAR);
[37]	1861	if(itr->second.Flags & FACTION_FLAG_PEACE_FORCED)
[44]	1862	ss << GetTrinityString(LANG_FACTION_PEACE_FORCED);
[37]	1863	if(itr->second.Flags & FACTION_FLAG_HIDDEN)
[44]	1864	ss << GetTrinityString(LANG_FACTION_HIDDEN);
[37]	1865	if(itr->second.Flags & FACTION_FLAG_INVISIBLE_FORCED)
[44]	1866	ss << GetTrinityString(LANG_FACTION_INVISIBLE_FORCED);
[37]	1867	if(itr->second.Flags & FACTION_FLAG_INACTIVE)
[44]	1868	ss << GetTrinityString(LANG_FACTION_INACTIVE);
[37]	1869
	1870	SendSysMessage(ss.str().c_str());
	1871	}
	1872	}
	1873	return true;
	1874	}
	1875
	1876	//show tickets
	1877	void ChatHandler::ShowTicket(uint64 guid, char const* text, char const* time)
	1878	{
	1879	std::string name;
	1880	if(!objmgr.GetPlayerNameByGUID(guid,name))
[44]	1881	name = GetTrinityString(LANG_UNKNOWN);
[37]	1882
	1883	PSendSysMessage(LANG_COMMAND_TICKETVIEW, name.c_str(),time,text);
	1884	}
	1885
	1886	//ticket commands
	1887	bool ChatHandler::HandleTicketCommand(const char* args)
	1888	{
	1889	char* px = strtok((char*)args, " ");
	1890
	1891	// ticket<end>
	1892	if (!px)
	1893	{
	1894	size_t count;
	1895	QueryResult *result = CharacterDatabase.Query("SELECT COUNT(ticket_id) FROM character_ticket");
	1896	if(result)
	1897	{
	1898	count = (*result)[0].GetUInt32();
	1899	delete result;
	1900	}
	1901	else
	1902	count = 0;
	1903
[44]	1904	PSendSysMessage(LANG_COMMAND_TICKETCOUNT, count, m_session->GetPlayer()->isAcceptTickets() ? GetTrinityString(LANG_ON) : GetTrinityString(LANG_OFF));
[37]	1905	return true;
	1906	}
	1907
	1908	// ticket on
	1909	if(strncmp(px,"on",3) == 0)
	1910	{
	1911	m_session->GetPlayer()->SetAcceptTicket(true);
	1912	SendSysMessage(LANG_COMMAND_TICKETON);
	1913	return true;
	1914	}
	1915
	1916	// ticket off
	1917	if(strncmp(px,"off",4) == 0)
	1918	{
	1919	m_session->GetPlayer()->SetAcceptTicket(false);
	1920	SendSysMessage(LANG_COMMAND_TICKETOFF);
	1921	return true;
	1922	}
	1923
	1924	// ticket #num
	1925	int num = atoi(px);
	1926	if(num > 0)
	1927	{
	1928	QueryResult *result = CharacterDatabase.PQuery("SELECT guid,ticket_text,ticket_lastchange FROM character_ticket ORDER BY ticket_id ASC LIMIT %d,1",num-1);
	1929
	1930	if(!result)
	1931	{
	1932	PSendSysMessage(LANG_COMMAND_TICKENOTEXIST, num);
	1933	delete result;
	1934	SetSentErrorMessage(true);
	1935	return false;
	1936	}
	1937
	1938	Field* fields = result->Fetch();
	1939
	1940	uint64 guid = fields[0].GetUInt64();
	1941	char const* text = fields[1].GetString();
	1942	char const* time = fields[2].GetString();
	1943
	1944	ShowTicket(guid,text,time);
	1945	delete result;
	1946	return true;
	1947	}
	1948
	1949	std::string name = px;
	1950
	1951	if(!normalizePlayerName(name))
	1952	{
	1953	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	1954	SetSentErrorMessage(true);
	1955	return false;
	1956	}
	1957
	1958	uint64 guid = objmgr.GetPlayerGUIDByName(name);
	1959
	1960	if(!guid)
	1961	return false;
	1962
	1963	// ticket $char_name
	1964	QueryResult *result = CharacterDatabase.PQuery("SELECT ticket_text,ticket_lastchange FROM character_ticket WHERE guid = '%u' ORDER BY ticket_id ASC",GUID_LOPART(guid));
	1965
	1966	if(!result)
	1967	return false;
	1968
	1969	Field* fields = result->Fetch();
	1970
	1971	char const* text = fields[0].GetString();
	1972	char const* time = fields[1].GetString();
	1973
	1974	ShowTicket(guid,text,time);
	1975	delete result;
	1976
	1977	return true;
	1978	}
	1979
	1980	uint32 ChatHandler::GetTicketIDByNum(uint32 num)
	1981	{
	1982	QueryResult *result = CharacterDatabase.Query("SELECT ticket_id FROM character_ticket");
	1983
	1984	if(!result \|\| num > result->GetRowCount())
	1985	{
	1986	PSendSysMessage(LANG_COMMAND_TICKENOTEXIST, num);
	1987	delete result;
	1988	return 0;
	1989	}
	1990
	1991	for(uint32 i = 1; i < num; ++i)
	1992	result->NextRow();
	1993
	1994	Field* fields = result->Fetch();
	1995
	1996	uint32 id = fields[0].GetUInt32();
	1997	delete result;
	1998	return id;
	1999	}
	2000
	2001	//dell all tickets
	2002	bool ChatHandler::HandleDelTicketCommand(const char *args)
	2003	{
	2004	char* px = strtok((char*)args, " ");
	2005	if (!px)
	2006	return false;
	2007
	2008	// delticket all
	2009	if(strncmp(px,"all",4) == 0)
	2010	{
	2011	QueryResult *result = CharacterDatabase.Query("SELECT guid FROM character_ticket");
	2012
	2013	if(!result)
	2014	return true;
	2015
	2016	// notify players about ticket deleting
	2017	do
	2018	{
	2019	Field* fields = result->Fetch();
	2020
	2021	uint64 guid = fields[0].GetUInt64();
	2022
	2023	if(Player* sender = objmgr.GetPlayer(guid))
	2024	sender->GetSession()->SendGMTicketGetTicket(0x0A,0);
	2025
	2026	}while(result->NextRow());
	2027
	2028	delete result;
	2029
	2030	CharacterDatabase.PExecute("DELETE FROM character_ticket");
	2031	SendSysMessage(LANG_COMMAND_ALLTICKETDELETED);
	2032	return true;
	2033	}
	2034
	2035	int num = (uint32)atoi(px);
	2036
	2037	// delticket #num
	2038	if(num > 0)
	2039	{
	2040	QueryResult *result = CharacterDatabase.PQuery("SELECT ticket_id,guid FROM character_ticket LIMIT %i",num);
	2041
	2042	if(!result \|\| uint64(num) > result->GetRowCount())
	2043	{
	2044	PSendSysMessage(LANG_COMMAND_TICKENOTEXIST, num);
	2045	delete result;
	2046	SetSentErrorMessage(true);
	2047	return false;
	2048	}
	2049
	2050	for(int i = 1; i < num; ++i)
	2051	result->NextRow();
	2052
	2053	Field* fields = result->Fetch();
	2054
	2055	uint32 id = fields[0].GetUInt32();
	2056	uint64 guid = fields[1].GetUInt64();
	2057	delete result;
	2058
	2059	CharacterDatabase.PExecute("DELETE FROM character_ticket WHERE ticket_id = '%u'", id);
	2060
	2061	// notify players about ticket deleting
	2062	if(Player* sender = objmgr.GetPlayer(guid))
	2063	{
	2064	sender->GetSession()->SendGMTicketGetTicket(0x0A,0);
	2065	PSendSysMessage(LANG_COMMAND_TICKETPLAYERDEL,sender->GetName());
	2066	}
	2067	else
	2068	SendSysMessage(LANG_COMMAND_TICKETDEL);
	2069
	2070	return true;
	2071	}
	2072
	2073	std::string name = px;
	2074
	2075	if(!normalizePlayerName(name))
	2076	{
	2077	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	2078	SetSentErrorMessage(true);
	2079	return false;
	2080	}
	2081
	2082	uint64 guid = objmgr.GetPlayerGUIDByName(name);
	2083
	2084	if(!guid)
	2085	return false;
	2086
	2087	// delticket $char_name
	2088	CharacterDatabase.PExecute("DELETE FROM character_ticket WHERE guid = '%u'",GUID_LOPART(guid));
	2089
	2090	// notify players about ticket deleting
	2091	if(Player* sender = objmgr.GetPlayer(guid))
	2092	sender->GetSession()->SendGMTicketGetTicket(0x0A,0);
	2093
	2094	PSendSysMessage(LANG_COMMAND_TICKETPLAYERDEL,px);
	2095	return true;
	2096	}
	2097
	2098	//set spawn dist of creature
	2099	bool ChatHandler::HandleSpawnDistCommand(const char* args)
	2100	{
	2101	if(!*args)
	2102	return false;
	2103
	2104	float option = atof((char*)args);
	2105	if (option < 0.0f)
	2106	{
	2107	SendSysMessage(LANG_BAD_VALUE);
	2108	return false;
	2109	}
	2110
	2111	MovementGeneratorType mtype = IDLE_MOTION_TYPE;
	2112	if (option >0.0f)
	2113	mtype = RANDOM_MOTION_TYPE;
	2114
	2115	Creature *pCreature = getSelectedCreature();
	2116	uint32 u_guidlow = 0;
	2117
	2118	if (pCreature)
	2119	u_guidlow = pCreature->GetDBTableGUIDLow();
	2120	else
	2121	return false;
	2122
	2123	pCreature->SetRespawnRadius((float)option);
	2124	pCreature->SetDefaultMovementType(mtype);
	2125	pCreature->GetMotionMaster()->Initialize();
	2126	if(pCreature->isAlive()) // dead creature will reset movement generator at respawn
	2127	{
	2128	pCreature->setDeathState(JUST_DIED);
	2129	pCreature->Respawn();
	2130	}
	2131
	2132	WorldDatabase.PExecuteLog("UPDATE creature SET spawndist=%f, MovementType=%i WHERE guid=%u",option,mtype,u_guidlow);
	2133	PSendSysMessage(LANG_COMMAND_SPAWNDIST,option);
	2134	return true;
	2135	}
	2136
	2137	bool ChatHandler::HandleSpawnTimeCommand(const char* args)
	2138	{
	2139	if(!*args)
	2140	return false;
	2141
	2142	char* stime = strtok((char*)args, " ");
	2143
	2144	if (!stime)
	2145	return false;
	2146
	2147	int i_stime = atoi((char*)stime);
	2148
	2149	if (i_stime < 0)
	2150	{
	2151	SendSysMessage(LANG_BAD_VALUE);
	2152	SetSentErrorMessage(true);
	2153	return false;
	2154	}
	2155
	2156	Creature *pCreature = getSelectedCreature();
	2157	uint32 u_guidlow = 0;
	2158
	2159	if (pCreature)
	2160	u_guidlow = pCreature->GetDBTableGUIDLow();
	2161	else
	2162	return false;
	2163
	2164	WorldDatabase.PExecuteLog("UPDATE creature SET spawntimesecs=%i WHERE guid=%u",i_stime,u_guidlow);
	2165	pCreature->SetRespawnDelay((uint32)i_stime);
	2166	PSendSysMessage(LANG_COMMAND_SPAWNTIME,i_stime);
	2167
	2168	return true;
	2169	}
	2170
	2171	/**
	2172	* Add a waypoint to a creature.
	2173	*
	2174	* The user can either select an npc or provide its GUID.
	2175	*
	2176	* The user can even select a visual waypoint - then the new waypoint
	2177	* is placed after the selected one - this makes insertion of new
	2178	* waypoints possible.
	2179	*
	2180	* eg:
	2181	* .wp add 12345
	2182	* -> adds a waypoint to the npc with the GUID 12345
	2183	*
	2184	* .wp add
	2185	* -> adds a waypoint to the currently selected creature
	2186	*
	2187	*
	2188	* @param args if the user did not provide a GUID, it is NULL
	2189	*
	2190	* @return true - command did succeed, false - something went wrong
	2191	*/
	2192	bool ChatHandler::HandleWpAddCommand(const char* args)
	2193	{
	2194	sLog.outDebug("DEBUG: HandleWpAddCommand");
	2195
	2196	// optional
	2197	char* guid_str = NULL;
	2198
	2199	if(*args)
	2200	{
	2201	guid_str = strtok((char*)args, " ");
	2202	}
	2203
	2204	uint32 lowguid = 0;
	2205	uint32 point = 0;
	2206	Creature* target = getSelectedCreature();
	2207	// Did player provide a GUID?
	2208	if (!guid_str)
	2209	{
	2210	sLog.outDebug("DEBUG: HandleWpAddCommand - No GUID provided");
	2211
	2212	// No GUID provided
	2213	// -> Player must have selected a creature
	2214
[79]	2215	if(!target \|\| target->isPet())
[37]	2216	{
	2217	SendSysMessage(LANG_SELECT_CREATURE);
	2218	SetSentErrorMessage(true);
	2219	return false;
	2220	}
	2221	if (target->GetEntry() == VISUAL_WAYPOINT )
	2222	{
	2223	sLog.outDebug("DEBUG: HandleWpAddCommand - target->GetEntry() == VISUAL_WAYPOINT (1) ");
	2224
	2225	QueryResult *result =
	2226	WorldDatabase.PQuery( "SELECT id, point FROM creature_movement WHERE wpguid = %u",
	2227	target->GetGUIDLow() );
	2228	if(!result)
	2229	{
	2230	PSendSysMessage(LANG_WAYPOINT_NOTFOUNDSEARCH, target->GetGUIDLow());
	2231	// User selected a visual spawnpoint -> get the NPC
	2232	// Select NPC GUID
	2233	// Since we compare float values, we have to deal with
	2234	// some difficulties.
	2235	// Here we search for all waypoints that only differ in one from 1 thousand
	2236	// (0.001) - There is no other way to compare C++ floats with mySQL floats
	2237	// See also: http://dev.mysql.com/doc/refman/5.0/en/problems-with-float.html
	2238	const char* maxDIFF = "0.01";
	2239	result = WorldDatabase.PQuery( "SELECT id, point FROM creature_movement WHERE (abs(position_x - %f) <= %s ) and (abs(position_y - %f) <= %s ) and (abs(position_z - %f) <= %s )",
	2240	target->GetPositionX(), maxDIFF, target->GetPositionY(), maxDIFF, target->GetPositionZ(), maxDIFF);
	2241	if(!result)
	2242	{
	2243	PSendSysMessage(LANG_WAYPOINT_NOTFOUNDDBPROBLEM, target->GetGUIDLow());
	2244	SetSentErrorMessage(true);
	2245	return false;
	2246	}
	2247	}
	2248	do
	2249	{
	2250	Field *fields = result->Fetch();
	2251	lowguid = fields[0].GetUInt32();
	2252	point = fields[1].GetUInt32();
	2253	}while( result->NextRow() );
	2254	delete result;
	2255
	2256	CreatureData const* data = objmgr.GetCreatureData(lowguid);
	2257	if(!data)
	2258	{
	2259	PSendSysMessage(LANG_WAYPOINT_CREATNOTFOUND, lowguid);
	2260	SetSentErrorMessage(true);
	2261	return false;
	2262	}
	2263
	2264	target = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_NEW_GUID(lowguid,data->id,HIGHGUID_UNIT));
	2265	if(!target)
	2266	{
	2267	PSendSysMessage(LANG_WAYPOINT_NOTFOUNDDBPROBLEM, lowguid);
	2268	SetSentErrorMessage(true);
	2269	return false;
	2270	}
	2271	}
	2272	else
	2273	{
	2274	lowguid = target->GetDBTableGUIDLow();
	2275	}
	2276	}
	2277	else
	2278	{
	2279	sLog.outDebug("DEBUG: HandleWpAddCommand - GUID provided");
	2280
	2281	// GUID provided
	2282	// Warn if player also selected a creature
	2283	// -> Creature selection is ignored <-
	2284	if(target)
	2285	{
	2286	SendSysMessage(LANG_WAYPOINT_CREATSELECTED);
	2287	}
	2288	lowguid = atoi((char*)guid_str);
	2289
	2290	CreatureData const* data = objmgr.GetCreatureData(lowguid);
	2291	if(!data)
	2292	{
	2293	PSendSysMessage(LANG_WAYPOINT_CREATNOTFOUND, lowguid);
	2294	SetSentErrorMessage(true);
	2295	return false;
	2296	}
	2297
	2298	target = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_NEW_GUID(lowguid,data->id,HIGHGUID_UNIT));
[79]	2299	if(!target \|\| target->isPet())
[37]	2300	{
	2301	PSendSysMessage(LANG_WAYPOINT_CREATNOTFOUND, lowguid);
	2302	SetSentErrorMessage(true);
	2303	return false;
	2304	}
	2305	}
	2306	// lowguid -> GUID of the NPC
	2307	// point -> number of the waypoint (if not 0)
	2308	sLog.outDebug("DEBUG: HandleWpAddCommand - danach");
	2309
	2310	sLog.outDebug("DEBUG: HandleWpAddCommand - point == 0");
	2311
	2312	Player* player = m_session->GetPlayer();
	2313	WaypointMgr.AddLastNode(lowguid, player->GetPositionX(), player->GetPositionY(), player->GetPositionZ(), player->GetOrientation(), 0, 0);
	2314
	2315	// update movement type
	2316	if(target)
	2317	{
	2318	target->SetDefaultMovementType(WAYPOINT_MOTION_TYPE);
	2319	target->GetMotionMaster()->Initialize();
	2320	if(target->isAlive()) // dead creature will reset movement generator at respawn
	2321	{
	2322	target->setDeathState(JUST_DIED);
	2323	target->Respawn();
	2324	}
	2325	target->SaveToDB();
	2326	}
	2327	else
	2328	WorldDatabase.PExecuteLog("UPDATE creature SET MovementType = '%u' WHERE guid = '%u'", WAYPOINT_MOTION_TYPE,lowguid);
	2329
	2330	PSendSysMessage(LANG_WAYPOINT_ADDED, point, lowguid);
	2331
	2332	return true;
	2333	} // HandleWpAddCommand
	2334
	2335	/**
	2336	* .wp modify emote \| spell \| text \| del \| move \| add
	2337	*
	2338	* add -> add a WP after the selected visual waypoint
	2339	* User must select a visual waypoint and then issue ".wp modify add"
	2340	*
	2341	* emote <emoteID>
	2342	* User has selected a visual waypoint before.
	2343	* <emoteID> is added to this waypoint. Everytime the
	2344	* NPC comes to this waypoint, the emote is called.
	2345	*
	2346	* emote <GUID> <WPNUM> <emoteID>
	2347	* User has not selected visual waypoint before.
	2348	* For the waypoint <WPNUM> for the NPC with <GUID>
	2349	* an emote <emoteID> is added.
	2350	* Everytime the NPC comes to this waypoint, the emote is called.
	2351	*
	2352	*
	2353	* info <GUID> <WPNUM> -> User did not select a visual waypoint and
	2354	*/
	2355	bool ChatHandler::HandleWpModifyCommand(const char* args)
	2356	{
	2357	sLog.outDebug("DEBUG: HandleWpModifyCommand");
	2358
	2359	if(!*args)
	2360	return false;
	2361
	2362	// first arg: add del text emote spell waittime move
	2363	char* show_str = strtok((char*)args, " ");
	2364	if (!show_str)
	2365	{
	2366	return false;
	2367	}
	2368
	2369	std::string show = show_str;
	2370	// Check
	2371	// Remember: "show" must also be the name of a column!
	2372	if( (show != "emote") && (show != "spell") && (show != "text1") && (show != "text2")
	2373	&& (show != "text3") && (show != "text4") && (show != "text5")
	2374	&& (show != "waittime") && (show != "del") && (show != "move") && (show != "add")
	2375	&& (show != "model1") && (show != "model2") && (show != "orientation"))
	2376	{
	2377	return false;
	2378	}
	2379
	2380	// Next arg is: <GUID> <WPNUM> <ARGUMENT>
	2381
	2382	// Did user provide a GUID
	2383	// or did the user select a creature?
	2384	// -> variable lowguid is filled with the GUID of the NPC
	2385	uint32 lowguid = 0;
	2386	uint32 point = 0;
	2387	uint32 wpGuid = 0;
	2388	Creature* target = getSelectedCreature();
	2389
	2390	if(target)
	2391	{
	2392	sLog.outDebug("DEBUG: HandleWpModifyCommand - User did select an NPC");
	2393
	2394	// Did the user select a visual spawnpoint?
	2395	if (target->GetEntry() != VISUAL_WAYPOINT )
	2396	{
	2397	PSendSysMessage(LANG_WAYPOINT_VP_SELECT);
	2398	SetSentErrorMessage(true);
	2399	return false;
	2400	}
	2401
	2402	wpGuid = target->GetGUIDLow();
	2403
	2404	// The visual waypoint
	2405	QueryResult *result =
	2406	WorldDatabase.PQuery( "SELECT id, point FROM creature_movement WHERE wpguid = %u LIMIT 1",
	2407	target->GetGUIDLow() );
	2408	if(!result)
	2409	{
	2410	PSendSysMessage(LANG_WAYPOINT_NOTFOUNDDBPROBLEM, wpGuid);
	2411	SetSentErrorMessage(true);
	2412	return false;
	2413	}
	2414	sLog.outDebug("DEBUG: HandleWpModifyCommand - After getting wpGuid");
	2415
	2416	Field *fields = result->Fetch();
	2417	lowguid = fields[0].GetUInt32();
	2418	point = fields[1].GetUInt32();
	2419
	2420	// Cleanup memory
	2421	sLog.outDebug("DEBUG: HandleWpModifyCommand - Cleanup memory");
	2422	delete result;
	2423	}
	2424	else
	2425	{
	2426	// User did provide <GUID> <WPNUM>
	2427
	2428	char* guid_str = strtok((char*)NULL, " ");
	2429	if( !guid_str )
	2430	{
	2431	SendSysMessage(LANG_WAYPOINT_NOGUID);
	2432	return false;
	2433	}
	2434	lowguid = atoi((char*)guid_str);
	2435
	2436	CreatureData const* data = objmgr.GetCreatureData(lowguid);
	2437	if(!data)
	2438	{
	2439	PSendSysMessage(LANG_WAYPOINT_CREATNOTFOUND, lowguid);
	2440	SetSentErrorMessage(true);
	2441	return false;
	2442	}
	2443
	2444	PSendSysMessage("DEBUG: GUID provided: %d", lowguid);
	2445
	2446	char* point_str = strtok((char*)NULL, " ");
	2447	if( !point_str )
	2448	{
	2449	SendSysMessage(LANG_WAYPOINT_NOWAYPOINTGIVEN);
	2450	return false;
	2451	}
	2452	point = atoi((char*)point_str);
	2453
	2454	PSendSysMessage("DEBUG: wpNumber provided: %d", point);
	2455
	2456	// Now we need the GUID of the visual waypoint
	2457	// -> "del", "move", "add" command
	2458
	2459	QueryResult *result = WorldDatabase.PQuery( "SELECT wpguid FROM creature_movement WHERE id = '%u' AND point = '%u' LIMIT 1", lowguid, point);
	2460	if (!result)
	2461	{
	2462	PSendSysMessage(LANG_WAYPOINT_NOTFOUNDSEARCH, lowguid, point);
	2463	SetSentErrorMessage(true);
	2464	return false;
	2465	}
	2466
	2467	Field *fields = result->Fetch();
	2468	wpGuid = fields[0].GetUInt32();
	2469
	2470	// Free memory
	2471	delete result;
	2472	}
	2473
	2474	char* arg_str = NULL;
	2475	// Check for argument
	2476	if( (show.find("text") == std::string::npos ) && (show != "del") && (show != "move") && (show != "add"))
	2477	{
	2478	// Text is enclosed in "<>", all other arguments not
	2479	if( show.find("text") != std::string::npos )
	2480	arg_str = strtok((char*)NULL, "<>");
	2481	else
	2482	arg_str = strtok((char*)NULL, " ");
	2483
	2484	if( !arg_str)
	2485	{
	2486	PSendSysMessage(LANG_WAYPOINT_ARGUMENTREQ, show_str);
	2487	return false;
	2488	}
	2489	}
	2490
	2491	sLog.outDebug("DEBUG: HandleWpModifyCommand - Parameters parsed - now execute the command");
	2492
	2493	// wpGuid -> GUID of the waypoint creature
	2494	// lowguid -> GUID of the NPC
	2495	// point -> waypoint number
	2496
	2497	// Special functions:
	2498	// add - move - del -> no args commands
	2499	// Add a waypoint after the selected visual
	2500	if(show == "add" && target)
	2501	{
	2502	PSendSysMessage("DEBUG: wp modify add, GUID: %u", lowguid);
	2503
	2504	// Get the creature for which we read the waypoint
	2505	CreatureData const* data = objmgr.GetCreatureData(lowguid);
	2506	if(!data)
	2507	{
	2508	PSendSysMessage(LANG_WAYPOINT_CREATNOTFOUND, lowguid);
	2509	SetSentErrorMessage(true);
	2510	return false;
	2511	}
	2512
	2513	Creature* npcCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(), MAKE_NEW_GUID(lowguid, data->id, HIGHGUID_UNIT));
	2514
	2515	if( !npcCreature )
	2516	{
	2517	PSendSysMessage(LANG_WAYPOINT_NPCNOTFOUND);
	2518	SetSentErrorMessage(true);
	2519	return false;
	2520	}
	2521
	2522	sLog.outDebug("DEBUG: HandleWpModifyCommand - add -- npcCreature");
	2523
	2524	// What to do:
	2525	// Add the visual spawnpoint (DB only)
	2526	// Adjust the waypoints
	2527	// Respawn the owner of the waypoints
	2528	sLog.outDebug("DEBUG: HandleWpModifyCommand - add");
	2529
	2530	Player* chr = m_session->GetPlayer();
	2531	Map *map = chr->GetMap();
	2532
	2533	if(npcCreature)
	2534	{
	2535	npcCreature->GetMotionMaster()->Initialize();
	2536	if(npcCreature->isAlive()) // dead creature will reset movement generator at respawn
	2537	{
	2538	npcCreature->setDeathState(JUST_DIED);
	2539	npcCreature->Respawn();
	2540	}
	2541	}
	2542
	2543	// create the waypoint creature
	2544	wpGuid = 0;
	2545	Creature* wpCreature = new Creature;
	2546	if (!wpCreature->Create(objmgr.GenerateLowGuid(HIGHGUID_UNIT), map,VISUAL_WAYPOINT,0))
	2547	{
	2548	PSendSysMessage(LANG_WAYPOINT_VP_NOTCREATED, VISUAL_WAYPOINT);
	2549	delete wpCreature;
	2550	}
	2551	else
	2552	{
	2553	wpCreature->Relocate(chr->GetPositionX(), chr->GetPositionY(), chr->GetPositionZ(), chr->GetOrientation());
	2554
	2555	if(!wpCreature->IsPositionValid())
	2556	{
	2557	sLog.outError("ERROR: Creature (guidlow %d, entry %d) not created. Suggested coordinates isn't valid (X: %f Y: %f)",wpCreature->GetGUIDLow(),wpCreature->GetEntry(),wpCreature->GetPositionX(),wpCreature->GetPositionY());
	2558	delete wpCreature;
	2559	}
	2560	else
	2561	{
	2562	wpCreature->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()));
	2563	// To call _LoadGoods(); _LoadQuests(); CreateTrainerSpells();
	2564	wpCreature->LoadFromDB(wpCreature->GetDBTableGUIDLow(), map);
	2565	map->Add(wpCreature);
	2566	wpGuid = wpCreature->GetGUIDLow();
	2567	}
	2568	}
	2569
	2570	WaypointMgr.AddAfterNode(lowguid, point, chr->GetPositionX(), chr->GetPositionY(), chr->GetPositionZ(), 0, 0, wpGuid);
	2571
	2572	if(!wpGuid)
	2573	return false;
	2574
	2575	PSendSysMessage(LANG_WAYPOINT_ADDED_NO, point+1);
	2576	return true;
	2577	} // add
	2578
	2579	if(show == "del" && target)
	2580	{
	2581	PSendSysMessage("DEBUG: wp modify del, GUID: %u", lowguid);
	2582
	2583	// Get the creature for which we read the waypoint
	2584	CreatureData const* data = objmgr.GetCreatureData(lowguid);
	2585	if(!data)
	2586	{
	2587	PSendSysMessage(LANG_WAYPOINT_CREATNOTFOUND, lowguid);
	2588	SetSentErrorMessage(true);
	2589	return false;
	2590	}
	2591
	2592	Creature* npcCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(), MAKE_NEW_GUID(lowguid, data->id, HIGHGUID_UNIT));
	2593
	2594	// wpCreature
	2595	Creature* wpCreature = NULL;
	2596	if( wpGuid != 0 )
	2597	{
	2598	wpCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_NEW_GUID(wpGuid, VISUAL_WAYPOINT, HIGHGUID_UNIT));
	2599	wpCreature->DeleteFromDB();
	2600	wpCreature->CleanupsBeforeDelete();
	2601	wpCreature->AddObjectToRemoveList();
	2602	}
	2603
	2604	// What to do:
	2605	// Remove the visual spawnpoint
	2606	// Adjust the waypoints
	2607	// Respawn the owner of the waypoints
	2608
	2609	WaypointMgr.DeleteNode(lowguid, point);
	2610
	2611	if(npcCreature)
	2612	{
	2613	// Any waypoints left?
	2614	QueryResult *result2 = WorldDatabase.PQuery( "SELECT point FROM creature_movement WHERE id = '%u'",lowguid);
	2615	if(!result2)
	2616	{
	2617	npcCreature->SetDefaultMovementType(RANDOM_MOTION_TYPE);
	2618	}
	2619	else
	2620	{
	2621	npcCreature->SetDefaultMovementType(WAYPOINT_MOTION_TYPE);
	2622	delete result2;
	2623	}
	2624	npcCreature->GetMotionMaster()->Initialize();
	2625	if(npcCreature->isAlive()) // dead creature will reset movement generator at respawn
	2626	{
	2627	npcCreature->setDeathState(JUST_DIED);
	2628	npcCreature->Respawn();
	2629	}
	2630	npcCreature->SaveToDB();
	2631	}
	2632
	2633	PSendSysMessage(LANG_WAYPOINT_REMOVED);
	2634	return true;
	2635	} // del
	2636
	2637	if(show == "move" && target)
	2638	{
	2639	PSendSysMessage("DEBUG: wp move, GUID: %u", lowguid);
	2640
	2641	Player *chr = m_session->GetPlayer();
	2642	Map *map = chr->GetMap();
	2643	{
	2644	// Get the creature for which we read the waypoint
	2645	CreatureData const* data = objmgr.GetCreatureData(lowguid);
	2646	if(!data)
	2647	{
	2648	PSendSysMessage(LANG_WAYPOINT_CREATNOTFOUND, lowguid);
	2649	SetSentErrorMessage(true);
	2650	return false;
	2651	}
	2652
	2653	Creature* npcCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(), MAKE_NEW_GUID(lowguid, data->id, HIGHGUID_UNIT));
	2654
	2655	// wpCreature
	2656	Creature* wpCreature = NULL;
	2657	// What to do:
	2658	// Move the visual spawnpoint
	2659	// Respawn the owner of the waypoints
	2660	if( wpGuid != 0 )
	2661	{
	2662	wpCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_NEW_GUID(wpGuid, VISUAL_WAYPOINT, HIGHGUID_UNIT));
	2663	wpCreature->DeleteFromDB();
	2664	wpCreature->CleanupsBeforeDelete();
	2665	wpCreature->AddObjectToRemoveList();
	2666	// re-create
	2667	Creature* wpCreature2 = new Creature;
	2668	if (!wpCreature2->Create(objmgr.GenerateLowGuid(HIGHGUID_UNIT), map, VISUAL_WAYPOINT, 0))
	2669	{
	2670	PSendSysMessage(LANG_WAYPOINT_VP_NOTCREATED, VISUAL_WAYPOINT);
	2671	delete wpCreature2;
	2672	return false;
	2673	}
	2674
	2675	wpCreature2->Relocate(chr->GetPositionX(), chr->GetPositionY(), chr->GetPositionZ(), chr->GetOrientation());
	2676
	2677	if(!wpCreature2->IsPositionValid())
	2678	{
	2679	sLog.outError("ERROR: Creature (guidlow %d, entry %d) not created. Suggested coordinates isn't valid (X: %f Y: %f)",wpCreature2->GetGUIDLow(),wpCreature2->GetEntry(),wpCreature2->GetPositionX(),wpCreature2->GetPositionY());
	2680	delete wpCreature2;
	2681	return false;
	2682	}
	2683
	2684	wpCreature2->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()));
	2685	// To call _LoadGoods(); _LoadQuests(); CreateTrainerSpells();
	2686	wpCreature2->LoadFromDB(wpCreature2->GetDBTableGUIDLow(), map);
	2687	map->Add(wpCreature2);
	2688	//MapManager::Instance().GetMap(npcCreature->GetMapId())->Add(wpCreature2);
	2689	}
	2690
	2691	WaypointMgr.SetNodePosition(lowguid, point, chr->GetPositionX(), chr->GetPositionY(), chr->GetPositionZ());
	2692
	2693	if(npcCreature)
	2694	{
	2695	npcCreature->GetMotionMaster()->Initialize();
	2696	if(npcCreature->isAlive()) // dead creature will reset movement generator at respawn
	2697	{
	2698	npcCreature->setDeathState(JUST_DIED);
	2699	npcCreature->Respawn();
	2700	}
	2701	}
	2702	PSendSysMessage(LANG_WAYPOINT_CHANGED);
	2703	}
	2704	return true;
	2705	} // move
	2706
	2707	// Create creature - npc that has the waypoint
	2708	CreatureData const* data = objmgr.GetCreatureData(lowguid);
	2709	if(!data)
	2710	{
	2711	PSendSysMessage(LANG_WAYPOINT_CREATNOTFOUND, lowguid);
	2712	SetSentErrorMessage(true);
	2713	return false;
	2714	}
	2715
	2716	WaypointMgr.SetNodeText(lowguid, point, show_str, arg_str);
	2717
	2718	Creature* npcCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(), MAKE_NEW_GUID(lowguid, data->id, HIGHGUID_UNIT));
	2719	if(npcCreature)
	2720	{
	2721	npcCreature->SetDefaultMovementType(WAYPOINT_MOTION_TYPE);
	2722	npcCreature->GetMotionMaster()->Initialize();
	2723	if(npcCreature->isAlive()) // dead creature will reset movement generator at respawn
	2724	{
	2725	npcCreature->setDeathState(JUST_DIED);
	2726	npcCreature->Respawn();
	2727	}
	2728	}
	2729	PSendSysMessage(LANG_WAYPOINT_CHANGED_NO, show_str);
	2730
	2731	return true;
	2732	}
	2733
	2734	/**
	2735	* .wp show info \| on \| off
	2736	*
	2737	* info -> User has selected a visual waypoint before
	2738	*
	2739	* info <GUID> <WPNUM> -> User did not select a visual waypoint and
	2740	* provided the GUID of the NPC and the number of
	2741	* the waypoint.
	2742	*
	2743	* on -> User has selected an NPC; all visual waypoints for this
	2744	* NPC are added to the world
	2745	*
	2746	* on <GUID> -> User did not select an NPC - instead the GUID of the
	2747	* NPC is provided. All visual waypoints for this NPC
	2748	* are added from the world.
	2749	*
	2750	* off -> User has selected an NPC; all visual waypoints for this
	2751	* NPC are removed from the world.
	2752	*
	2753	* on <GUID> -> User did not select an NPC - instead the GUID of the
	2754	* NPC is provided. All visual waypoints for this NPC
	2755	* are removed from the world.
	2756	*
	2757	*
	2758	*/
	2759	bool ChatHandler::HandleWpShowCommand(const char* args)
	2760	{
	2761	sLog.outDebug("DEBUG: HandleWpShowCommand");
	2762
	2763	if(!*args)
	2764	return false;
	2765
	2766	// first arg: on, off, first, last
	2767	char* show_str = strtok((char*)args, " ");
	2768	if (!show_str)
	2769	{
	2770	return false;
	2771	}
	2772	// second arg: GUID (optional, if a creature is selected)
	2773	char* guid_str = strtok((char*)NULL, " ");
	2774	sLog.outDebug("DEBUG: HandleWpShowCommand: show_str: %s guid_str: %s", show_str, guid_str);
	2775	//if (!guid_str) {
	2776	// return false;
	2777	//}
	2778
	2779	// Did user provide a GUID
	2780	// or did the user select a creature?
	2781	// -> variable lowguid is filled with the GUID
	2782	Creature* target = getSelectedCreature();
	2783	// Did player provide a GUID?
	2784	if (!guid_str)
	2785	{
	2786	sLog.outDebug("DEBUG: HandleWpShowCommand: !guid_str");
	2787	// No GUID provided
	2788	// -> Player must have selected a creature
	2789
	2790	if(!target)
	2791	{
	2792	SendSysMessage(LANG_SELECT_CREATURE);
	2793	SetSentErrorMessage(true);
	2794	return false;
	2795	}
	2796	}
	2797	else
	2798	{
	2799	sLog.outDebug("DEBUG: HandleWpShowCommand: GUID provided");
	2800	// GUID provided
	2801	// Warn if player also selected a creature
	2802	// -> Creature selection is ignored <-
	2803	if(target)
	2804	{
	2805	SendSysMessage(LANG_WAYPOINT_CREATSELECTED);
	2806	}
	2807
	2808	uint32 lowguid = atoi((char*)guid_str);
	2809
	2810	CreatureData const* data = objmgr.GetCreatureData(lowguid);
	2811	if(!data)
	2812	{
	2813	PSendSysMessage(LANG_WAYPOINT_CREATNOTFOUND, lowguid);
	2814	SetSentErrorMessage(true);
	2815	return false;
	2816	}
	2817
	2818	target = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_NEW_GUID(lowguid,data->id,HIGHGUID_UNIT));
	2819
	2820	if(!target)
	2821	{
	2822	PSendSysMessage(LANG_WAYPOINT_CREATNOTFOUND, lowguid);
	2823	SetSentErrorMessage(true);
	2824	return false;
	2825	}
	2826	}
	2827
	2828	uint32 lowguid = target->GetDBTableGUIDLow();
	2829
	2830	std::string show = show_str;
	2831	uint32 Maxpoint;
	2832
	2833	sLog.outDebug("DEBUG: HandleWpShowCommand: lowguid: %u", lowguid);
	2834
	2835	sLog.outDebug("DEBUG: HandleWpShowCommand: Habe creature: %ld", target );
	2836
	2837	sLog.outDebug("DEBUG: HandleWpShowCommand: wpshow - show: %s", show_str);
	2838	//PSendSysMessage("wpshow - show: %s", show);
	2839
	2840	// Show info for the selected waypoint
	2841	if(show == "info")
	2842	{
	2843	PSendSysMessage("DEBUG: wp info, GUID: %u", lowguid);
	2844
	2845	// Check if the user did specify a visual waypoint
	2846	if( target->GetEntry() != VISUAL_WAYPOINT )
	2847	{
	2848	PSendSysMessage(LANG_WAYPOINT_VP_SELECT);
	2849	SetSentErrorMessage(true);
	2850	return false;
	2851	}
	2852
	2853	//PSendSysMessage("wp on, GUID: %u", lowguid);
	2854
	2855	//pCreature->GetPositionX();
	2856
	2857	QueryResult *result =
	2858	WorldDatabase.PQuery( "SELECT id, point, waittime, emote, spell, text1, text2, text3, text4, text5, model1, model2 FROM creature_movement WHERE wpguid = %u",
	2859	target->GetGUID() );
	2860	if(!result)
	2861	{
	2862	// Since we compare float values, we have to deal with
	2863	// some difficulties.
	2864	// Here we search for all waypoints that only differ in one from 1 thousand
	2865	// (0.001) - There is no other way to compare C++ floats with mySQL floats
	2866	// See also: http://dev.mysql.com/doc/refman/5.0/en/problems-with-float.html
	2867	const char* maxDIFF = "0.01";
	2868	PSendSysMessage(LANG_WAYPOINT_NOTFOUNDSEARCH, target->GetGUID());
	2869
	2870	result = WorldDatabase.PQuery( "SELECT id, point, waittime, emote, spell, text1, text2, text3, text4, text5, model1, model2 FROM creature_movement WHERE (abs(position_x - %f) <= %s ) and (abs(position_y - %f) <= %s ) and (abs(position_z - %f) <= %s )",
	2871	target->GetPositionX(), maxDIFF, target->GetPositionY(), maxDIFF, target->GetPositionZ(), maxDIFF);
	2872	if(!result)
	2873	{
	2874	PSendSysMessage(LANG_WAYPOINT_NOTFOUNDDBPROBLEM, lowguid);
	2875	SetSentErrorMessage(true);
	2876	return false;
	2877	}
	2878	}
	2879	do
	2880	{
	2881	Field *fields = result->Fetch();
	2882	uint32 creGUID = fields[0].GetUInt32();
	2883	uint32 point = fields[1].GetUInt32();
	2884	int waittime = fields[2].GetUInt32();
	2885	uint32 emote = fields[3].GetUInt32();
	2886	uint32 spell = fields[4].GetUInt32();
	2887	const char * text1 = fields[5].GetString();
	2888	const char * text2 = fields[6].GetString();
	2889	const char * text3 = fields[7].GetString();
	2890	const char * text4 = fields[8].GetString();
	2891	const char * text5 = fields[9].GetString();
	2892	uint32 model1 = fields[10].GetUInt32();
	2893	uint32 model2 = fields[11].GetUInt32();
	2894
	2895	// Get the creature for which we read the waypoint
	2896	Creature* wpCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_NEW_GUID(creGUID,VISUAL_WAYPOINT,HIGHGUID_UNIT));
	2897
	2898	PSendSysMessage(LANG_WAYPOINT_INFO_TITLE, point, (wpCreature ? wpCreature->GetName() : "<not found>"), creGUID);
	2899	PSendSysMessage(LANG_WAYPOINT_INFO_WAITTIME, waittime);
	2900	PSendSysMessage(LANG_WAYPOINT_INFO_MODEL, 1, model1);
	2901	PSendSysMessage(LANG_WAYPOINT_INFO_MODEL, 2, model2);
	2902	PSendSysMessage(LANG_WAYPOINT_INFO_EMOTE, emote);
	2903	PSendSysMessage(LANG_WAYPOINT_INFO_SPELL, spell);
	2904	PSendSysMessage(LANG_WAYPOINT_INFO_TEXT, 1, text1);
	2905	PSendSysMessage(LANG_WAYPOINT_INFO_TEXT, 2, text2);
	2906	PSendSysMessage(LANG_WAYPOINT_INFO_TEXT, 3, text3);
	2907	PSendSysMessage(LANG_WAYPOINT_INFO_TEXT, 4, text4);
	2908	PSendSysMessage(LANG_WAYPOINT_INFO_TEXT, 5, text5);
	2909
	2910	}while( result->NextRow() );
	2911	// Cleanup memory
	2912	delete result;
	2913	return true;
	2914	}
	2915
	2916	if(show == "on")
	2917	{
	2918	PSendSysMessage("DEBUG: wp on, GUID: %u", lowguid);
	2919
	2920	QueryResult *result = WorldDatabase.PQuery( "SELECT point, position_x,position_y,position_z FROM creature_movement WHERE id = '%u'",lowguid);
	2921	if(!result)
	2922	{
	2923	PSendSysMessage(LANG_WAYPOINT_NOTFOUND, lowguid);
	2924	SetSentErrorMessage(true);
	2925	return false;
	2926	}
	2927	// Delete all visuals for this NPC
	2928	QueryResult *result2 = WorldDatabase.PQuery( "SELECT wpguid FROM creature_movement WHERE id = '%u' and wpguid <> 0", lowguid);
	2929	if(result2)
	2930	{
	2931	bool hasError = false;
	2932	do
	2933	{
	2934	Field *fields = result2->Fetch();
	2935	uint32 wpguid = fields[0].GetUInt32();
	2936	Creature* pCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_NEW_GUID(wpguid,VISUAL_WAYPOINT,HIGHGUID_UNIT));
	2937
	2938	if(!pCreature)
	2939	{
	2940	PSendSysMessage(LANG_WAYPOINT_NOTREMOVED, wpguid);
	2941	hasError = true;
	2942	WorldDatabase.PExecuteLog("DELETE FROM creature WHERE guid = '%u'", wpguid);
	2943	}
	2944	else
	2945	{
	2946	pCreature->DeleteFromDB();
	2947	pCreature->CleanupsBeforeDelete();
	2948	pCreature->AddObjectToRemoveList();
	2949	}
	2950
	2951	}while( result2->NextRow() );
	2952	delete result2;
	2953	if( hasError )
	2954	{
	2955	PSendSysMessage(LANG_WAYPOINT_TOOFAR1);
	2956	PSendSysMessage(LANG_WAYPOINT_TOOFAR2);
	2957	PSendSysMessage(LANG_WAYPOINT_TOOFAR3);
	2958	}
	2959	}
	2960
	2961	do
	2962	{
	2963	Field *fields = result->Fetch();
	2964	uint32 point = fields[0].GetUInt32();
	2965	float x = fields[1].GetFloat();
	2966	float y = fields[2].GetFloat();
	2967	float z = fields[3].GetFloat();
	2968
	2969	uint32 id = VISUAL_WAYPOINT;
	2970
	2971	Player *chr = m_session->GetPlayer();
	2972	Map *map = chr->GetMap();
	2973	float o = chr->GetOrientation();
	2974
	2975	Creature* wpCreature = new Creature;
	2976	if (!wpCreature->Create(objmgr.GenerateLowGuid(HIGHGUID_UNIT), map, id, 0))
	2977	{
	2978	PSendSysMessage(LANG_WAYPOINT_VP_NOTCREATED, id);
	2979	delete wpCreature;
	2980	delete result;
	2981	return false;
	2982	}
	2983
	2984	wpCreature->Relocate(x, y, z, o);
	2985
	2986	if(!wpCreature->IsPositionValid())
	2987	{
	2988	sLog.outError("ERROR: Creature (guidlow %d, entry %d) not created. Suggested coordinates isn't valid (X: %f Y: %f)",wpCreature->GetGUIDLow(),wpCreature->GetEntry(),wpCreature->GetPositionX(),wpCreature->GetPositionY());
	2989	delete wpCreature;
	2990	delete result;
	2991	return false;
	2992	}
	2993
	2994	wpCreature->SetVisibility(VISIBILITY_OFF);
	2995	sLog.outDebug("DEBUG: UPDATE creature_movement SET wpguid = '%u");
	2996	// set "wpguid" column to the visual waypoint
	2997	WorldDatabase.PExecuteLog("UPDATE creature_movement SET wpguid = '%u' WHERE id = '%u' and point = '%u'", wpCreature->GetGUIDLow(), lowguid, point);
	2998
	2999	wpCreature->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()));
	3000	// To call _LoadGoods(); _LoadQuests(); CreateTrainerSpells();
	3001	wpCreature->LoadFromDB(wpCreature->GetDBTableGUIDLow(),map);
	3002	map->Add(wpCreature);
	3003	//MapManager::Instance().GetMap(wpCreature->GetMapId())->Add(wpCreature);
	3004	}while( result->NextRow() );
	3005
	3006	// Cleanup memory
	3007	delete result;
	3008	return true;
	3009	}
	3010
	3011	if(show == "first")
	3012	{
	3013	PSendSysMessage("DEBUG: wp first, GUID: %u", lowguid);
	3014
	3015	QueryResult *result = WorldDatabase.PQuery( "SELECT position_x,position_y,position_z FROM creature_movement WHERE point='1' AND id = '%u'",lowguid);
	3016	if(!result)
	3017	{
	3018	PSendSysMessage(LANG_WAYPOINT_NOTFOUND, lowguid);
	3019	SetSentErrorMessage(true);
	3020	return false;
	3021	}
	3022
	3023	Field *fields = result->Fetch();
	3024	float x = fields[0].GetFloat();
	3025	float y = fields[1].GetFloat();
	3026	float z = fields[2].GetFloat();
	3027	uint32 id = VISUAL_WAYPOINT;
	3028
	3029	Player *chr = m_session->GetPlayer();
	3030	float o = chr->GetOrientation();
	3031	Map *map = chr->GetMap();
	3032
	3033	Creature* pCreature = new Creature;
	3034	if (!pCreature->Create(objmgr.GenerateLowGuid(HIGHGUID_UNIT),map, id, 0))
	3035	{
	3036	PSendSysMessage(LANG_WAYPOINT_VP_NOTCREATED, id);
	3037	delete pCreature;
	3038	delete result;
	3039	return false;
	3040	}
	3041
	3042	pCreature->Relocate(x, y, z, o);
	3043
	3044	if(!pCreature->IsPositionValid())
	3045	{
	3046	sLog.outError("ERROR: Creature (guidlow %d, entry %d) not created. Suggested coordinates isn't valid (X: %f Y: %f)",pCreature->GetGUIDLow(),pCreature->GetEntry(),pCreature->GetPositionX(),pCreature->GetPositionY());
	3047	delete pCreature;
	3048	delete result;
	3049	return false;
	3050	}
	3051
	3052	pCreature->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()));
	3053	pCreature->LoadFromDB(pCreature->GetDBTableGUIDLow(), map);
	3054	map->Add(pCreature);
	3055	//player->PlayerTalkClass->SendPointOfInterest(x, y, 6, 6, 0, "First Waypoint");
	3056
	3057	// Cleanup memory
	3058	delete result;
	3059	return true;
	3060	}
	3061
	3062	if(show == "last")
	3063	{
	3064	PSendSysMessage("DEBUG: wp last, GUID: %u", lowguid);
	3065
	3066	QueryResult *result = WorldDatabase.PQuery( "SELECT MAX(point) FROM creature_movement WHERE id = '%u'",lowguid);
	3067	if( result )
	3068	{
	3069	Maxpoint = (*result)[0].GetUInt32();
	3070
	3071	delete result;
	3072	}
	3073	else
	3074	Maxpoint = 0;
	3075
	3076	result = WorldDatabase.PQuery( "SELECT position_x,position_y,position_z FROM creature_movement WHERE point ='%u' AND id = '%u'",Maxpoint, lowguid);
	3077	if(!result)
	3078	{
	3079	PSendSysMessage(LANG_WAYPOINT_NOTFOUNDLAST, lowguid);
	3080	SetSentErrorMessage(true);
	3081	return false;
	3082	}
	3083	Field *fields = result->Fetch();
	3084	float x = fields[0].GetFloat();
	3085	float y = fields[1].GetFloat();
	3086	float z = fields[2].GetFloat();
	3087	uint32 id = VISUAL_WAYPOINT;
	3088
	3089	Player *chr = m_session->GetPlayer();
	3090	float o = chr->GetOrientation();
	3091	Map *map = chr->GetMap();
	3092
	3093	Creature* pCreature = new Creature;
	3094	if (!pCreature->Create(objmgr.GenerateLowGuid(HIGHGUID_UNIT), map, id, 0))
	3095	{
	3096	PSendSysMessage(LANG_WAYPOINT_NOTCREATED, id);
	3097	delete pCreature;
	3098	delete result;
	3099	return false;
	3100	}
	3101
	3102	pCreature->Relocate(x, y, z, o);
	3103
	3104	if(!pCreature->IsPositionValid())
	3105	{
	3106	sLog.outError("ERROR: Creature (guidlow %d, entry %d) not created. Suggested coordinates isn't valid (X: %f Y: %f)",pCreature->GetGUIDLow(),pCreature->GetEntry(),pCreature->GetPositionX(),pCreature->GetPositionY());
	3107	delete pCreature;
	3108	delete result;
	3109	return false;
	3110	}
	3111
	3112	pCreature->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()));
	3113	pCreature->LoadFromDB(pCreature->GetDBTableGUIDLow(), map);
	3114	map->Add(pCreature);
	3115	//player->PlayerTalkClass->SendPointOfInterest(x, y, 6, 6, 0, "Last Waypoint");
	3116	// Cleanup memory
	3117	delete result;
	3118	return true;
	3119	}
	3120
	3121	if(show == "off")
	3122	{
	3123	QueryResult *result = WorldDatabase.PQuery("SELECT guid FROM creature WHERE id = '%d'", VISUAL_WAYPOINT);
	3124	if(!result)
	3125	{
	3126	SendSysMessage(LANG_WAYPOINT_VP_NOTFOUND);
	3127	SetSentErrorMessage(true);
	3128	return false;
	3129	}
	3130	bool hasError = false;
	3131	do
	3132	{
	3133	Field *fields = result->Fetch();
	3134	uint32 guid = fields[0].GetUInt32();
	3135	Creature* pCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(),MAKE_NEW_GUID(guid,VISUAL_WAYPOINT,HIGHGUID_UNIT));
	3136
	3137	//Creature* pCreature = ObjectAccessor::GetCreature(*m_session->GetPlayer(), guid);
	3138
	3139	if(!pCreature)
	3140	{
	3141	PSendSysMessage(LANG_WAYPOINT_NOTREMOVED, guid);
	3142	hasError = true;
	3143	WorldDatabase.PExecuteLog("DELETE FROM creature WHERE guid = '%u'", guid);
	3144	}
	3145	else
	3146	{
	3147	pCreature->DeleteFromDB();
	3148	pCreature->CleanupsBeforeDelete();
	3149	pCreature->AddObjectToRemoveList();
	3150	}
	3151	}while(result->NextRow());
	3152	// set "wpguid" column to "empty" - no visual waypoint spawned
	3153	WorldDatabase.PExecuteLog("UPDATE creature_movement SET wpguid = '0'");
	3154
	3155	if( hasError )
	3156	{
	3157	PSendSysMessage(LANG_WAYPOINT_TOOFAR1);
	3158	PSendSysMessage(LANG_WAYPOINT_TOOFAR2);
	3159	PSendSysMessage(LANG_WAYPOINT_TOOFAR3);
	3160	}
	3161
	3162	SendSysMessage(LANG_WAYPOINT_VP_ALLREMOVED);
	3163	// Cleanup memory
	3164	delete result;
	3165
	3166	return true;
	3167	}
	3168
	3169	PSendSysMessage("DEBUG: wpshow - no valid command found");
	3170
	3171	return true;
	3172	} // HandleWpShowCommand
	3173
	3174	bool ChatHandler::HandleWpExportCommand(const char *args)
	3175	{
	3176	if(!*args)
	3177	return false;
	3178
	3179	// Next arg is: <GUID> <ARGUMENT>
	3180
	3181	// Did user provide a GUID
	3182	// or did the user select a creature?
	3183	// -> variable lowguid is filled with the GUID of the NPC
	3184	uint32 lowguid = 0;
	3185	Creature* target = getSelectedCreature();
	3186	char* arg_str = NULL;
	3187	if (target)
	3188	{
	3189	if (target->GetEntry() != VISUAL_WAYPOINT)
	3190	lowguid = target->GetGUIDLow();
	3191	else
	3192	{
	3193	QueryResult *result = WorldDatabase.PQuery( "SELECT id FROM creature_movement WHERE wpguid = %u LIMIT 1", target->GetGUIDLow() );
	3194	if (!result)
	3195	{
	3196	PSendSysMessage(LANG_WAYPOINT_NOTFOUNDDBPROBLEM, target->GetGUIDLow());
	3197	return true;
	3198	}
	3199	Field *fields = result->Fetch();
	3200	lowguid = fields[0].GetUInt32();;
	3201	delete result;
	3202	}
	3203
	3204	arg_str = strtok((char*)args, " ");
	3205	}
	3206	else
	3207	{
	3208	// user provided <GUID>
	3209	char* guid_str = strtok((char*)args, " ");
	3210	if( !guid_str )
	3211	{
	3212	SendSysMessage(LANG_WAYPOINT_NOGUID);
	3213	return false;
	3214	}
	3215	lowguid = atoi((char*)guid_str);
	3216
	3217	arg_str = strtok((char*)NULL, " ");
	3218	}
	3219
	3220	if( !arg_str)
	3221	{
	3222	PSendSysMessage(LANG_WAYPOINT_ARGUMENTREQ, "export");
	3223	return false;
	3224	}
	3225
	3226	PSendSysMessage("DEBUG: wp export, GUID: %u", lowguid);
	3227
	3228	QueryResult *result = WorldDatabase.PQuery(
	3229	// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
	3230	"SELECT point, position_x, position_y, position_z, orientation, model1, model2, waittime, emote, spell, text1, text2, text3, text4, text5, id FROM creature_movement WHERE id = '%u' ORDER BY point", lowguid );
	3231
	3232	if (!result)
	3233	{
	3234	PSendSysMessage(LANG_WAYPOINT_NOTHINGTOEXPORT);
	3235	SetSentErrorMessage(true);
	3236	return false;
	3237	}
	3238
	3239	std::ofstream outfile;
	3240	outfile.open (arg_str);
	3241
	3242	do
	3243	{
	3244	Field *fields = result->Fetch();
	3245
	3246	outfile << "INSERT INTO creature_movement ";
	3247	outfile << "( id, point, position_x, position_y, position_z, orientation, model1, model2, waittime, emote, spell, text1, text2, text3, text4, text5 ) VALUES ";
	3248
	3249	outfile << "( ";
	3250	outfile << fields[15].GetUInt32(); // id
	3251	outfile << ", ";
	3252	outfile << fields[0].GetUInt32(); // point
	3253	outfile << ", ";
	3254	outfile << fields[1].GetFloat(); // position_x
	3255	outfile << ", ";
	3256	outfile << fields[2].GetFloat(); // position_y
	3257	outfile << ", ";
	3258	outfile << fields[3].GetUInt32(); // position_z
	3259	outfile << ", ";
	3260	outfile << fields[4].GetUInt32(); // orientation
	3261	outfile << ", ";
	3262	outfile << fields[5].GetUInt32(); // model1
	3263	outfile << ", ";
	3264	outfile << fields[6].GetUInt32(); // model2
	3265	outfile << ", ";
	3266	outfile << fields[7].GetUInt16(); // waittime
	3267	outfile << ", ";
	3268	outfile << fields[8].GetUInt32(); // emote
	3269	outfile << ", ";
	3270	outfile << fields[9].GetUInt32(); // spell
	3271	outfile << ", ";
	3272	const char *tmpChar = fields[10].GetString();
	3273	if( !tmpChar )
	3274	{
	3275	outfile << "NULL"; // text1
	3276	}
	3277	else
	3278	{
	3279	outfile << "'";
	3280	outfile << tmpChar; // text1
	3281	outfile << "'";
	3282	}
	3283	outfile << ", ";
	3284	tmpChar = fields[11].GetString();
	3285	if( !tmpChar )
	3286	{
	3287	outfile << "NULL"; // text2
	3288	}
	3289	else
	3290	{
	3291	outfile << "'";
	3292	outfile << tmpChar; // text2
	3293	outfile << "'";
	3294	}
	3295	outfile << ", ";
	3296	tmpChar = fields[12].GetString();
	3297	if( !tmpChar )
	3298	{
	3299	outfile << "NULL"; // text3
	3300	}
	3301	else
	3302	{
	3303	outfile << "'";
	3304	outfile << tmpChar; // text3
	3305	outfile << "'";
	3306	}
	3307	outfile << ", ";
	3308	tmpChar = fields[13].GetString();
	3309	if( !tmpChar )
	3310	{
	3311	outfile << "NULL"; // text4
	3312	}
	3313	else
	3314	{
	3315	outfile << "'";
	3316	outfile << tmpChar; // text4
	3317	outfile << "'";
	3318	}
	3319	outfile << ", ";
	3320	tmpChar = fields[14].GetString();
	3321	if( !tmpChar )
	3322	{
	3323	outfile << "NULL"; // text5
	3324	}
	3325	else
	3326	{
	3327	outfile << "'";
	3328	outfile << tmpChar; // text5
	3329	outfile << "'";
	3330	}
	3331	outfile << ");\n ";
	3332
	3333	} while( result->NextRow() );
	3334	delete result;
	3335
	3336	PSendSysMessage(LANG_WAYPOINT_EXPORTED);
	3337	outfile.close();
	3338
	3339	return true;
	3340	}
	3341
	3342	bool ChatHandler::HandleWpImportCommand(const char *args)
	3343	{
	3344	if(!*args)
	3345	return false;
	3346
	3347	char* arg_str = strtok((char*)args, " ");
	3348	if (!arg_str)
	3349	return false;
	3350
	3351	std::string line;
	3352	std::ifstream infile (arg_str);
	3353	if (infile.is_open())
	3354	{
	3355	while (! infile.eof() )
	3356	{
	3357	getline (infile,line);
	3358	//cout << line << endl;
	3359	QueryResult *result = WorldDatabase.PQuery(line.c_str());
	3360	delete result;
	3361	}
	3362	infile.close();
	3363	}
	3364	PSendSysMessage(LANG_WAYPOINT_IMPORTED);
	3365
	3366	return true;
	3367	}
	3368
	3369	//rename characters
	3370	bool ChatHandler::HandleRenameCommand(const char* args)
	3371	{
	3372	Player* target = NULL;
	3373	uint64 targetGUID = 0;
	3374	std::string oldname;
	3375
	3376	char* px = strtok((char*)args, " ");
	3377
	3378	if(px)
	3379	{
	3380	oldname = px;
	3381
	3382	if(!normalizePlayerName(oldname))
	3383	{
	3384	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	3385	SetSentErrorMessage(true);
	3386	return false;
	3387	}
	3388
	3389	target = objmgr.GetPlayer(oldname.c_str());
	3390
	3391	if (!target)
	3392	targetGUID = objmgr.GetPlayerGUIDByName(oldname);
	3393	}
	3394
	3395	if(!target && !targetGUID)
	3396	{
	3397	target = getSelectedPlayer();
	3398	}
	3399
	3400	if(!target && !targetGUID)
	3401	{
	3402	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	3403	SetSentErrorMessage(true);
	3404	return false;
	3405	}
	3406
	3407	if(target)
	3408	{
	3409	PSendSysMessage(LANG_RENAME_PLAYER, target->GetName());
	3410	target->SetAtLoginFlag(AT_LOGIN_RENAME);
	3411	CharacterDatabase.PExecute("UPDATE characters SET at_login = at_login \| '1' WHERE guid = '%u'", target->GetGUIDLow());
	3412	}
	3413	else
	3414	{
	3415	PSendSysMessage(LANG_RENAME_PLAYER_GUID, oldname.c_str(), GUID_LOPART(targetGUID));
	3416	CharacterDatabase.PExecute("UPDATE characters SET at_login = at_login \| '1' WHERE guid = '%u'", GUID_LOPART(targetGUID));
	3417	}
	3418
	3419	return true;
	3420	}
	3421
	3422	//spawn go
	3423	bool ChatHandler::HandleGameObjectCommand(const char* args)
	3424	{
	3425	if (!*args)
	3426	return false;
	3427
	3428	char* pParam1 = strtok((char*)args, " ");
	3429	if (!pParam1)
	3430	return false;
	3431
	3432	uint32 id = atoi((char*)pParam1);
	3433	if(!id)
	3434	return false;
	3435
	3436	char* spawntimeSecs = strtok(NULL, " ");
	3437
	3438	const GameObjectInfo *goI = objmgr.GetGameObjectInfo(id);
	3439
	3440	if (!goI)
	3441	{
	3442	PSendSysMessage(LANG_GAMEOBJECT_NOT_EXIST,id);
	3443	SetSentErrorMessage(true);
	3444	return false;
	3445	}
	3446
	3447	Player *chr = m_session->GetPlayer();
	3448	float x = float(chr->GetPositionX());
	3449	float y = float(chr->GetPositionY());
	3450	float z = float(chr->GetPositionZ());
	3451	float o = float(chr->GetOrientation());
	3452	Map *map = chr->GetMap();
	3453
	3454	float rot2 = sin(o/2);
	3455	float rot3 = cos(o/2);
	3456
	3457	GameObject* pGameObj = new GameObject;
	3458	uint32 db_lowGUID = objmgr.GenerateLowGuid(HIGHGUID_GAMEOBJECT);
	3459
	3460	if(!pGameObj->Create(db_lowGUID, goI->id, map, x, y, z, o, 0, 0, rot2, rot3, 0, 1))
	3461	{
	3462	delete pGameObj;
	3463	return false;
	3464	}
	3465
	3466	if( spawntimeSecs )
	3467	{
	3468	uint32 value = atoi((char*)spawntimeSecs);
	3469	pGameObj->SetRespawnTime(value);
	3470	//sLog.outDebug("*** spawntimeSecs: %d", value);
	3471	}
	3472
	3473	// fill the gameobject data and save to the db
	3474	pGameObj->SaveToDB(map->GetId(), (1 << map->GetSpawnMode()));
	3475
	3476	// this will generate a new guid if the object is in an instance
	3477	if(!pGameObj->LoadFromDB(db_lowGUID, map))
	3478	{
	3479	delete pGameObj;
	3480	return false;
	3481	}
	3482
[44]	3483	sLog.outDebug(GetTrinityString(LANG_GAMEOBJECT_CURRENT), goI->name, db_lowGUID, x, y, z, o);
[37]	3484
	3485	map->Add(pGameObj);
	3486
	3487	// TODO: is it really necessary to add both the real and DB table guid here ?
	3488	objmgr.AddGameobjectToGrid(db_lowGUID, objmgr.GetGOData(db_lowGUID));
	3489
	3490	PSendSysMessage(LANG_GAMEOBJECT_ADD,id,goI->name,db_lowGUID,x,y,z);
	3491	return true;
	3492	}
	3493
	3494	//show animation
	3495	bool ChatHandler::HandleAnimCommand(const char* args)
	3496	{
	3497	if (!*args)
	3498	return false;
	3499
	3500	uint32 anim_id = atoi((char*)args);
	3501	m_session->GetPlayer()->HandleEmoteCommand(anim_id);
	3502	return true;
	3503	}
	3504
	3505	//change standstate
	3506	bool ChatHandler::HandleStandStateCommand(const char* args)
	3507	{
	3508	if (!*args)
	3509	return false;
	3510
	3511	uint32 anim_id = atoi((char*)args);
	3512	m_session->GetPlayer( )->SetUInt32Value( UNIT_NPC_EMOTESTATE , anim_id );
	3513
	3514	return true;
	3515	}
	3516
	3517	bool ChatHandler::HandleAddHonorCommand(const char* args)
	3518	{
	3519	if (!*args)
	3520	return false;
	3521
	3522	Player *target = getSelectedPlayer();
	3523	if(!target)
	3524	{
	3525	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	3526	SetSentErrorMessage(true);
	3527	return false;
	3528	}
	3529
	3530	uint32 amount = (uint32)atoi(args);
	3531	target->RewardHonor(NULL, 1, amount);
	3532	return true;
	3533	}
	3534
	3535	bool ChatHandler::HandleHonorAddKillCommand(const char* /args/)
	3536	{
	3537	Unit *target = getSelectedUnit();
	3538	if(!target)
	3539	{
	3540	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	3541	SetSentErrorMessage(true);
	3542	return false;
	3543	}
	3544
	3545	m_session->GetPlayer()->RewardHonor(target, 1);
	3546	return true;
	3547	}
	3548
	3549	bool ChatHandler::HandleUpdateHonorFieldsCommand(const char* /args/)
	3550	{
	3551	Player *target = getSelectedPlayer();
	3552	if(!target)
	3553	{
	3554	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	3555	SetSentErrorMessage(true);
	3556	return false;
	3557	}
	3558
	3559	target->UpdateHonorFields();
	3560	return true;
	3561	}
	3562
	3563	bool ChatHandler::HandleLookupEventCommand(const char* args)
	3564	{
	3565	if(!*args)
	3566	return false;
	3567
	3568	std::string namepart = args;
	3569	std::wstring wnamepart;
	3570
	3571	// converting string that we try to find to lower case
	3572	if(!Utf8toWStr(namepart,wnamepart))
	3573	return false;
	3574
	3575	wstrToLower(wnamepart);
	3576
	3577	uint32 counter = 0;
	3578
	3579	GameEvent::GameEventDataMap const& events = gameeventmgr.GetEventMap();
	3580	GameEvent::ActiveEvents const& activeEvents = gameeventmgr.GetActiveEventList();
	3581
	3582	for(uint32 id = 0; id < events.size(); ++id )
	3583	{
	3584	GameEventData const& eventData = events[id];
	3585
	3586	std::string descr = eventData.description;
	3587	if(descr.empty())
	3588	continue;
	3589
	3590	if (Utf8FitTo(descr, wnamepart))
	3591	{
[44]	3592	char const* active = activeEvents.find(id) != activeEvents.end() ? GetTrinityString(LANG_ACTIVE) : "";
[37]	3593	PSendSysMessage(LANG_EVENT_ENTRY_LIST,id,id,descr.c_str(),active );
	3594	++counter;
	3595	}
	3596	}
	3597
	3598	if (counter==0)
	3599	SendSysMessage(LANG_NOEVENTFOUND);
	3600
	3601	return true;
	3602	}
	3603
	3604	bool ChatHandler::HandleEventActiveListCommand(const char* args)
	3605	{
	3606	uint32 counter = 0;
	3607
	3608	GameEvent::GameEventDataMap const& events = gameeventmgr.GetEventMap();
	3609	GameEvent::ActiveEvents const& activeEvents = gameeventmgr.GetActiveEventList();
	3610
[44]	3611	char const* active = GetTrinityString(LANG_ACTIVE);
[37]	3612
	3613	for(GameEvent::ActiveEvents::const_iterator itr = activeEvents.begin(); itr != activeEvents.end(); ++itr )
	3614	{
	3615	uint32 event_id = *itr;
	3616	GameEventData const& eventData = events[event_id];
	3617
	3618	PSendSysMessage(LANG_EVENT_ENTRY_LIST,event_id,event_id,eventData.description.c_str(),active );
	3619	++counter;
	3620	}
	3621
	3622	if (counter==0)
	3623	SendSysMessage(LANG_NOEVENTFOUND);
	3624
	3625	return true;
	3626	}
	3627
	3628	bool ChatHandler::HandleEventInfoCommand(const char* args)
	3629	{
	3630	if(!*args)
	3631	return false;
	3632
	3633	// id or [name] Shift-click form \|color\|Hgameevent:id\|h[name]\|h\|r
	3634	char* cId = extractKeyFromLink((char*)args,"Hgameevent");
	3635	if(!cId)
	3636	return false;
	3637
	3638	uint32 event_id = atoi(cId);
	3639
	3640	GameEvent::GameEventDataMap const& events = gameeventmgr.GetEventMap();
	3641
	3642	if(event_id >=events.size())
	3643	{
	3644	SendSysMessage(LANG_EVENT_NOT_EXIST);
	3645	SetSentErrorMessage(true);
	3646	return false;
	3647	}
	3648
	3649	GameEventData const& eventData = events[event_id];
	3650	if(!eventData.isValid())
	3651	{
	3652	SendSysMessage(LANG_EVENT_NOT_EXIST);
	3653	SetSentErrorMessage(true);
	3654	return false;
	3655	}
	3656
	3657	GameEvent::ActiveEvents const& activeEvents = gameeventmgr.GetActiveEventList();
	3658	bool active = activeEvents.find(event_id) != activeEvents.end();
[44]	3659	char const* activeStr = active ? GetTrinityString(LANG_ACTIVE) : "";
[37]	3660
	3661	std::string startTimeStr = TimeToTimestampStr(eventData.start);
	3662	std::string endTimeStr = TimeToTimestampStr(eventData.end);
	3663
	3664	uint32 delay = gameeventmgr.NextCheck(event_id);
	3665	time_t nextTime = time(NULL)+delay;
	3666	std::string nextStr = nextTime >= eventData.start && nextTime < eventData.end ? TimeToTimestampStr(time(NULL)+delay) : "-";
	3667
	3668	std::string occurenceStr = secsToTimeString(eventData.occurence * MINUTE);
	3669	std::string lengthStr = secsToTimeString(eventData.length * MINUTE);
	3670
	3671	PSendSysMessage(LANG_EVENT_INFO,event_id,eventData.description.c_str(),activeStr,
	3672	startTimeStr.c_str(),endTimeStr.c_str(),occurenceStr.c_str(),lengthStr.c_str(),
	3673	nextStr.c_str());
	3674	return true;
	3675	}
	3676
	3677	bool ChatHandler::HandleEventStartCommand(const char* args)
	3678	{
	3679	if(!*args)
	3680	return false;
	3681
	3682	// id or [name] Shift-click form \|color\|Hgameevent:id\|h[name]\|h\|r
	3683	char* cId = extractKeyFromLink((char*)args,"Hgameevent");
	3684	if(!cId)
	3685	return false;
	3686
	3687	int32 event_id = atoi(cId);
	3688
	3689	GameEvent::GameEventDataMap const& events = gameeventmgr.GetEventMap();
	3690
	3691	if(event_id < 1 \|\| event_id >=events.size())
	3692	{
	3693	SendSysMessage(LANG_EVENT_NOT_EXIST);
	3694	SetSentErrorMessage(true);
	3695	return false;
	3696	}
	3697
	3698	GameEventData const& eventData = events[event_id];
	3699	if(!eventData.isValid())
	3700	{
	3701	SendSysMessage(LANG_EVENT_NOT_EXIST);
	3702	SetSentErrorMessage(true);
	3703	return false;
	3704	}
	3705
	3706	GameEvent::ActiveEvents const& activeEvents = gameeventmgr.GetActiveEventList();
	3707	if(activeEvents.find(event_id) != activeEvents.end())
	3708	{
	3709	PSendSysMessage(LANG_EVENT_ALREADY_ACTIVE,event_id);
	3710	SetSentErrorMessage(true);
	3711	return false;
	3712	}
	3713
	3714	gameeventmgr.StartEvent(event_id,true);
	3715	return true;
	3716	}
	3717
	3718	bool ChatHandler::HandleEventStopCommand(const char* args)
	3719	{
	3720	if(!*args)
	3721	return false;
	3722
	3723	// id or [name] Shift-click form \|color\|Hgameevent:id\|h[name]\|h\|r
	3724	char* cId = extractKeyFromLink((char*)args,"Hgameevent");
	3725	if(!cId)
	3726	return false;
	3727
	3728	int32 event_id = atoi(cId);
	3729
	3730	GameEvent::GameEventDataMap const& events = gameeventmgr.GetEventMap();
	3731
	3732	if(event_id < 1 \|\| event_id >=events.size())
	3733	{
	3734	SendSysMessage(LANG_EVENT_NOT_EXIST);
	3735	SetSentErrorMessage(true);
	3736	return false;
	3737	}
	3738
	3739	GameEventData const& eventData = events[event_id];
	3740	if(!eventData.isValid())
	3741	{
	3742	SendSysMessage(LANG_EVENT_NOT_EXIST);
	3743	SetSentErrorMessage(true);
	3744	return false;
	3745	}
	3746
	3747	GameEvent::ActiveEvents const& activeEvents = gameeventmgr.GetActiveEventList();
	3748
	3749	if(activeEvents.find(event_id) == activeEvents.end())
	3750	{
	3751	PSendSysMessage(LANG_EVENT_NOT_ACTIVE,event_id);
	3752	SetSentErrorMessage(true);
	3753	return false;
	3754	}
	3755
	3756	gameeventmgr.StopEvent(event_id,true);
	3757	return true;
	3758	}
	3759
	3760	bool ChatHandler::HandleCombatStopCommand(const char* args)
	3761	{
	3762	Player *player;
	3763
	3764	if(*args)
	3765	{
	3766	std::string playername = args;
	3767
	3768	if(!normalizePlayerName(playername))
	3769	{
	3770	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	3771	SetSentErrorMessage(true);
	3772	return false;
	3773	}
	3774
	3775	player = objmgr.GetPlayer(playername.c_str());
	3776
	3777	if(!player)
	3778	{
	3779	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	3780	SetSentErrorMessage(true);
	3781	return false;
	3782	}
	3783	}
	3784	else
	3785	{
	3786	player = getSelectedPlayer();
	3787
	3788	if (!player)
	3789	player = m_session->GetPlayer();
	3790	}
	3791
	3792	player->CombatStop();
	3793	player->getHostilRefManager().deleteReferences();
	3794	return true;
	3795	}
	3796
	3797	bool ChatHandler::HandleLearnAllCraftsCommand(const char* /args/)
	3798	{
	3799	uint32 classmask = m_session->GetPlayer()->getClassMask();
	3800
	3801	for (uint32 i = 0; i < sSkillLineStore.GetNumRows(); ++i)
	3802	{
	3803	SkillLineEntry const *skillInfo = sSkillLineStore.LookupEntry(i);
	3804	if( !skillInfo )
	3805	continue;
	3806
	3807	if( skillInfo->categoryId == SKILL_CATEGORY_PROFESSION \|\| skillInfo->categoryId == SKILL_CATEGORY_SECONDARY )
	3808	{
	3809	for (uint32 j = 0; j < sSkillLineAbilityStore.GetNumRows(); ++j)
	3810	{
	3811	SkillLineAbilityEntry const *skillLine = sSkillLineAbilityStore.LookupEntry(j);
	3812	if( !skillLine )
	3813	continue;
	3814
	3815	// skip racial skills
	3816	if( skillLine->racemask != 0 )
	3817	continue;
	3818
	3819	// skip wrong class skills
	3820	if( skillLine->classmask && (skillLine->classmask & classmask) == 0)
	3821	continue;
	3822
	3823	if( skillLine->skillId != i \|\| skillLine->forward_spellid )
	3824	continue;
	3825
	3826	SpellEntry const* spellInfo = sSpellStore.LookupEntry(skillLine->spellId);
	3827	if(!spellInfo \|\| !SpellMgr::IsSpellValid(spellInfo,m_session->GetPlayer(),false))
	3828	continue;
	3829
	3830	m_session->GetPlayer()->learnSpell(skillLine->spellId);
	3831	}
	3832	}
	3833	}
	3834
	3835	SendSysMessage(LANG_COMMAND_LEARN_ALL_CRAFT);
	3836	return true;
	3837	}
	3838
	3839	bool ChatHandler::HandleLearnAllRecipesCommand(const char* args)
	3840	{
	3841	// Learns all recipes of specified profession and sets skill to max
	3842	// Example: .learn all_recipes enchanting
	3843
	3844	Player* target = getSelectedPlayer();
	3845	if( !target )
	3846	{
	3847	SendSysMessage(LANG_PLAYER_NOT_FOUND);
	3848	return false;
	3849	}
	3850
	3851	if(!*args)
	3852	return false;
	3853
	3854	std::wstring wnamepart;
	3855
	3856	if(!Utf8toWStr(args,wnamepart))
	3857	return false;
	3858
	3859	uint32 counter = 0; // Counter for figure out that we found smth.
	3860
	3861	// converting string that we try to find to lower case
	3862	wstrToLower( wnamepart );
	3863
	3864	uint32 classmask = m_session->GetPlayer()->getClassMask();
	3865
	3866	for (uint32 i = 0; i < sSkillLineStore.GetNumRows(); ++i)
	3867	{
	3868	SkillLineEntry const *skillInfo = sSkillLineStore.LookupEntry(i);
	3869	if( !skillInfo )
	3870	continue;
	3871
	3872	if( skillInfo->categoryId != SKILL_CATEGORY_PROFESSION &&
	3873	skillInfo->categoryId != SKILL_CATEGORY_SECONDARY )
	3874	continue;
	3875
	3876	int loc = m_session->GetSessionDbcLocale();
	3877	std::string name = skillInfo->name[loc];
	3878
	3879	if(Utf8FitTo(name, wnamepart))
	3880	{
	3881	for (uint32 j = 0; j < sSkillLineAbilityStore.GetNumRows(); ++j)
	3882	{
	3883	SkillLineAbilityEntry const *skillLine = sSkillLineAbilityStore.LookupEntry(j);
	3884	if( !skillLine )
	3885	continue;
	3886
	3887	if( skillLine->skillId != i \|\| skillLine->forward_spellid )
	3888	continue;
	3889
	3890	// skip racial skills
	3891	if( skillLine->racemask != 0 )
	3892	continue;
	3893
	3894	// skip wrong class skills
	3895	if( skillLine->classmask && (skillLine->classmask & classmask) == 0)
	3896	continue;
	3897
	3898	SpellEntry const* spellInfo = sSpellStore.LookupEntry(skillLine->spellId);
	3899	if(!spellInfo \|\| !SpellMgr::IsSpellValid(spellInfo,m_session->GetPlayer(),false))
	3900	continue;
	3901
	3902	if( !target->HasSpell(spellInfo->Id) )
	3903	m_session->GetPlayer()->learnSpell(skillLine->spellId);
	3904	}
	3905
	3906	uint16 maxLevel = target->GetPureMaxSkillValue(skillInfo->id);
	3907	target->SetSkill(skillInfo->id, maxLevel, maxLevel);
	3908	PSendSysMessage(LANG_COMMAND_LEARN_ALL_RECIPES, name.c_str());
	3909	return true;
	3910	}
	3911	}
	3912
	3913	return false;
	3914	}
	3915
	3916	bool ChatHandler::HandleLookupPlayerIpCommand(const char* args)
	3917	{
	3918
	3919	if(!*args)
	3920	return false;
	3921
	3922	std::string ip = strtok((char*)args, " ");
	3923	char* limit_str = strtok(NULL, " ");
	3924	int32 limit = limit_str ? atoi(limit_str) : -1;
	3925
	3926	loginDatabase.escape_string(ip);
	3927
	3928	QueryResult* result = loginDatabase.PQuery("SELECT id,username FROM account WHERE last_ip = '%s'", ip.c_str());
	3929
	3930	return LookupPlayerSearchCommand(result,limit);
	3931	}
	3932
	3933	bool ChatHandler::HandleLookupPlayerAccountCommand(const char* args)
	3934	{
	3935	if(!*args)
	3936	return false;
	3937
	3938	std::string account = strtok((char*)args, " ");
	3939	char* limit_str = strtok(NULL, " ");
	3940	int32 limit = limit_str ? atoi(limit_str) : -1;
	3941
	3942	if(!AccountMgr::normilizeString(account))
	3943	return false;
	3944
	3945	loginDatabase.escape_string(account);
	3946
	3947	QueryResult* result = loginDatabase.PQuery("SELECT id,username FROM account WHERE username = '%s'", account.c_str());
	3948
	3949	return LookupPlayerSearchCommand(result,limit);
	3950	}
	3951
	3952	bool ChatHandler::HandleLookupPlayerEmailCommand(const char* args)
	3953	{
	3954
	3955	if(!*args)
	3956	return false;
	3957
	3958	std::string email = strtok((char*)args, " ");
	3959	char* limit_str = strtok(NULL, " ");
	3960	int32 limit = limit_str ? atoi(limit_str) : -1;
	3961
	3962	loginDatabase.escape_string(email);
	3963
	3964	QueryResult* result = loginDatabase.PQuery("SELECT id,username FROM account WHERE email = '%s'", email.c_str());
	3965
	3966	return LookupPlayerSearchCommand(result,limit);
	3967	}
	3968
	3969	bool ChatHandler::LookupPlayerSearchCommand(QueryResult* result, int32 limit)
	3970	{
	3971	if(!result)
	3972	{
	3973	PSendSysMessage(LANG_NO_PLAYERS_FOUND);
	3974	SetSentErrorMessage(true);
	3975	return false;
	3976	}
	3977
	3978	int i =0;
	3979	do
	3980	{
	3981	Field* fields = result->Fetch();
	3982	uint32 acc_id = fields[0].GetUInt32();
	3983	std::string acc_name = fields[1].GetCppString();
	3984
	3985	QueryResult* chars = CharacterDatabase.PQuery("SELECT guid,name FROM characters WHERE account = '%u'", acc_id);
	3986	if(chars)
	3987	{
	3988	PSendSysMessage(LANG_LOOKUP_PLAYER_ACCOUNT,acc_name.c_str(),acc_id);
	3989
	3990	uint64 guid = 0;
	3991	std::string name;
	3992
	3993	do
	3994	{
	3995	Field* charfields = chars->Fetch();
	3996	guid = charfields[0].GetUInt64();
	3997	name = charfields[1].GetCppString();
	3998
	3999	PSendSysMessage(LANG_LOOKUP_PLAYER_CHARACTER,name.c_str(),guid);
	4000	++i;
	4001
	4002	} while( chars->NextRow() && ( limit == -1 \|\| i < limit ) );
	4003
	4004	delete chars;
	4005	}
	4006	} while(result->NextRow());
	4007
	4008	delete result;
	4009
	4010	return true;
	4011	}

Note: See TracBrowser for help on using the browser.

Context Navigation

root/trunk/src/game/Level2.cpp @ 79

Download in other formats: