Assembla home | Assembla project page

My Start Page

Navigation

← Previous Changeset
Next Changeset →

Changeset 916

Timestamp:

11/09/08 04:51:24 (8 months ago)

Author:

dannuic

Message:

*This is a CombatTest? update*
[added] proper trainers (require xp to train non-BF skills)

Files:

core3/branches/CombatTest/src/server/zone/managers/creature/CreatureManagerImplementation.cpp (modified) (2 diffs)
core3/branches/CombatTest/src/server/zone/objects/creature/skills/target/CureTargetSkill.h (modified) (1 diff)
core3/branches/CombatTest/src/server/zone/objects/creature/trainer/TrainerCreature.cpp (modified) (6 diffs)
core3/branches/CombatTest/src/server/zone/objects/creature/trainer/TrainerCreature.h (modified) (2 diffs)
core3/branches/CombatTest/src/server/zone/objects/creature/trainer/TrainerCreature.idl (modified) (1 diff)
core3/branches/CombatTest/src/server/zone/objects/creature/trainer/TrainerCreatureImplementation.cpp (modified) (2 diffs)
core3/branches/CombatTest/src/server/zone/objects/creature/trainer/TrainerCreatureImplementation.h (modified) (1 diff)
core3/branches/CombatTest/src/server/zone/objects/player/Player.cpp (modified) (212 diffs)
core3/branches/CombatTest/src/server/zone/objects/player/Player.h (modified) (7 diffs)
core3/branches/CombatTest/src/server/zone/objects/player/Player.idl (modified) (2 diffs)
core3/branches/CombatTest/src/server/zone/objects/player/PlayerImplementation.h (modified) (3 diffs)
core3/branches/CombatTest/src/server/zone/objects/player/PlayerObject.cpp (modified) (60 diffs)
core3/branches/CombatTest/src/server/zone/objects/player/PlayerObject.h (modified) (3 diffs)
core3/branches/CombatTest/src/server/zone/objects/player/PlayerObject.idl (modified) (1 diff)
core3/branches/CombatTest/src/server/zone/objects/player/PlayerObjectImplementation.cpp (modified) (1 diff)
core3/branches/CombatTest/src/server/zone/objects/player/PlayerObjectImplementation.h (modified) (1 diff)
core3/branches/CombatTest/src/server/zone/objects/tangible/weapons/WeaponImplementation.cpp (modified) (1 diff)
core3/branches/CombatTest/src/server/zone/packets/object/StringList.h (modified) (1 diff)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

core3/branches/CombatTest/src/server/zone/managers/creature/CreatureManagerImplementation.cpp

r888	r916
268	268	Profession* prof = professionManager->professionMap.getNextValue();
269	269
270		if ((int)prof->getName().find("jedi") >= 0 \|\| (int)prof->getName().find("force") >= 0)
271		continue;
272
273		TrainerCreature* trainer = spawnTrainer(prof->getName(), "", prof->getName(), 0x8C73B91, 0, -4967 - (i*1), 4043, 6, 0, 0);
	270	//if ((int)prof->getName().find("jedi") >= 0 \|\| (int)prof->getName().find("force") >= 0)
	271	// continue;
	272
	273	TrainerCreature* trainer = spawnTrainer(prof->getName(), "trainer_unknown", prof->getName(), 0x8C73B91, 0, -4967 - (i*1), 4043, 6, 0, 0);
274	274	}
275	275	}
…	…
445	445	if (!stfname.empty())
446	446	trainer->setSpeciesName(stfname);
447		else
	447	//else
	448	if (!name.empty())
448	449	trainer->setCharacterName(unicode(name));
449	450

core3/branches/CombatTest/src/server/zone/objects/creature/skills/target/CureTargetSkill.h

r888	r916
288	288	player->addXp(type, amount, true);
289	289
290		String::toLower(type);
	290	/*String::toLower(type);
291	291	type[0] = toupper(type[0]); //Capitalize first letter.
292	292
293	293	stringstream msgExperience;
294	294	msgExperience << "You receive " << amount << " points of " << type << " experience.";
295		player->sendSystemMessage(msgExperience.str());
	295	player->sendSystemMessage(msgExperience.str());*/
296	296	}
297	297

core3/branches/CombatTest/src/server/zone/objects/creature/trainer/TrainerCreature.cpp

r365	r916
28	28	}
29	29
	30	void TrainerCreature::sendInitialMessage(Player* player) {
	31	if (_impl == NULL) {
	32	if (!deployed)
	33	throw ObjectNotDeployedException(this);
	34
	35	DistributedMethod method(this, 6);
	36	method.addObjectParameter(player);
	37
	38	method.executeWithVoidReturn();
	39	} else
	40	((TrainerCreatureImplementation*) _impl)->sendInitialMessage(player);
	41	}
	42
	43	void TrainerCreature::sendInitialChoices(Player* player) {
	44	if (_impl == NULL) {
	45	if (!deployed)
	46	throw ObjectNotDeployedException(this);
	47
	48	DistributedMethod method(this, 7);
	49	method.addObjectParameter(player);
	50
	51	method.executeWithVoidReturn();
	52	} else
	53	((TrainerCreatureImplementation*) _impl)->sendInitialChoices(player);
	54	}
	55
30	56	void TrainerCreature::sendConversationStartTo(SceneObject* obj) {
31	57	if (_impl == NULL) {
…	…
33	59	throw ObjectNotDeployedException(this);
34	60
35		DistributedMethod method(this, 6);
	61	DistributedMethod method(this, 8);
36	62	method.addObjectParameter(obj);
37	63
…	…
41	67	}
42	68
43		void TrainerCreature::sendSkillBoxes(Player* player) {
44		if (_impl == NULL) {
45		if (!deployed)
46		throw ObjectNotDeployedException(this);
47
48		DistributedMethod method(this, 7);
49		method.addObjectParameter(player);
50
51		method.executeWithVoidReturn();
52		} else
53		((TrainerCreatureImplementation*) _impl)->sendSkillBoxes(player);
	69	void TrainerCreature::sendSkillBoxes(Player* player, bool checkXp) {
	70	if (_impl == NULL) {
	71	if (!deployed)
	72	throw ObjectNotDeployedException(this);
	73
	74	DistributedMethod method(this, 9);
	75	method.addObjectParameter(player);
	76	method.addBooleanParameter(checkXp);
	77
	78	method.executeWithVoidReturn();
	79	} else
	80	((TrainerCreatureImplementation*) _impl)->sendSkillBoxes(player, checkXp);
	81	}
	82
	83	void TrainerCreature::sendSkillBoxList(Player* player, bool checkLearned) {
	84	if (_impl == NULL) {
	85	if (!deployed)
	86	throw ObjectNotDeployedException(this);
	87
	88	DistributedMethod method(this, 10);
	89	method.addObjectParameter(player);
	90	method.addBooleanParameter(checkLearned);
	91
	92	method.executeWithVoidReturn();
	93	} else
	94	((TrainerCreatureImplementation*) _impl)->sendSkillBoxList(player, checkLearned);
	95	}
	96
	97	void TrainerCreature::sendConfirmation(Player* player) {
	98	if (_impl == NULL) {
	99	if (!deployed)
	100	throw ObjectNotDeployedException(this);
	101
	102	DistributedMethod method(this, 11);
	103	method.addObjectParameter(player);
	104
	105	method.executeWithVoidReturn();
	106	} else
	107	((TrainerCreatureImplementation*) _impl)->sendConfirmation(player);
54	108	}
55	109
…	…
59	113	throw ObjectNotDeployedException(this);
60	114
61		DistributedMethod method(this, 8);
	115	DistributedMethod method(this, 12);
62	116	method.addSignedIntParameter(option);
63	117	method.addObjectParameter(obj);
…	…
80	134	switch (methid) {
81	135	case 6:
	136	sendInitialMessage((Player*) inv->getObjectParameter());
	137	break;
	138	case 7:
	139	sendInitialChoices((Player*) inv->getObjectParameter());
	140	break;
	141	case 8:
82	142	sendConversationStartTo((SceneObject*) inv->getObjectParameter());
83	143	break;
84		case 7:
85		sendSkillBoxes((Player*) inv->getObjectParameter());
86		break;
87		case 8:
	144	case 9:
	145	sendSkillBoxes((Player*) inv->getObjectParameter(), inv->getBooleanParameter());
	146	break;
	147	case 10:
	148	sendSkillBoxList((Player*) inv->getObjectParameter(), inv->getBooleanParameter());
	149	break;
	150	case 11:
	151	sendConfirmation((Player*) inv->getObjectParameter());
	152	break;
	153	case 12:
88	154	selectConversationOption(inv->getSignedIntParameter(), (SceneObject*) inv->getObjectParameter());
89	155	break;
…	…
95	161	}
96	162
	163	void TrainerCreatureAdapter::sendInitialMessage(Player* player) {
	164	return ((TrainerCreatureImplementation*) impl)->sendInitialMessage(player);
	165	}
	166
	167	void TrainerCreatureAdapter::sendInitialChoices(Player* player) {
	168	return ((TrainerCreatureImplementation*) impl)->sendInitialChoices(player);
	169	}
	170
97	171	void TrainerCreatureAdapter::sendConversationStartTo(SceneObject* obj) {
98	172	return ((TrainerCreatureImplementation*) impl)->sendConversationStartTo(obj);
99	173	}
100	174
101		void TrainerCreatureAdapter::sendSkillBoxes(Player* player) {
102		return ((TrainerCreatureImplementation*) impl)->sendSkillBoxes(player);
	175	void TrainerCreatureAdapter::sendSkillBoxes(Player* player, bool checkXp) {
	176	return ((TrainerCreatureImplementation*) impl)->sendSkillBoxes(player, checkXp);
	177	}
	178
	179	void TrainerCreatureAdapter::sendSkillBoxList(Player* player, bool checkLearned) {
	180	return ((TrainerCreatureImplementation*) impl)->sendSkillBoxList(player, checkLearned);
	181	}
	182
	183	void TrainerCreatureAdapter::sendConfirmation(Player* player) {
	184	return ((TrainerCreatureImplementation*) impl)->sendConfirmation(player);
103	185	}
104	186

core3/branches/CombatTest/src/server/zone/objects/creature/trainer/TrainerCreature.h

r365	r916
22	22	TrainerCreature(unsigned long long oid, Profession* prof);
23	23
	24	void sendInitialMessage(Player* player);
	25
	26	void sendInitialChoices(Player* player);
	27
24	28	void sendConversationStartTo(SceneObject* obj);
25	29
26		void sendSkillBoxes(Player* player);
	30	void sendSkillBoxes(Player* player, bool checkXp);
	31
	32	void sendSkillBoxList(Player* player, bool checkLearned);
	33
	34	void sendConfirmation(Player* player);
27	35
28	36	void selectConversationOption(int option, SceneObject* obj);
…	…
44	52	Packet* invokeMethod(sys::uint32 methid, DistributedMethod* method);
45	53
	54	void sendInitialMessage(Player* player);
	55
	56	void sendInitialChoices(Player* player);
	57
46	58	void sendConversationStartTo(SceneObject* obj);
47	59
48		void sendSkillBoxes(Player* player);
	60	void sendSkillBoxes(Player* player, bool checkXp);
	61
	62	void sendSkillBoxList(Player* player, bool checkLearned);
	63
	64	void sendConfirmation(Player* player);
49	65
50	66	void selectConversationOption(int option, SceneObject* obj);

core3/branches/CombatTest/src/server/zone/objects/creature/trainer/TrainerCreature.idl

r365	r916
56	56	}
57	57
	58	void sendInitialMessage(Player player);
	59	void sendInitialChoices(Player player);
58	60	void sendConversationStartTo(SceneObject obj);
59		void sendSkillBoxes(Player player);
	61	void sendSkillBoxes(Player player, boolean checkXp);
	62	void sendSkillBoxList(Player player, boolean checkLearned);
	63	void sendConfirmation(Player player);
60	64
61	65	void selectConversationOption(int option, SceneObject obj);

core3/branches/CombatTest/src/server/zone/objects/creature/trainer/TrainerCreatureImplementation.cpp

r732	r916
85	85	Player* player = (Player*)obj;
86	86
	87	// TODO test for qualifying prereq skills
87	88	StartNpcConversation* conv = new StartNpcConversation(player, objectID, "");
88	89	player->sendMessage(conv);
89
90		unicode mes1 = "Please select the box you want to learn";
91		NpcConversationMessage* m1 = new NpcConversationMessage(player, mes1);
	90	player->setLastNpcConvStr(getSpeciesName());
	91
	92	sendInitialMessage(player);
	93	}
	94
	95	void TrainerCreatureImplementation::sendInitialMessage(Player* player) {
	96	NpcConversationMessage* m1 = new NpcConversationMessage(player, "skill_teacher", getSpeciesName());
92	97	player->sendMessage(m1);
93	98
94		sendSkillBoxes(player);
95		}
96
97		void TrainerCreatureImplementation::sendSkillBoxes(Player* player) {
	99	player->setLastNpcConvMessStr("trainer_initial");
	100	sendInitialChoices(player);
	101	}
	102
	103	void TrainerCreatureImplementation::sendInitialChoices(Player* player) {
	104	StringList* slist = new StringList(player);
	105
	106	slist->insertOption("skill_teacher", "opt1_1");
	107	slist->insertOption("skill_teacher", "opt1_2");
	108	slist->insertOption("skill_teacher", "opt1_3");
	109	slist->insertOption("skill_teacher", "opt1_4");
	110
	111	player->setLastNpcConvMessStr("trainer_initial");
	112
	113	player->sendMessage(slist);
	114	}
	115
	116	void TrainerCreatureImplementation::sendSkillBoxes(Player* player, bool checkXp) {
98	117	StringList* slist = new StringList(player);
99	118	Vector<SkillBox> skillBoxes = profession->getSkillBoxes();
100
	119	string option;
	120	int known = 0;
	121
	122	player->clearLastNpcConvOptions();
	123
101	124	for (int i = 0; i < skillBoxes->size(); i++) {
102	125	SkillBox* skillBox = skillBoxes->get(i);
	126	bool qual = true;
	127
	128	if (player->hasSkillBox(skillBox->getName())) {
	129	known++;
	130	qual = false;
	131	}
	132
	133	//if (checkXp && skillBox->getSkillXpCost() > player->getXp(skillBox->getSkillXpType()))
	134	// qual = false;
	135
	136	for (int j = 0; (qual == true) && (j < skillBox->getRequiredSkillsSize()); j++) {
	137	string skillname;
	138	skillBox->getRequiredSkill(skillname, j);
	139
	140	if (!player->hasSkillBox(skillname))
	141	qual = false;
	142	}
	143
	144	if (qual) {
	145	slist->insertOption("skl_n", skillBox->getName());
	146	player->addLastNpcConvOptions(skillBox->getName());
	147	}
	148	}
	149
	150	if (checkXp)
	151	player->setLastNpcConvMessStr("trainer_canlearn");
	152	else
	153	player->setLastNpcConvMessStr("trainer_nextskills");
	154
	155	if (slist->getOptionCount() > 0)
	156	if (checkXp)
	157	option = "msg2_1";
	158	else
	159	option = "msg2_2";
	160	else if (known == skillBoxes->size())
	161	option = "msg3_1";
	162	else
	163	option = "error_empty_category";
	164
	165	NpcConversationMessage* m2 = new NpcConversationMessage(player, "skill_teacher", option);
	166	player->sendMessage(m2);
	167
	168	slist->insertOption("skill_teacher","back");
	169	player->addLastNpcConvOptions(string("back"));
	170	player->sendMessage(slist);
	171	}
	172
	173	void TrainerCreatureImplementation::sendSkillBoxList(Player* player, bool checkLearned) {
	174	StringList* slist = new StringList(player);
	175	Vector<SkillBox> skillBoxes = profession->getSkillBoxes();
	176
	177	for (int i = 0; i < skillBoxes->size(); i++) {
	178	SkillBox *skillBox = skillBoxes->get(i);
	179	if (checkLearned && player->hasSkillBox(skillBox->getName()))
	180	continue;
103	181	slist->insertOption("skl_n", skillBox->getName());
	182	player->addLastNpcConvOptions(skillBox->getName());
104	183	}
105	184
	185	string option;
	186	if (checkLearned) {
	187	option = "msg2_3";
	188	player->setLastNpcConvMessStr("trainer_unlearned");
	189	} else {
	190	option = "msg2_4";
	191	player->setLastNpcConvMessStr("trainer_allskills");
	192	}
	193
	194	NpcConversationMessage* m3 = new NpcConversationMessage(player, "skill_teacher", option);
	195	slist->insertOption("skill_teacher","back");
	196	player->addLastNpcConvOptions(string("back"));
	197	player->sendMessage(slist);
	198	}
	199
	200	void TrainerCreatureImplementation::sendConfirmation(Player* player) {
	201	StringList* slist = new StringList(player);
	202
	203	slist->insertOption("skill_teacher", "yes");
	204	slist->insertOption("skill_teacher", "no");
	205
106	206	player->sendMessage(slist);
107	207	}
…	…
112	212
113	213	Player* player = (Player*)obj;
	214
	215	if (player->getLastNpcConvStr() != getSpeciesName())
	216	return;
114	217
115	218	Vector<SkillBox> skillBoxes = profession->getSkillBoxes();
116
117		SkillBox* sBox = skillBoxes->get(option);
118		if (sBox == NULL)
119		return;
	219	string choice;
	220	if (player->countLastNpcConvOptions() > 0)
	221	choice = player->getLastNpcConvOption(option);
	222	player->clearLastNpcConvOptions();
	223
	224	if (player->getLastNpcConvMessStr() == "trainer_initial") {
	225	switch (option) {
	226	case 0:
	227	sendSkillBoxes(player, true);
	228	break;
	229	case 1:
	230	sendSkillBoxes(player, false);
	231	break;
	232	case 2:
	233	sendSkillBoxList(player, true);
	234	break;
	235	case 3:
	236	sendSkillBoxList(player, false);
	237	break;
	238	default:
	239	break;
	240	};
	241
	242	} else if (player->getLastNpcConvMessStr() == "trainer_canlearn") {
	243	if (choice == "back") {
	244	sendInitialMessage(player);
	245	} else {
	246	NpcConversationMessage* skillmsg = new NpcConversationMessage(player, "skill_teacher", "confirm");
	247	player->setLastNpcConvMessStr("trainer_learn");
	248	player->addLastNpcConvOptions(choice);
	249	player->sendMessage(skillmsg);
	250	sendConfirmation(player);
	251	}
	252	} else if (player->getLastNpcConvMessStr() == "trainer_nextskills") {
	253	if (choice == "back") {
	254	sendInitialMessage(player);
	255	} else {
	256	NpcConversationMessage* skillmsg = new NpcConversationMessage(player, "skl_d", choice);
	257	player->sendMessage(skillmsg);
	258	sendSkillBoxes(player, false);
	259	}
	260	} else if (player->getLastNpcConvMessStr() == "trainer_unlearned") {
	261	if (choice == "back") {
	262	sendInitialMessage(player);
	263	} else {
	264	NpcConversationMessage* skillmsg = new NpcConversationMessage(player, "skl_d", choice);
	265	player->sendMessage(skillmsg);
	266	sendSkillBoxList(player, true);
	267	}
	268	} else if (player->getLastNpcConvMessStr() == "trainer_allskills") {
	269	if (choice == "back") {
	270	sendInitialMessage(player);
	271	} else {
	272	NpcConversationMessage* skillmsg = new NpcConversationMessage(player, "skl_d", choice);
	273	player->sendMessage(skillmsg);
	274	sendSkillBoxList(player, false);
	275	}
	276	} else if (player->getLastNpcConvMessStr() == "trainer_learn") {
	277	SkillBox* sBox;
	278	string optionmessage;
	279	StfParameter* params = new StfParameter();
	280
	281	switch (option) {
	282	case 0: //yes
	283	params->addTO("skl_n", choice);
	284	for (int i = 0; i < skillBoxes->size(); i++) {
	285	if (skillBoxes->get(i)->getName() == choice) {
	286	sBox = skillBoxes->get(i);
	287	break;
	288	}
	289	}
	290
	291	if (sBox->getSkillXpCost() > player->getXp(sBox->getSkillXpType()))
	292	player->sendSystemMessage("skill_teacher", "prose_train_failed", params);
	293	else {
	294	train(sBox, player);
	295	player->addXp(sBox->getSkillXpType(), (-1)*sBox->getSkillXpCost(), true);
	296	player->sendSystemMessage("skill_teacher", "prose_skill_learned", params);
	297	}
	298	optionmessage = "msg_yes";
	299	break;
	300	case 1: //no
	301	optionmessage = "msg_no";
	302	break;
	303	default:
	304	break;
	305	};
120	306
121		stringstream test;
122		test << "Trying to train " << sBox->getName();
123		player->sendSystemMessage(test.str());
124
125		if (train(sBox, player))
126		player->sendSystemMessage("SkillBox trained");
127		else
128		player->sendSystemMessage("You lack the requisites to train this SkillBox");
129
130		sendSkillBoxes(player);
131		}
	307	delete params;
	308	NpcConversationMessage* skillmsg = new NpcConversationMessage(player, "skill_teacher", optionmessage);
	309	player->sendMessage(skillmsg);
	310	sendInitialChoices(player);
	311	} else
	312	sendInitialMessage(player);
	313	}

core3/branches/CombatTest/src/server/zone/objects/creature/trainer/TrainerCreatureImplementation.h

r365	r916
63	63	bool train(SkillBox* skillBox, Player* player);
64	64
	65	void sendInitialMessage(Player* player);
	66	void sendInitialChoices(Player* player);
65	67	void sendConversationStartTo(SceneObject* obj);
66		void sendSkillBoxes(Player* player);
	68	void sendSkillBoxes(Player* player, bool checkXp);
	69	void sendSkillBoxList(Player* player, bool checkLearned);
	70	void sendConfirmation(Player* player);
67	71
68	72	void selectConversationOption(int option, SceneObject* obj);

core3/branches/CombatTest/src/server/zone/objects/player/Player.cpp

r908	r916
1826	1826	}
1827	1827
1828		~~void Player::addXp(string& xpType, int xp, bool updateClient~~) {
	1828	int Player::getXp(const string& xpType) {
1829	1829	if (_impl == NULL) {
1830	1830	if (!deployed)
…	…
1833	1833	DistributedMethod method(this, 144);
1834	1834	method.addAsciiParameter(xpType);
1835		method.addSignedIntParameter(xp);
1836		method.addBooleanParameter(updateClient);
1837
1838		method.executeWithVoidReturn();
1839		} else
1840		((PlayerImplementation*) _impl)->addXp(xpType, xp, updateClient);
1841		}
1842
1843		void Player::removeXp(string& xpType, int xp, bool updateClient) {
	1835
	1836	return method.executeWithSignedIntReturn();
	1837	} else
	1838	return ((PlayerImplementation*) _impl)->getXp(xpType);
	1839	}
	1840
	1841	void Player::addXp(string& xpType, int xp, bool updateClient) {
1844	1842	if (_impl == NULL) {
1845	1843	if (!deployed)
…	…
1853	1851	method.executeWithVoidReturn();
1854	1852	} else
	1853	((PlayerImplementation*) _impl)->addXp(xpType, xp, updateClient);
	1854	}
	1855
	1856	void Player::removeXp(string& xpType, int xp, bool updateClient) {
	1857	if (_impl == NULL) {
	1858	if (!deployed)
	1859	throw ObjectNotDeployedException(this);
	1860
	1861	DistributedMethod method(this, 146);
	1862	method.addAsciiParameter(xpType);
	1863	method.addSignedIntParameter(xp);
	1864	method.addBooleanParameter(updateClient);
	1865
	1866	method.executeWithVoidReturn();
	1867	} else
1855	1868	((PlayerImplementation*) _impl)->removeXp(xpType, xp, updateClient);
1856	1869	}
…	…
1861	1874	throw ObjectNotDeployedException(this);
1862	1875
1863		DistributedMethod method(this, 146);
	1876	DistributedMethod method(this, 147);
1864	1877	method.addAsciiParameter(xpStr);
1865	1878
…	…
1874	1887	throw ObjectNotDeployedException(this);
1875	1888
1876		DistributedMethod method(this, 147);
	1889	DistributedMethod method(this, 148);
1877	1890
1878	1891	method.executeWithAsciiReturn(_return_saveXp);
…	…
1887	1900	throw ObjectNotDeployedException(this);
1888	1901
1889		DistributedMethod method(this, 148);
	1902	DistributedMethod method(this, 149);
1890	1903	method.addAsciiParameter(xptype);
1891	1904
…	…
1900	1913	throw ObjectNotDeployedException(this);
1901	1914
1902		DistributedMethod method(this, 149);
	1915	DistributedMethod method(this, 150);
1903	1916
1904	1917	method.executeWithVoidReturn();
…	…
1912	1925	throw ObjectNotDeployedException(this);
1913	1926
1914		DistributedMethod method(this, 150);
	1927	DistributedMethod method(this, 151);
1915	1928	method.addAsciiParameter(xptype);
1916	1929	method.addAsciiParameter(prosetype);
…	…
1926	1939	throw ObjectNotDeployedException(this);
1927	1940
1928		DistributedMethod method(this, 151);
	1941	DistributedMethod method(this, 152);
1929	1942	method.addAsciiParameter(xptype);
1930	1943
…	…
1935	1948
1936	1949	void Player::removeFromDuelList(Player* targetPlayer) {
1937		~~if (_impl == NULL) {~~
1938		~~if (!deployed)~~
1939		~~throw ObjectNotDeployedException(this);~~
1940
1941		~~DistributedMethod method(this, 152);~~
1942		~~method.addObjectParameter(targetPlayer);~~
1943
1944		~~method.executeWithVoidReturn();~~
1945		~~} else~~
1946		~~((PlayerImplementation*) _impl)->removeFromDuelList(targetPlayer);~~
1947		}
1948
1949		~~void Player::addToDuelList(Player* targetPlayer) {~~
1950	1950	if (_impl == NULL) {
1951	1951	if (!deployed)
…	…
1957	1957	method.executeWithVoidReturn();
1958	1958	} else
1959		((PlayerImplementation*) _impl)->~~addTo~~DuelList(targetPlayer);
1960		}
1961
1962		~~bool Player::isInDuelWith(Player* targetPlayer, bool doLock~~) {
	1959	((PlayerImplementation*) _impl)->removeFromDuelList(targetPlayer);
	1960	}
	1961
	1962	void Player::addToDuelList(Player* targetPlayer) {
1963	1963	if (_impl == NULL) {
1964	1964	if (!deployed)
…	…
1967	1967	DistributedMethod method(this, 154);
1968	1968	method.addObjectParameter(targetPlayer);
	1969
	1970	method.executeWithVoidReturn();
	1971	} else
	1972	((PlayerImplementation*) _impl)->addToDuelList(targetPlayer);
	1973	}
	1974
	1975	bool Player::isInDuelWith(Player* targetPlayer, bool doLock) {
	1976	if (_impl == NULL) {
	1977	if (!deployed)
	1978	throw ObjectNotDeployedException(this);
	1979
	1980	DistributedMethod method(this, 155);
	1981	method.addObjectParameter(targetPlayer);
1969	1982	method.addBooleanParameter(doLock);
1970	1983
…	…
1979	1992	throw ObjectNotDeployedException(this);
1980	1993
1981		DistributedMethod method(this, 155);
	1994	DistributedMethod method(this, 156);
1982	1995	method.addSignedIntParameter(index);
1983	1996
…	…
1992	2005	throw ObjectNotDeployedException(this);
1993	2006
1994		DistributedMethod method(this, 156);
	2007	DistributedMethod method(this, 157);
1995	2008	method.addObjectParameter(targetPlayer);
1996	2009
…	…
2005	2018	throw ObjectNotDeployedException(this);
2006	2019
2007		DistributedMethod method(this, 157);
	2020	DistributedMethod method(this, 158);
2008	2021
2009	2022	return method.executeWithBooleanReturn();
…	…
2017	2030	throw ObjectNotDeployedException(this);
2018	2031
2019		DistributedMethod method(this, 158);
	2032	DistributedMethod method(this, 159);
2020	2033
2021	2034	return method.executeWithSignedIntReturn();
…	…
2029	2042	throw ObjectNotDeployedException(this);
2030	2043
2031		DistributedMethod method(this, 159);
	2044	DistributedMethod method(this, 160);
2032	2045	method.addUnsignedIntParameter(gid);
2033	2046
…	…
2042	2055	throw ObjectNotDeployedException(this);
2043	2056
2044		DistributedMethod method(this, 160);
	2057	DistributedMethod method(this, 161);
2045	2058	method.addObjectParameter(gild);
2046	2059
…	…
2055	2068	throw ObjectNotDeployedException(this);
2056	2069
2057		DistributedMethod method(this, 161);
	2070	DistributedMethod method(this, 162);
2058	2071	method.addUnsignedIntParameter(gid);
2059	2072
…	…
2068	2081	throw ObjectNotDeployedException(this);
2069	2082
2070		DistributedMethod method(this, 162);
	2083	DistributedMethod method(this, 163);
2071	2084	method.addObjectParameter(guild);
2072	2085
…	…
2077	2090
2078	2091	void Player::addChatRoom(ChatRoom* room) {
2079		~~if (_impl == NULL) {~~
2080		~~if (!deployed)~~
2081		~~throw ObjectNotDeployedException(this);~~
2082
2083		~~DistributedMethod method(this, 163);~~
2084		~~method.addObjectParameter(room);~~
2085
2086		~~method.executeWithVoidReturn();~~
2087		~~} else~~
2088		~~((PlayerImplementation*) _impl)->addChatRoom(room);~~
2089		}
2090
2091		~~void Player::removeChatRoom(ChatRoom* room) {~~
2092	2092	if (_impl == NULL) {
2093	2093	if (!deployed)
…	…
2099	2099	method.executeWithVoidReturn();
2100	2100	} else
	2101	((PlayerImplementation*) _impl)->addChatRoom(room);
	2102	}
	2103
	2104	void Player::removeChatRoom(ChatRoom* room) {
	2105	if (_impl == NULL) {
	2106	if (!deployed)
	2107	throw ObjectNotDeployedException(this);
	2108
	2109	DistributedMethod method(this, 165);
	2110	method.addObjectParameter(room);
	2111
	2112	method.executeWithVoidReturn();
	2113	} else
2101	2114	((PlayerImplementation*) _impl)->removeChatRoom(room);
2102	2115	}
…	…
2107	2120	throw ObjectNotDeployedException(this);
2108	2121
2109		DistributedMethod method(this, 165);
	2122	DistributedMethod method(this, 166);
2110	2123	method.addAsciiParameter(msg);
2111	2124
…	…
2120	2133	throw ObjectNotDeployedException(this);
2121	2134
2122		DistributedMethod method(this, 166);
	2135	DistributedMethod method(this, 167);
2123	2136	method.addUnicodeParameter(msg);
2124	2137
…	…
2133	2146	throw ObjectNotDeployedException(this);
2134	2147
2135		DistributedMethod method(this, 167);
	2148	DistributedMethod method(this, 168);
2136	2149	method.addAsciiParameter(file);
2137	2150	method.addAsciiParameter(str);
…	…
2148	2161	throw ObjectNotDeployedException(this);
2149	2162
2150		DistributedMethod method(this, 168);
	2163	DistributedMethod method(this, 169);
2151	2164	method.addAsciiParameter(file);
2152	2165	method.addAsciiParameter(str);
…	…
2163	2176	throw ObjectNotDeployedException(this);
2164	2177
2165		DistributedMethod method(this, 169);
	2178	DistributedMethod method(this, 170);
2166	2179	method.addObjectParameter(target);
2167	2180
…	…
2176	2189	throw ObjectNotDeployedException(this);
2177	2190
2178		DistributedMethod method(this, 170);
	2191	DistributedMethod method(this, 171);
2179	2192	method.addObjectParameter(target);
2180	2193	method.addSignedIntParameter(h);
…	…
2192	2205	throw ObjectNotDeployedException(this);
2193	2206
2194		DistributedMethod method(this, 171);
	2207	DistributedMethod method(this, 172);
2195	2208	method.addObjectParameter(conversator);
2196	2209
…	…
2201	2214
2202	2215	void Player::setFirstName(const string& name) {
2203		~~if (_impl == NULL) {~~
2204		~~if (!deployed)~~
2205		~~throw ObjectNotDeployedException(this);~~
2206
2207		~~DistributedMethod method(this, 172);~~
2208		~~method.addAsciiParameter(name);~~
2209
2210		~~method.executeWithVoidReturn();~~
2211		~~} else~~
2212		~~((PlayerImplementation*) _impl)->setFirstName(name);~~
2213		}
2214
2215		~~void Player::setLastName(const string& name) {~~
2216	2216	if (_impl == NULL) {
2217	2217	if (!deployed)
…	…
2223	2223	method.executeWithVoidReturn();
2224	2224	} else
2225		((PlayerImplementation*) _impl)->setLastName(name);
2226		}
2227
2228		void Player::set~~FirstNameProper~~(const string& name) {
	2225	((PlayerImplementation*) _impl)->setFirstName(name);
	2226	}
	2227
	2228	void Player::setLastName(const string& name) {
2229	2229	if (_impl == NULL) {
2230	2230	if (!deployed)
…	…
2236	2236	method.executeWithVoidReturn();
2237	2237	} else
	2238	((PlayerImplementation*) _impl)->setLastName(name);
	2239	}
	2240
	2241	void Player::setFirstNameProper(const string& name) {
	2242	if (_impl == NULL) {
	2243	if (!deployed)
	2244	throw ObjectNotDeployedException(this);
	2245
	2246	DistributedMethod method(this, 175);
	2247	method.addAsciiParameter(name);
	2248
	2249	method.executeWithVoidReturn();
	2250	} else
2238	2251	((PlayerImplementation*) _impl)->setFirstNameProper(name);
2239	2252	}
…	…
2244	2257	throw ObjectNotDeployedException(this);
2245	2258
2246		DistributedMethod method(this, 175);
	2259	DistributedMethod method(this, 176);
2247	2260	method.addAsciiParameter(bio);
2248	2261
…	…
2257	2270	throw ObjectNotDeployedException(this);
2258	2271
2259		DistributedMethod method(this, 176);
	2272	DistributedMethod method(this, 177);
2260	2273	method.addUnicodeParameter(bio);
2261	2274
…	…
2266	2279
2267	2280	bool Player::changeForcePowerBar(int fp) {
2268		~~if (_impl == NULL) {~~
2269		~~if (!deployed)~~
2270		~~throw ObjectNotDeployedException(this);~~
2271
2272		~~DistributedMethod method(this, 177);~~
2273		~~method.addSignedIntParameter(fp);~~
2274
2275		~~return method.executeWithBooleanReturn();~~
2276		~~} else~~
2277		~~return ((PlayerImplementation*) _impl)->changeForcePowerBar(fp);~~
2278		}
2279
2280		~~void Player::setForcePowerBar(int fp) {~~
2281	2281	if (_impl == NULL) {
2282	2282	if (!deployed)
…	…
2286	2286	method.addSignedIntParameter(fp);
2287	2287
	2288	return method.executeWithBooleanReturn();
	2289	} else
	2290	return ((PlayerImplementation*) _impl)->changeForcePowerBar(fp);
	2291	}
	2292
	2293	void Player::setForcePowerBar(int fp) {
	2294	if (_impl == NULL) {
	2295	if (!deployed)
	2296	throw ObjectNotDeployedException(this);
	2297
	2298	DistributedMethod method(this, 179);
	2299	method.addSignedIntParameter(fp);
	2300
2288	2301	method.executeWithVoidReturn();
2289	2302	} else
…	…
2296	2309	throw ObjectNotDeployedException(this);
2297	2310
2298		DistributedMethod method(this, 179);
	2311	DistributedMethod method(this, 180);
2299	2312	method.addBooleanParameter(updateClient);
2300	2313
…	…
2305	2318
2306	2319	void Player::setFoodFilling(int fill, bool updateClient) {
2307		~~if (_impl == NULL) {~~
2308		~~if (!deployed)~~
2309		~~throw ObjectNotDeployedException(this);~~
2310
2311		~~DistributedMethod method(this, 180);~~
2312		~~method.addSignedIntParameter(fill);~~
2313		~~method.addBooleanParameter(updateClient);~~
2314
2315		~~method.executeWithVoidReturn();~~
2316		~~} else~~
2317		~~((PlayerImplementation*) _impl)->setFoodFilling(fill, updateClient);~~
2318		}
2319
2320		~~void Player::setDrinkFilling(int fill, bool updateClient) {~~
2321	2320	if (_impl == NULL) {
2322	2321	if (!deployed)
…	…
2329	2328	method.executeWithVoidReturn();
2330	2329	} else
2331		((PlayerImplementation*) _impl)->set~~Drink~~Filling(fill, updateClient);
2332		}
2333
2334		void Player::~~changeFood~~Filling(int fill, bool updateClient) {
	2330	((PlayerImplementation*) _impl)->setFoodFilling(fill, updateClient);
	2331	}
	2332
	2333	void Player::setDrinkFilling(int fill, bool updateClient) {
2335	2334	if (_impl == NULL) {
2336	2335	if (!deployed)
…	…
2343	2342	method.executeWithVoidReturn();
2344	2343	} else
2345		((PlayerImplementation*) _impl)->~~changeFood~~Filling(fill, updateClient);
2346		}
2347
2348		void Player::change~~Drink~~Filling(int fill, bool updateClient) {
	2344	((PlayerImplementation*) _impl)->setDrinkFilling(fill, updateClient);
	2345	}
	2346
	2347	void Player::changeFoodFilling(int fill, bool updateClient) {
2349	2348	if (_impl == NULL) {
2350	2349	if (!deployed)
…	…
2357	2356	method.executeWithVoidReturn();
2358	2357	} else
	2358	((PlayerImplementation*) _impl)->changeFoodFilling(fill, updateClient);
	2359	}
	2360
	2361	void Player::changeDrinkFilling(int fill, bool updateClient) {
	2362	if (_impl == NULL) {
	2363	if (!deployed)
	2364	throw ObjectNotDeployedException(this);
	2365
	2366	DistributedMethod method(this, 184);
	2367	method.addSignedIntParameter(fill);
	2368	method.addBooleanParameter(updateClient);
	2369
	2370	method.executeWithVoidReturn();
	2371	} else
2359	2372	((PlayerImplementation*) _impl)->changeDrinkFilling(fill, updateClient);
2360	2373	}
…	…
2365	2378	throw ObjectNotDeployedException(this);
2366	2379
2367		DistributedMethod method(this, 184);
	2380	DistributedMethod method(this, 185);
2368	2381	method.addObjectParameter(attacker);
2369	2382
…	…
2378	2391	throw ObjectNotDeployedException(this);
2379	2392
2380		DistributedMethod method(this, 185);
	2393	DistributedMethod method(this, 186);
2381	2394
2382	2395	return method.executeWithSignedIntReturn();
…	…
2390	2403	throw ObjectNotDeployedException(this);
2391	2404
2392		DistributedMethod method(this, 186);
	2405	DistributedMethod method(this, 187);
2393	2406
2394	2407	return method.executeWithSignedIntReturn();
…	…
2402	2415	throw ObjectNotDeployedException(this);
2403	2416
2404		DistributedMethod method(this, 187);
	2417	DistributedMethod method(this, 188);
2405	2418
2406	2419	method.executeWithVoidReturn();
…	…
2414	2427	throw ObjectNotDeployedException(this);
2415	2428
2416		DistributedMethod method(this, 188);
	2429	DistributedMethod method(this, 189);
2417	2430
2418	2431	method.executeWithVoidReturn();
…	…
2426	2439	throw ObjectNotDeployedException(this);
2427	2440
2428		DistributedMethod method(this, 189);
	2441	DistributedMethod method(this, 190);
2429	2442	method.addUnsignedLongParameter(id);
2430	2443
…	…
2439	2452	throw ObjectNotDeployedException(this);
2440	2453
2441		DistributedMethod method(this, 190);
	2454	DistributedMethod method(this, 191);
2442	2455	method.addAsciiParameter(prof);
2443	2456
…	…
2452	2465	throw ObjectNotDeployedException(this);
2453	2466
2454		DistributedMethod method(this, 191);
	2467	DistributedMethod method(this, 192);
2455	2468	method.addAsciiParameter(hair);
2456	2469
…	…
2465	2478	throw ObjectNotDeployedException(this);
2466	2479
2467		DistributedMethod method(this, 192);
	2480	DistributedMethod method(this, 193);
2468	2481
2469	2482	method.executeWithVoidReturn();
…	…
2477	2490	throw ObjectNotDeployedException(this);
2478	2491
2479		DistributedMethod method(this, 193);
	2492	DistributedMethod method(this, 194);
2480	2493	method.addObjectParameter(obj);
2481	2494
…	…
2490	2503	throw ObjectNotDeployedException(this);
2491	2504
2492		DistributedMethod method(this, 194);
	2505	DistributedMethod method(this, 195);
2493	2506
2494	2507	method.executeWithVoidReturn();
…	…
2502	2515	throw ObjectNotDeployedException(this);
2503	2516
2504		DistributedMethod method(this, 195);
	2517	DistributedMethod method(this, 196);
2505	2518
2506	2519	method.executeWithVoidReturn();
…	…
2514	2527	throw ObjectNotDeployedException(this);
2515	2528
2516		DistributedMethod method(this, 196);
	2529	DistributedMethod method(this, 197);
2517	2530	method.addObjectParameter(client);
2518	2531
…	…
2527	2540	throw ObjectNotDeployedException(this);
2528	2541
2529		DistributedMethod method(this, 197);
	2542	DistributedMethod method(this, 198);
2530	2543
2531	2544	method.executeWithVoidReturn();
…	…
2539	2552	throw ObjectNotDeployedException(this);
2540	2553
2541		DistributedMethod method(this, 198);
	2554	DistributedMethod method(this, 199);
2542	2555
2543	2556	method.executeWithVoidReturn();
…	…
2551	2564	throw ObjectNotDeployedException(this);
2552	2565
2553		DistributedMethod method(this, ~~199~~);
	2566	DistributedMethod method(this, 200);
2554	2567
2555	2568	method.executeWithVoidReturn();
…	…
2563	2576	throw ObjectNotDeployedException(this);
2564	2577
2565		DistributedMethod method(this, 200);
	2578	DistributedMethod method(this, 201);
2566	2579
2567	2580	return method.executeWithBooleanReturn();
…	…
2575	2588	throw ObjectNotDeployedException(this);
2576	2589
2577		DistributedMethod method(this, 201);
	2590	DistributedMethod method(this, 202);
2578	2591
2579	2592	return method.executeWithBooleanReturn();
…	…
2587	2600	throw ObjectNotDeployedException(this);
2588	2601
2589		DistributedMethod method(this, 202);
	2602	DistributedMethod method(this, 203);
2590	2603
2591	2604	return method.executeWithBooleanReturn();
…	…
2599	2612	throw ObjectNotDeployedException(this);
2600	2613
2601		DistributedMethod method(this, 203);
	2614	DistributedMethod method(this, 204);
2602	2615	method.addUnsignedCharParameter(status);
2603	2616	method.addUnsignedIntParameter(timer);
…	…
2613	2626	throw ObjectNotDeployedException(this);
2614	2627
2615		DistributedMethod method(this, 204);
	2628	DistributedMethod method(this, 205);
2616	2629	method.addAsciiParameter(name);
2617	2630
…	…
2626	2639	throw ObjectNotDeployedException(this);
2627	2640
2628		DistributedMethod method(this, 205);
	2641	DistributedMethod method(this, 206);
2629	2642	method.addUnsignedCharParameter(id);
2630	2643
…	…
2639	2652	throw ObjectNotDeployedException(this);
2640	2653
2641		DistributedMethod method(this, 206);
	2654	DistributedMethod method(this, 207);
2642	2655	method.addAsciiParameter(loc);
2643	2656
…	…
2652	2665	throw ObjectNotDeployedException(this);
2653	2666
2654		DistributedMethod method(this, 207);
	2667	DistributedMethod method(this, 208);
2655	2668	method.addUnsignedIntParameter(shift);
2656	2669
…	…
2665	2678	throw ObjectNotDeployedException(this);
2666	2679
2667		DistributedMethod method(this, 208);
	2680	DistributedMethod method(this, 209);
2668	2681	method.addUnsignedIntParameter(bit);
2669	2682
…	…
2678	2691	throw ObjectNotDeployedException(this);
2679	2692
2680		DistributedMethod method(this, 209);
	2693	DistributedMethod method(this, 210);
2681	2694	method.addUnsignedIntParameter(badgeindex);
2682	2695
…	…
2691	2704	throw ObjectNotDeployedException(this);
2692	2705
2693		DistributedMethod method(this, 210);
	2706	DistributedMethod method(this, 211);
2694	2707
2695	2708	method.executeWithVoidReturn();
…	…
2703	2716	throw ObjectNotDeployedException(this);
2704	2717
2705		DistributedMethod method(this, 211);
	2718	DistributedMethod method(this, 212);
2706	2719
2707	2720	method.executeWithVoidReturn();
…	…
2715	2728	throw ObjectNotDeployedException(this);
2716	2729
2717		DistributedMethod method(this, 212);
	2730	DistributedMethod method(this, 213);
2718	2731	method.addSignedIntParameter(level);
2719	2732
…	…
2728	2741	throw ObjectNotDeployedException(this);
2729	2742
2730		DistributedMethod method(this, 213);
	2743	DistributedMethod method(this, 214);
2731	2744
2732	2745	return method.executeWithSignedIntReturn();
…	…
2736	2749
2737	2750	void Player::setLastTestPositionX(float pos) {
2738		~~if (_impl == NULL) {~~
2739		~~if (!deployed)~~
2740		~~throw ObjectNotDeployedException(this);~~
2741
2742		~~DistributedMethod method(this, 214);~~
2743		~~method.addFloatParameter(pos);~~
2744
2745		~~method.executeWithVoidReturn();~~
2746		~~} else~~
2747		~~((PlayerImplementation*) _impl)->setLastTestPositionX(pos);~~
2748		}
2749
2750		~~void Player::setLastTestPositionY(float pos) {~~
2751	2751	if (_impl == NULL) {
2752	2752	if (!deployed)
…	…
2758	2758	method.executeWithVoidReturn();
2759	2759	} else
	2760	((PlayerImplementation*) _impl)->setLastTestPositionX(pos);
	2761	}
	2762
	2763	void Player::setLastTestPositionY(float pos) {
	2764	if (_impl == NULL) {
	2765	if (!deployed)
	2766	throw ObjectNotDeployedException(this);
	2767
	2768	DistributedMethod method(this, 216);
	2769	method.addFloatParameter(pos);
	2770
	2771	method.executeWithVoidReturn();
	2772	} else
2760	2773	((PlayerImplementation*) _impl)->setLastTestPositionY(pos);
2761	2774	}
…	…
2766	2779	throw ObjectNotDeployedException(this);
2767	2780
2768		DistributedMethod method(this, 216);
	2781	DistributedMethod method(this, 217);
2769	2782	method.addUnsignedLongParameter(ID);
2770	2783
…	…
2779	2792	throw ObjectNotDeployedException(this);
2780	2793
2781		DistributedMethod method(this, 217);
	2794	DistributedMethod method(this, 218);
2782	2795
2783	2796	return method.executeWithUnsignedLongReturn();
…	…
2791	2804	throw ObjectNotDeployedException(this);
2792	2805
2793		DistributedMethod method(this, 218);
	2806	DistributedMethod method(this, 219);
2794	2807	method.addSignedIntParameter(anim);
2795	2808
…	…
2800	2813
2801	2814	void Player::sendMessage(BaseMessage* msg) {
2802		~~if (_impl == NULL) {~~
2803		~~if (!deployed)~~
2804		~~throw ObjectNotDeployedException(this);~~
2805
2806		~~DistributedMethod method(this, 219);~~
2807		~~method.addObjectParameter(msg);~~
2808
2809		~~method.executeWithVoidReturn();~~
2810		~~} else~~
2811		~~((PlayerImplementation*) _impl)->sendMessage(msg);~~
2812		}
2813
2814		~~void Player::sendMessage(StandaloneBaseMessage* msg) {~~
2815	2815	if (_impl == NULL) {
2816	2816	if (!deployed)
…	…
2825	2825	}
2826	2826
	2827	void Player::sendMessage(StandaloneBaseMessage* msg) {
	2828	if (_impl == NULL) {
	2829	if (!deployed)
	2830	throw ObjectNotDeployedException(this);
	2831
	2832	DistributedMethod method(this, 221);
	2833	method.addObjectParameter(msg);
	2834
	2835	method.executeWithVoidReturn();
	2836	} else
	2837	((PlayerImplementation*) _impl)->sendMessage(msg);
	2838	}
	2839
2827	2840	bool Player::isJedi() {
2828	2841	if (_impl == NULL) {
…	…
2830	2843	throw ObjectNotDeployedException(this);
2831	2844
2832		DistributedMethod method(this, 221);
	2845	DistributedMethod method(this, 222);
2833	2846
2834	2847	return method.executeWithBooleanReturn();
…	…
2842	2855	throw ObjectNotDeployedException(this);
2843	2856
2844		DistributedMethod method(this, 222);
	2857	DistributedMethod method(this, 223);
2845	2858
2846	2859	method.executeWithVoidReturn();
…	…
2854	2867	throw ObjectNotDeployedException(this);
2855	2868
2856		DistributedMethod method(this, 223);
	2869	DistributedMethod method(this, 224);
2857	2870
2858	2871	method.executeWithVoidReturn();
…	…
2866	2879	throw ObjectNotDeployedException(this);
2867	2880
2868		DistributedMethod method(this, 224);
	2881	DistributedMethod method(this, 225);
2869	2882	method.addUnsignedIntParameter(boxID);
2870	2883
…	…
2875	2888
2876	2889	bool Player::hasSuiBoxType(unsigned int boxTypeID) {
2877		~~if (_impl == NULL) {~~
2878		~~if (!deployed)~~
2879		~~throw ObjectNotDeployedException(this);~~
2880
2881		~~DistributedMethod method(this, 225);~~
2882		~~method.addUnsignedIntParameter(boxTypeID);~~
2883
2884		~~return method.executeWithBooleanReturn();~~
2885		~~} else~~
2886		~~return ((PlayerImplementation*) _impl)->hasSuiBoxType(boxTypeID);~~
2887		}
2888
2889		~~unsigned int Player::getSuiBoxFromType(unsigned int boxTypeID) {~~
2890	2890	if (_impl == NULL) {
2891	2891	if (!deployed)
…	…
2895	2895	method.addUnsignedIntParameter(boxTypeID);
2896	2896
	2897	return method.executeWithBooleanReturn();
	2898	} else
	2899	return ((PlayerImplementation*) _impl)->hasSuiBoxType(boxTypeID);
	2900	}
	2901
	2902	unsigned int Player::getSuiBoxFromType(unsigned int boxTypeID) {
	2903	if (_impl == NULL) {
	2904	if (!deployed)
	2905	throw ObjectNotDeployedException(this);
	2906
	2907	DistributedMethod method(this, 227);
	2908	method.addUnsignedIntParameter(boxTypeID);
	2909
2897	2910	return method.executeWithUnsignedIntReturn();
2898	2911	} else
…	…
2901	2914
2902	2915	void Player::removeSuiBox(unsigned int boxID) {
2903		~~if (_impl == NULL) {~~
2904		~~if (!deployed)~~
2905		~~throw ObjectNotDeployedException(this);~~
2906
2907		~~DistributedMethod method(this, 227);~~
2908		~~method.addUnsignedIntParameter(boxID);~~
2909
2910		~~method.executeWithVoidReturn();~~
2911		~~} else~~
2912		~~((PlayerImplementation*) _impl)->removeSuiBox(boxID);~~
2913		}
2914
2915		~~SuiBox* Player::getSuiBox(unsigned int boxID) {~~
2916	2916	if (_impl == NULL) {
2917	2917	if (!deployed)
…	…
2921	2921	method.addUnsignedIntParameter(boxID);
2922	2922
	2923	method.executeWithVoidReturn();
	2924	} else
	2925	((PlayerImplementation*) _impl)->removeSuiBox(boxID);
	2926	}
	2927
	2928	SuiBox* Player::getSuiBox(unsigned int boxID) {
	2929	if (_impl == NULL) {
	2930	if (!deployed)
	2931	throw ObjectNotDeployedException(this);
	2932
	2933	DistributedMethod method(this, 229);
	2934	method.addUnsignedIntParameter(boxID);
	2935
2923	2936	return (SuiBox*) method.executeWithObjectReturn();
2924	2937	} else
…	…
2931	2944	throw ObjectNotDeployedException(this);
2932	2945
2933		DistributedMethod method(this, 229);
	2946	DistributedMethod method(this, 230);
2934	2947	method.addObjectParameter(sui);
2935	2948
…	…
2944	2957	throw ObjectNotDeployedException(this);
2945	2958
2946		DistributedMethod method(this, 230);
	2959	DistributedMethod method(this, 231);
2947	2960	method.addUnsignedIntParameter(type);
2948	2961
…	…
2957	2970	throw ObjectNotDeployedException(this);
2958	2971
2959		DistributedMethod method(this, 231);
	2972	DistributedMethod method(this, 232);
2960	2973
2961	2974	return method.executeWithBooleanReturn();
…	…
2969	2982	throw ObjectNotDeployedException(this);
2970	2983
2971		DistributedMethod method(this, 232);
	2984	DistributedMethod method(this, 233);
2972	2985
2973	2986	return method.executeWithBooleanReturn();
…	…
2981	2994	throw ObjectNotDeployedException(this);
2982	2995
2983		DistributedMethod method(this, 233);
	2996	DistributedMethod method(this, 234);
2984	2997
2985	2998	return method.executeWithBooleanReturn();
…	…
2993	3006	throw ObjectNotDeployedException(this);
2994	3007
2995		DistributedMethod method(this, 234);
	3008	DistributedMethod method(this, 235);
2996	3009
2997	3010	return method.executeWithBooleanReturn();
…	…
3005	3018	throw ObjectNotDeployedException(this);
3006	3019
3007		DistributedMethod method(this, 235);
	3020	DistributedMethod method(this, 236);
3008	3021
3009	3022	return method.executeWithBooleanReturn();
…	…
3017	3030	throw ObjectNotDeployedException(this);
3018	3031
3019		DistributedMethod method(this, 236);
	3032	DistributedMethod method(this, 237);
3020	3033
3021	3034	return (PlayerObject*) method.executeWithObjectReturn();
…	…
3029	3042	throw ObjectNotDeployedException(this);
3030	3043
3031		DistributedMethod method(this, 237);
	3044	DistributedMethod method(this, 238);
3032	3045
3033	3046	return (CreatureObject*) method.executeWithObjectReturn();
…	…
3041	3054	throw ObjectNotDeployedException(this);
3042	3055
3043		DistributedMethod method(this, 238);
	3056	DistributedMethod method(this, 239);
3044	3057
3045	3058	method.executeWithAsciiReturn(_return_getFirstName);
…	…
3054	3067	throw ObjectNotDeployedException(this);
3055	3068
3056		DistributedMethod method(this, 239);
	3069	DistributedMethod method(this, 240);
3057	3070
3058	3071	method.executeWithAsciiReturn(_return_getLastName);
…	…
3067	3080	throw ObjectNotDeployedException(this);
3068	3081
3069		DistributedMethod method(this, 240);
	3082	DistributedMethod method(this, 241);
3070	3083
3071	3084	method.executeWithAsciiReturn(_return_getFirstNameProper);
…	…
3080	3093	throw ObjectNotDeployedException(this);
3081	3094
3082		DistributedMethod method(this, 241);
	3095	DistributedMethod method(this, 242);
3083	3096
3084	3097	method.executeWithAsciiReturn(_return_getRaceFileName);
…	…
3093	3106	throw ObjectNotDeployedException(this);
3094	3107
3095		DistributedMethod method(this, 242);
	3108	DistributedMethod method(this, 243);
3096	3109
3097	3110	return method.executeWithUnsignedCharReturn();
…	…
3105	3118	throw ObjectNotDeployedException(this);
3106	3119
3107		DistributedMethod method(this, 243);
	3120	DistributedMethod method(this, 244);
3108	3121
3109	3122	method.executeWithUnicodeReturn(_return_getBiography);
…	…
3118	3131	throw ObjectNotDeployedException(this);
3119	3132
3120		DistributedMethod method(this, 244);
	3133	DistributedMethod method(this, 245);
3121	3134
3122	3135	return method.executeWithUnsignedLongReturn();
…	…
3130	3143	throw ObjectNotDeployedException(this);
3131	3144
3132		DistributedMethod method(this, 245);
	3145	DistributedMethod method(this, 246);
3133	3146
3134	3147	method.executeWithAsciiReturn(_return_getStartingProfession);
…	…
3143	3156	throw ObjectNotDeployedException(this);
3144	3157
3145		DistributedMethod method(this, 246);
	3158	DistributedMethod method(this, 247);
3146	3159
3147	3160	return method.executeWithSignedIntReturn();
…	…
3155	3168	throw ObjectNotDeployedException(this);
3156	3169
3157		DistributedMethod method(this, 247);
	3170	DistributedMethod method(this, 248);
3158	3171
3159	3172	method.executeWithAsciiReturn(_return_getHairObject);
…	…
3168	3181	throw ObjectNotDeployedException(this);
3169	3182
3170		DistributedMethod method(this, 248);
	3183	DistributedMethod method(this, 249);
3171	3184
3172	3185	return (ZoneClientSession*) method.executeWithObjectReturn();
…	…
3180	3193	throw ObjectNotDeployedException(this);
3181	3194
3182		DistributedMethod method(this, 249);
	3195	DistributedMethod method(this, 250);
3183	3196
3184	3197	return (GroupObject*) method.executeWithObjectReturn();
…	…
3192	3205	throw ObjectNotDeployedException(this);
3193	3206
3194		DistributedMethod method(this, 250);
	3207	DistributedMethod method(this, 251);
3195	3208
3196	3209	return method.executeWithSignedIntReturn();
…	…
3200	3213
3201	3214	void Player::setPvpRating(int value) {
3202		~~if (_impl == NULL) {~~
3203		~~if (!deployed)~~
3204		~~throw ObjectNotDeployedException(this);~~
3205
3206		~~DistributedMethod method(this, 251);~~
3207		~~method.addSignedIntParameter(value);~~
3208
3209		~~method.executeWithVoidReturn();~~
3210		~~} else~~
3211		~~((PlayerImplementation*) _impl)->setPvpRating(value);~~
3212		}
3213
3214		~~void Player::increasePvpRating(int value) {~~
3215	3215	if (_impl == NULL) {
3216	3216	if (!deployed)
…	…
3222	3222	method.executeWithVoidReturn();
3223	3223	} else
3224		((PlayerImplementation*) _impl)->~~increase~~PvpRating(value);
3225		}
3226
3227		void Player::decreasePvpRating(int value) {
	3224	((PlayerImplementation*) _impl)->setPvpRating(value);
	3225	}
	3226
	3227	void Player::increasePvpRating(int value) {
3228	3228	if (_impl == NULL) {
3229	3229	if (!deployed)
…	…
3235	3235	method.executeWithVoidReturn();
3236	3236	} else
	3237	((PlayerImplementation*) _impl)->increasePvpRating(value);
	3238	}
	3239
	3240	void Player::decreasePvpRating(int value) {
	3241	if (_impl == NULL) {
	3242	if (!deployed)
	3243	throw ObjectNotDeployedException(this);
	3244
	3245	DistributedMethod method(this, 254);
	3246	method.addSignedIntParameter(value);
	3247
	3248	method.executeWithVoidReturn();
	3249	} else
3237	3250	((PlayerImplementation*) _impl)->decreasePvpRating(value);
3238	3251	}
…	…
3243	3256	throw ObjectNotDeployedException(this);
3244	3257
3245		DistributedMethod method(this, 254);
	3258	DistributedMethod method(this, 255);
3246	3259
3247	3260	method.executeWithVoidReturn();
…	…
3255	3268	throw ObjectNotDeployedException(this);
3256	3269
3257		DistributedMethod method(this, 255);
	3270	DistributedMethod method(this, 256);
3258	3271
3259	3272	return method.executeWithSignedIntReturn();
…	…
3267	3280	throw ObjectNotDeployedException(this);
3268	3281
3269		DistributedMethod method(this, 256);
	3282	DistributedMethod method(this, 257);
3270	3283
3271	3284	return method.executeWithSignedIntReturn();
…	…
3279	3292	throw ObjectNotDeployedException(this);
3280	3293
3281		DistributedMethod method(this, 257);
	3294	DistributedMethod method(this, 258);
3282	3295	method.addSignedIntParameter(idx);
3283	3296
…	…
3293	3306	throw ObjectNotDeployedException(this);
3294	3307
3295		DistributedMethod method(this, 258);
	3308	DistributedMethod method(this, 259);
3296	3309	method.addAsciiParameter(certification);
3297	3310
…	…
3306	3319	throw ObjectNotDeployedException(this);
3307	3320
3308		DistributedMethod method(this, 259);
	3321	DistributedMethod method(this, 260);
3309	3322
3310	3323	return method.executeWithSignedIntReturn();
…	…
3318	3331	throw ObjectNotDeployedException(this);
3319	3332
3320		DistributedMethod method(this, 260);
	3333	DistributedMethod method(this, 261);
3321	3334
3322	3335	return method.executeWithBooleanReturn();
…	…
3330	3343	throw ObjectNotDeployedException(this);
3331	3344
3332		DistributedMethod method(this, 261);
	3345	DistributedMethod method(this, 262);
3333	3346
3334	3347	return method.executeWithBooleanReturn();
…	…
3342	3355	throw ObjectNotDeployedException(this);
3343	3356
3344		DistributedMethod method(this, 262);
	3357	DistributedMethod method(this, 263);
3345	3358
3346	3359	method.executeWithAsciiReturn(_return_getInputBoxReturnBuffer);
…	…
3355	3368	throw ObjectNotDeployedException(this);
3356	3369
3357		DistributedMethod method(this, 263);
	3370	DistributedMethod method(this, 264);
3358	3371
3359	3372	return method.executeWithUnsignedIntReturn();
…	…
3367	3380	throw ObjectNotDeployedException(this);
3368	3381
3369		DistributedMethod method(this, 264);
	3382	DistributedMethod method(this, 265);
3370	3383	method.addSignedIntParameter(tcb);
3371	3384
…	…
3380	3393	throw ObjectNotDeployedException(this);
3381	3394
3382		DistributedMethod method(this, 265);
	3395	DistributedMethod method(this, 266);
3383	3396	method.addSignedIntParameter(tms);
3384	3397
…	…
3393	3406	throw ObjectNotDeployedException(this);
3394	3407
3395		DistributedMethod method(this, 266);
	3408	DistributedMethod method(this, 267);
3396	3409	method.addAsciiParameter(tck);
3397	3410
…	…
3406	3419	throw ObjectNotDeployedException(this);
3407	3420
3408		DistributedMethod method(this, 267);
	3421	DistributedMethod method(this, 268);
3409	3422	method.addAsciiParameter(tmk);
3410	3423
…	…
3419	3432	throw ObjectNotDeployedException(this);
3420	3433
3421		DistributedMethod method(this, 268);
	3434	DistributedMethod method(this, 269);
3422	3435	method.addAsciiParameter(tck);
3423	3436
…	…
3432	3445	throw ObjectNotDeployedException(this);
3433	3446
3434		DistributedMethod method(this, 269);
	3447	DistributedMethod method(this, 270);
3435	3448	method.addAsciiParameter(tmp);
3436	3449
…	…
3445	3458	throw ObjectNotDeployedException(this);
3446	3459
3447		DistributedMethod method(this, 270);
	3460	DistributedMethod method(this, 271);
3448	3461	method.addAsciiParameter(tmk);
3449	3462
…	…
3458	3471	throw ObjectNotDeployedException(this);
3459	3472
3460		DistributedMethod method(this, 271);
	3473	DistributedMethod method(this, 272);
3461	3474
3462	3475	return (CraftingTool*) method.executeWithObjectReturn();
…	…
3470	3483	throw ObjectNotDeployedException(this);
3471	3484
3472		DistributedMethod method(this, 272);
	3485	DistributedMethod method(this, 273);
3473	3486	method.addSignedIntParameter(type);
3474	3487	method.addBooleanParameter(doLock);
…	…
3484	3497	throw ObjectNotDeployedException(this);
3485	3498
3486		DistributedMethod method(this, 273);
	3499	DistributedMethod method(this, 274);
3487	3500	method.addObjectParameter(ct);
3488	3501
…	…
3497	3510	throw ObjectNotDeployedException(this);
3498	3511
3499		DistributedMethod method(this, 274);
	3512	DistributedMethod method(this, 275);
3500	3513
3501	3514	method.executeWithVoidReturn();
…	…
3509	3522	throw ObjectNotDeployedException(this);
3510	3523
3511		DistributedMethod method(this, 275);
	3524	DistributedMethod method(this, 276);
3512	3525	method.addObjectParameter(ct);
3513	3526	method.addObjectParameter(ds);
…	…
3523	3536	throw ObjectNotDeployedException(this);
3524	3537
3525		DistributedMethod method(this, 276);
	3538	DistributedMethod method(this, 277);
3526	3539	method.addObjectParameter(tano);
3527	3540	method.addSignedIntParameter(slot);
…	…
3538	3551	throw ObjectNotDeployedException(this);
3539	3552
3540		DistributedMethod method(this, 277);
	3553	DistributedMethod method(this, 278);
3541	3554	method.addUnsignedLongParameter(resID);
3542	3555	method.addSignedIntParameter(slot);
…	…
3553	3566	throw ObjectNotDeployedException(this);
3554	3567
3555		DistributedMethod method(this, 278);
	3568	DistributedMethod method(this, 279);
3556	3569	method.addAsciiParameter(test);
3557	3570
…	…
3566	3579	throw ObjectNotDeployedException(this);
3567	3580
3568		DistributedMethod method(this, 279);
	3581	DistributedMethod method(this, 280);
3569	3582	method.addAsciiParameter(name);
3570	3583	method.addSignedIntParameter(condition);
…	…
3580	3593	throw ObjectNotDeployedException(this);
3581	3594
3582		~~DistributedMethod method(this, 280);~~
3583		~~method.addAsciiParameter(count);~~
3584
3585		~~method.executeWithVoidReturn();~~
3586		~~} else~~
3587		~~((PlayerImplementation*) _impl)->createPrototype(count);~~
3588		}
3589
3590		~~void Player::createSchematic(string& count) {~~
3591		~~if (_impl == NULL) {~~
3592		~~if (!deployed)~~
3593		~~throw ObjectNotDeployedException(this);~~
3594
3595	3595	DistributedMethod method(this, 281);
3596	3596	method.addAsciiParameter(count);
…	…
3598	3598	method.executeWithVoidReturn();
3599	3599	} else
	3600	((PlayerImplementation*) _impl)->createPrototype(count);
	3601	}
	3602
	3603	void Player::createSchematic(string& count) {
	3604	if (_impl == NULL) {
	3605	if (!deployed)
	3606	throw ObjectNotDeployedException(this);
	3607
	3608	DistributedMethod method(this, 282);
	3609	method.addAsciiParameter(count);
	3610
	3611	method.executeWithVoidReturn();
	3612	} else
3600	3613	((PlayerImplementation*) _impl)->createSchematic(count);
3601	3614	}
…	…
3606	3619	throw ObjectNotDeployedException(this);
3607	3620
3608		DistributedMethod method(this, 282);
	3621	DistributedMethod method(this, 283);
3609	3622	method.addSignedIntParameter(count);
3610	3623	method.addSignedIntParameter(numRowsAttempted);
…	…
3621	3634	throw ObjectNotDeployedException(this);
3622	3635
3623		DistributedMethod method(this, 283);
	3636	DistributedMethod method(this, 284);
3624	3637
3625	3638	method.executeWithVoidReturn();
…	…
3629	3642
3630	3643	void Player::addDraftSchematicsFromGroupName(const string& schematicGroupName) {
3631		~~if (_impl == NULL) {~~
3632		~~if (!deployed)~~
3633		~~throw ObjectNotDeployedException(this);~~
3634
3635		~~DistributedMethod method(this, 284);~~
3636		~~method.addAsciiParameter(schematicGroupName);~~
3637
3638		~~method.executeWithVoidReturn();~~
3639		~~} else~~
3640		~~((PlayerImplementation*) _impl)->addDraftSchematicsFromGroupName(schematicGroupName);~~
3641		}
3642
3643		~~void Player::subtractDraftSchematicsFromGroupName(const string& schematicGroupName) {~~
3644	3644	if (_impl == NULL) {
3645	3645	if (!deployed)
…	…
3651	3651	method.executeWithVoidReturn();
3652	3652	} else
	3653	((PlayerImplementation*) _impl)->addDraftSchematicsFromGroupName(schematicGroupName);
	3654	}
	3655
	3656	void Player::subtractDraftSchematicsFromGroupName(const string& schematicGroupName) {
	3657	if (_impl == NULL) {
	3658	if (!deployed)
	3659	throw ObjectNotDeployedException(this);
	3660
	3661	DistributedMethod method(this, 286);
	3662	method.addAsciiParameter(schematicGroupName);
	3663
	3664	method.executeWithVoidReturn();
	3665	} else
3653	3666	((PlayerImplementation*) _impl)->subtractDraftSchematicsFromGroupName(schematicGroupName);
3654	3667	}
3655	3668
3656	3669	void Player::addDraftSchematic(DraftSchematic* ds) {
3657		~~if (_impl == NULL) {~~
3658		~~if (!deployed)~~
3659		~~throw ObjectNotDeployedException(this);~~
3660
3661		~~DistributedMethod method(this, 286);~~
3662		~~method.addObjectParameter(ds);~~
3663
3664		~~method.executeWithVoidReturn();~~
3665		~~} else~~
3666		~~((PlayerImplementation*) _impl)->addDraftSchematic(ds);~~
3667		}
3668
3669		~~void Player::subtractDraftSchematic(DraftSchematic* ds) {~~
3670	3670	if (_impl == NULL) {
3671	3671	if (!deployed)
…	…
3677	3677	method.executeWithVoidReturn();
3678	3678	} else
	3679	((PlayerImplementation*) _impl)->addDraftSchematic(ds);
	3680	}
	3681
	3682	void Player::subtractDraftSchematic(DraftSchematic* ds) {
	3683	if (_impl == NULL) {
	3684	if (!deployed)
	3685	throw ObjectNotDeployedException(this);
	3686
	3687	DistributedMethod method(this, 288);
	3688	method.addObjectParameter(ds);
	3689
	3690	method.executeWithVoidReturn();
	3691	} else
3679	3692	((PlayerImplementation*) _impl)->subtractDraftSchematic(ds);
3680	3693	}
…	…
3685	3698	throw ObjectNotDeployedException(this);
3686	3699
3687		DistributedMethod method(this, 288);
	3700	DistributedMethod method(this, 289);
3688	3701
3689	3702	return method.executeWithUnsignedIntReturn();
…	…
3697	3710	throw ObjectNotDeployedException(this);
3698	3711
3699		DistributedMethod method(this, 289);
	3712	DistributedMethod method(this, 290);
3700	3713	method.addUnsignedIntParameter(count);
3701	3714
…	…
3710	3723	throw ObjectNotDeployedException(this);
3711	3724
3712		DistributedMethod method(this, 290);
	3725	DistributedMethod method(this, 291);
3713	3726	method.addUnsignedIntParameter(schematicID);
3714	3727
…	…
3723	3736	throw ObjectNotDeployedException(this);
3724	3737
3725		DistributedMethod method(this, 291);
	3738	DistributedMethod method(this, 292);
3726	3739	method.addSignedIntParameter(index);
3727	3740
…	…
3736	3749	throw ObjectNotDeployedException(this);
3737	3750
3738		DistributedMethod method(this, 292);
	3751	DistributedMethod method(this, 293);
3739	3752
3740	3753	return method.executeWithBooleanReturn();
…	…
3748	3761	throw ObjectNotDeployedException(this);
3749	3762
3750		DistributedMethod method(this, 293);
	3763	DistributedMethod method(this, 294);
3751	3764
3752	3765	return (Datapad*) method.executeWithObjectReturn();
…	…
3760	3773	throw ObjectNotDeployedException(this);
3761	3774
3762		DistributedMethod method(this, 294);
	3775	DistributedMethod method(this, 295);
3763	3776
3764	3777	return method.executeWithUnsignedLongReturn();
…	…
3772	3785	throw ObjectNotDeployedException(this);
3773	3786
3774		DistributedMethod method(this, 295);
	3787	DistributedMethod method(this, 296);
3775	3788
3776	3789	return method.executeWithUnsignedIntReturn();
…	…
3784	3797	throw ObjectNotDeployedException(this);
3785	3798
3786		DistributedMethod method(this, 296);
	3799	DistributedMethod method(this, 297);
3787	3800
3788	3801	return method.executeWithFloatReturn();
…	…
3796	3809	throw ObjectNotDeployedException(this);
3797	3810
3798		DistributedMethod method(this, 297);
	3811	DistributedMethod method(this, 298);
3799	3812
3800	3813	return method.executeWithFloatReturn();
…	…
3808	3821	throw ObjectNotDeployedException(this);
3809	3822
3810		DistributedMethod method(this, 298);
	3823	DistributedMethod method(this, 299);
3811	3824
3812	3825	return method.executeWithUnsignedIntReturn();
…	…
3820	3833	throw ObjectNotDeployedException(this);
3821	3834
3822		DistributedMethod method(this, ~~299~~);
	3835	DistributedMethod method(this, 300);
3823	3836
3824	3837	return method.executeWithUnsignedIntReturn();
…	…
3832	3845	throw ObjectNotDeployedException(this);
3833	3846
3834		DistributedMethod method(this, 300);
	3847	DistributedMethod method(this, 301);
3835	3848
3836	3849	return method.executeWithBooleanReturn();
…	…
3844	3857	throw ObjectNotDeployedException(this);
3845	3858
3846		DistributedMethod method(this, 301);
	3859	DistributedMethod method(this, 302);
3847	3860
3848	3861	return method.executeWithUnsignedLongReturn();
…	…
3856	3869	throw ObjectNotDeployedException(this);
3857	3870
3858		DistributedMethod method(this, 302);
	3871	DistributedMethod method(this, 303);
3859	3872	method.addUnsignedLongParameter(oid);
3860	3873
…	…
3869	3882	throw ObjectNotDeployedException(this);
3870	3883
3871		DistributedMethod method(this, 303);
	3884	DistributedMethod method(this, 304);
3872	3885
3873	3886	return (SurveyTool*) method.executeWithObjectReturn();
…	…
3881	3894	throw ObjectNotDeployedException(this);
3882	3895
3883		DistributedMethod method(this, 304);
	3896	DistributedMethod method(this, 305);
3884	3897
3885	3898	return (SurveyTool*) method.executeWithObjectReturn();
…	…
3889	3902
3890	3903	void Player::setSurveyTool(SurveyTool* sTool) {
3891		~~if (_impl == NULL) {~~
3892		~~if (!deployed)~~
3893		~~throw ObjectNotDeployedException(this);~~
3894
3895		~~DistributedMethod method(this, 305);~~
3896		~~method.addObjectParameter(sTool);~~
3897
3898		~~method.executeWithVoidReturn();~~
3899		~~} else~~
3900		~~((PlayerImplementation*) _impl)->setSurveyTool(sTool);~~
3901		}
3902
3903		~~void Player::setSampleTool(SurveyTool* sTool) {~~
3904	3904	if (_impl == NULL) {
3905	3905	if (!deployed)
…	…
3911	3911	method.executeWithVoidReturn();
3912	3912	} else
	3913	((PlayerImplementation*) _impl)->setSurveyTool(sTool);
	3914	}
	3915
	3916	void Player::setSampleTool(SurveyTool* sTool) {
	3917	if (_impl == NULL) {
	3918	if (!deployed)
	3919	throw ObjectNotDeployedException(this);
	3920
	3921	DistributedMethod method(this, 307);
	3922	method.addObjectParameter(sTool);
	3923
	3924	method.executeWithVoidReturn();
	3925	} else
3913	3926	((PlayerImplementation*) _impl)->setSampleTool(sTool);
3914	3927	}
…	…
3919	3932	throw ObjectNotDeployedException(this);
3920	3933
3921		DistributedMethod method(this, 307);
	3934	DistributedMethod method(this, 308);
3922	3935	method.addObjectParameter(id);
3923	3936
…	…
3932	3945	throw ObjectNotDeployedException(this);
3933	3946
3934		DistributedMethod method(this, 308);
	3947	DistributedMethod method(this, 309);
3935	3948
3936	3949	return (WaypointObject*) method.executeWithObjectReturn();
…	…
3944	3957	throw ObjectNotDeployedException(this);
3945	3958
3946		DistributedMethod method(this, 309);
	3959	DistributedMethod method(this, 310);
3947	3960
3948	3961	return method.executeWithBooleanReturn();
…	…
3956	3969	throw ObjectNotDeployedException(this);
3957	3970
3958		DistributedMethod method(this, 310);
	3971	DistributedMethod method(this, 311);
3959	3972
3960	3973	return method.executeWithBooleanReturn();
…	…
3968	3981	throw ObjectNotDeployedException(this);
3969	3982
3970		DistributedMethod method(this, 311);
	3983	DistributedMethod method(this, 312);
3971	3984
3972	3985	method.executeWithVoidReturn();
…	…
3980	3993	throw ObjectNotDeployedException(this);
3981	3994
3982		DistributedMethod method(this, 312);
	3995	DistributedMethod method(this, 313);
3983	3996
3984	3997	method.executeWithVoidReturn();
…	…
3988	4001
3989	4002	void Player::setSurveyEvent(string& resourcename) {
3990		~~if (_impl == NULL) {~~
3991		~~if (!deployed)~~
3992		~~throw ObjectNotDeployedException(this);~~
3993
3994		~~DistributedMethod method(this, 313);~~
3995		~~method.addAsciiParameter(resourcename);~~
3996
3997		~~method.executeWithVoidReturn();~~
3998		~~} else~~
3999		~~((PlayerImplementation*) _impl)->setSurveyEvent(resourcename);~~
4000		}
4001
4002		~~void Player::setSampleEvent(string& resourcename, bool firstTime) {~~
4003	4003	if (_impl == NULL) {
4004	4004	if (!deployed)
…	…
4007	4007	DistributedMethod method(this, 314);
4008	4008	method.addAsciiParameter(resourcename);
	4009
	4010	method.executeWithVoidReturn();
	4011	} else
	4012	((PlayerImplementation*) _impl)->setSurveyEvent(resourcename);
	4013	}
	4014
	4015	void Player::setSampleEvent(string& resourcename, bool firstTime) {
	4016	if (_impl == NULL) {
	4017	if (!deployed)
	4018	throw ObjectNotDeployedException(this);
	4019
	4020	DistributedMethod method(this, 315);
	4021	method.addAsciiParameter(resourcename);
4009	4022	method.addBooleanParameter(firstTime);
4010	4023
…	…
4019	4032	throw ObjectNotDeployedException(this);
4020	4033
4021		DistributedMethod method(this, 315);
	4034	DistributedMethod method(this, 316);
4022	4035	method.addBooleanParameter(val);
4023	4036
…	…
4032	4045	throw ObjectNotDeployedException(this);
4033	4046
4034		DistributedMethod method(this, 316);
	4047	DistributedMethod method(this, 317);
4035	4048
4036	4049	return method.executeWithBooleanReturn();
…	…
4044	4057	throw ObjectNotDeployedException(this);
4045	4058
4046		DistributedMethod method(this, 317);
	4059	DistributedMethod method(this, 318);
4047	4060
4048	4061	method.executeWithVoidReturn();
…	…
4056	4069	throw ObjectNotDeployedException(this);
4057	4070
4058		DistributedMethod method(this, 318);
	4071	DistributedMethod method(this, 319);
4059	4072
4060	4073	method.executeWithVoidReturn();
…	…
4068	4081	throw ObjectNotDeployedException(this);
4069	4082
4070		DistributedMethod method(this, 319);
	4083	DistributedMethod method(this, 320);
4071	4084
4072	4085	method.executeWithVoidReturn();
…	…
4080	4093	throw ObjectNotDeployedException(this);
4081	4094
4082		DistributedMethod method(this, 320);
	4095	DistributedMethod method(this, 321);
4083	4096
4084	4097	return method.executeWithBooleanReturn();
…	…
4092	4105	throw ObjectNotDeployedException(this);
4093	4106
4094		DistributedMethod method(this, 321);
	4107	DistributedMethod method(this, 322);
4095	4108
4096	4109	return method.executeWithBooleanReturn();
…	…
4104	4117	throw ObjectNotDeployedException(this);
4105	4118
4106		DistributedMethod method(this, 322);
	4119	DistributedMethod method(this, 323);
4107	4120	method.addAsciiParameter(mailsender);
4108	4121	method.addUnicodeParameter(subjectSender);
…	…
4120	4133	throw ObjectNotDeployedException(this);
4121	4134
4122		DistributedMethod method(this, 323);
	4135	DistributedMethod method(this, 324);
4123	4136
4124	4137	method.executeWithVoidReturn();
…	…
4132	4145	throw ObjectNotDeployedException(this);
4133	4146
4134		DistributedMethod method(this, 324);
	4147	DistributedMethod method(this, 325);
4135	4148
4136	4149	method.executeWithVoidReturn();
…	…
4144	4157	throw ObjectNotDeployedException(this);
4145	4158
4146		DistributedMethod method(this, 325);
	4159	DistributedMethod method(this, 326);
4147	4160	method.addAsciiParameter(conv);
4148	4161
…	…
4157	4170	throw ObjectNotDeployedException(this);
4158	4171
4159		DistributedMethod method(this, 326);
	4172	DistributedMethod method(this, 327);
4160	4173	method.addAsciiParameter(mess);
4161	4174
…	…
4170	4183	throw ObjectNotDeployedException(this);
4171	4184
4172		DistributedMethod method(this, 327);
	4185	DistributedMethod method(this, 328);
4173	4186
4174	4187	method.executeWithAsciiReturn(_return_getLastNpcConvStr);
…	…
4183	4196	throw ObjectNotDeployedException(this);
4184	4197
4185		DistributedMethod method(this, 328);
	4198	DistributedMethod method(this, 329);
4186	4199
4187	4200	method.executeWithAsciiReturn(_return_getLastNpcConvMessStr);
…	…
4191	4204	}
4192	4205
	4206	string& Player::getLastNpcConvOption(int idx) {
	4207	if (_impl == NULL) {
	4208	if (!deployed)
	4209	throw ObjectNotDeployedException(this);
	4210
	4211	DistributedMethod method(this, 330);
	4212	method.addSignedIntParameter(idx);
	4213
	4214	method.executeWithAsciiReturn(_return_getLastNpcConvOption);
	4215	return _return_getLastNpcConvOption;
	4216	} else
	4217	return ((PlayerImplementation*) _impl)->getLastNpcConvOption(idx);
	4218	}
	4219
	4220	void Player::addLastNpcConvOptions(const string& option) {
	4221	if (_impl == NULL) {
	4222	if (!deployed)
	4223	throw ObjectNotDeployedException(this);
	4224
	4225	DistributedMethod method(this, 331);
	4226	method.addAsciiParameter(option);
	4227
	4228	method.executeWithVoidReturn();
	4229	} else
	4230	((PlayerImplementation*) _impl)->addLastNpcConvOptions(option);
	4231	}
	4232
	4233	void Player::clearLastNpcConvOptions() {
	4234	if (_impl == NULL) {
	4235	if (!deployed)
	4236	throw ObjectNotDeployedException(this);
	4237
	4238	DistributedMethod method(this, 332);
	4239
	4240	method.executeWithVoidReturn();
	4241	} else
	4242	((PlayerImplementation*) _impl)->clearLastNpcConvOptions();
	4243	}
	4244
	4245	int Player::countLastNpcConvOptions() {
	4246	if (_impl == NULL) {
	4247	if (!deployed)
	4248	throw ObjectNotDeployedException(this);
	4249
	4250	DistributedMethod method(this, 333);
	4251
	4252	return method.executeWithSignedIntReturn();
	4253	} else
	4254	return ((PlayerImplementation*) _impl)->countLastNpcConvOptions();
	4255	}
	4256
4193	4257	void Player::setInputBoxReturnBuffer(const string& message) {
4194	4258	if (_impl == NULL) {
…	…
4196	4260	throw ObjectNotDeployedException(this);
4197	4261
4198		DistributedMethod method(this, 329);
	4262	DistributedMethod method(this, 334);
4199	4263	method.addAsciiParameter(message);
4200	4264
…	…
4209	4273	throw ObjectNotDeployedException(this);
4210	4274
4211		DistributedMethod method(this, 330);
	4275	DistributedMethod method(this, 335);
4212	4276	method.addBooleanParameter(guildLeader);
4213	4277
…	…
4222	4286	throw ObjectNotDeployedException(this);
4223	4287
4224		DistributedMethod method(this, 331);
	4288	DistributedMethod method(this, 336);
4225	4289
4226	4290	method.executeWithVoidReturn();
…	…
4234	4298	throw ObjectNotDeployedException(this);
4235	4299
4236		DistributedMethod method(this, 332);
	4300	DistributedMethod method(this, 337);
4237	4301	method.addUnsignedIntParameter(bit);
4238	4302
…	…
4247	4311	throw ObjectNotDeployedException(this);
4248	4312
4249		DistributedMethod method(this, 333);
	4313	DistributedMethod method(this, 338);
4250	4314
4251	4315	return method.executeWithUnsignedIntReturn();
…	…
4259	4323	throw ObjectNotDeployedException(this);
4260	4324
4261		DistributedMethod method(this, 334);
	4325	DistributedMethod method(this, 339);
4262	4326	method.addUnsignedIntParameter(bit);
4263	4327	method.addBooleanParameter(updateClient);
…	…
4273	4337	throw ObjectNotDeployedException(this);
4274	4338
4275		DistributedMethod method(this, 335);
	4339	DistributedMethod method(this, 340);
4276	4340	method.addUnsignedIntParameter(bit);
4277	4341
…	…
4286	4350	throw ObjectNotDeployedException(this);
4287	4351
4288		DistributedMethod method(this, 336);
	4352	DistributedMethod method(this, 341);
4289	4353	method.addUnsignedIntParameter(bit);
4290	4354	method.addBooleanParameter(updateClient);
…	…
4300	4364	throw ObjectNotDeployedException(this);
4301	4365
4302		DistributedMethod method(this, 337);
	4366	DistributedMethod method(this, 342);
4303	4367	method.addAsciiParameter(faction);
4304	4368
…	…
4313	4377	throw ObjectNotDeployedException(this);
4314	4378
4315		DistributedMethod method(this, 338);
	4379	DistributedMethod method(this, 343);
4316	4380	method.addAsciiParameter(faction);
4317	4381	method.addUnsignedIntParameter(points);
…	…
4327	4391	throw ObjectNotDeployedException(this);
4328	4392
4329		DistributedMethod method(this, 339);
	4393	DistributedMethod method(this, 344);
4330	4394	method.addAsciiParameter(faction);
4331	4395	method.addUnsignedIntParameter(points);
…	…
4341	4405	throw ObjectNotDeployedException(this);
4342	4406
4343		DistributedMethod method(this, 340);
	4407	DistributedMethod method(this, 345);
4344	4408
4345	4409	return method.executeWithSignedIntReturn();
…	…
4353	4417	throw ObjectNotDeployedException(this);
4354	4418
4355		DistributedMethod method(this, 341);
	4419	DistributedMethod method(this, 346);
4356	4420	method.addSignedIntParameter(status);
4357	4421
…	…
4366	4430	throw ObjectNotDeployedException(this);
4367	4431
4368		DistributedMethod method(this, 342);
	4432	DistributedMethod method(this, 347);
4369	4433
4370	4434	return (FactionPointList*) method.executeWithObjectReturn();
…	…
4378	4442	throw ObjectNotDeployedException(this);
4379	4443
4380		DistributedMethod method(this, 343);
	4444	DistributedMethod method(this, 348);
4381	4445	method.addAsciiParameter(faction);
4382	4446
…	…
4391	4455	throw ObjectNotDeployedException(this);
4392	4456
4393		DistributedMethod method(this, 344);
	4457	DistributedMethod method(this, 349);
4394	4458	method.addObjectParameter(player);
4395	4459	method.addUnsignedIntParameter(amount);
…	…
4405	4469	throw ObjectNotDeployedException(this);
4406	4470
4407		DistributedMethod method(this, 345);
	4471	DistributedMethod method(this, 350);
4408	4472	method.addAsciiParameter(choice);
4409	4473
…	…
4418	4482	throw ObjectNotDeployedException(this);
4419	4483
4420		DistributedMethod method(this, 346);
	4484	DistributedMethod method(this, 351);
4421	4485
4422	4486	method.executeWithVoidReturn();
…	…
4430	4494	throw ObjectNotDeployedException(this);
4431	4495
4432		DistributedMethod method(this, 347);
	4496	DistributedMethod method(this, 352);
4433	4497	method.addObjectParameter(choicesList);
4434	4498
…	…
4443	4507	throw ObjectNotDeployedException(this);
4444	4508
4445		DistributedMethod method(this, 348);
	4509	DistributedMethod method(this, 353);
4446	4510
4447	4511	return (SuiListBoxVector*) method.executeWithObjectReturn();
…	…
4455	4519	throw ObjectNotDeployedException(this);
4456	4520
4457		DistributedMethod method(this, 349);
	4521	DistributedMethod method(this, 354);
4458	4522
4459	4523	method.executeWithVoidReturn();
…	…
4467	4531	throw ObjectNotDeployedException(this);
4468	4532
4469		DistributedMethod method(this, 350);
	4533	DistributedMethod method(this, 355);
4470	4534	method.addUnsignedLongParameter(objectID);
4471	4535
…	…
4480	4544	throw ObjectNotDeployedException(this);
4481	4545
4482		DistributedMethod method(this, 351);
	4546	DistributedMethod method(this, 356);
4483	4547
4484	4548	return method.executeWithUnsignedLongReturn();
…	…
4913	4977	break;
4914	4978	case 144:
	4979	resp->insertSignedInt(getXp(inv->getAsciiParameter(_param0_getXp__string_)));
	4980	break;
	4981	case 145:
4915	4982	addXp(inv->getAsciiParameter(_param0_addXp__string_int_bool_), inv->getSignedIntParameter(), inv->getBooleanParameter());
4916	4983	break;
4917		case 145:
	4984	case 146:
4918	4985	removeXp(inv->getAsciiParameter(_param0_removeXp__string_int_bool_), inv->getSignedIntParameter(), inv->getBooleanParameter());
4919	4986	break;
4920		case 146:
	4987	case 147:
4921	4988	loadXp(inv->getAsciiParameter(_param0_loadXp__string_));
4922	4989	break;
4923		case 147:
	4990	case 148:
4924	4991	resp->insertAscii(saveXp());
4925	4992	break;
4926		case 148:
	4993	case 149:
4927	4994	resp->insertSignedInt(getXpTypeCap(inv->getAsciiParameter(_param0_getXpTypeCap__string_)));
4928	4995	break;
4929		case 149:
	4996	case 150:
4930	4997	loadXpTypeCap();
4931	4998	break;
4932		case 150:
	4999	case 151:
4933	5000	getXpTypeProse(inv->getAsciiParameter(_param0_getXpTypeProse__string_string_), inv->getAsciiParameter(_param1_getXpTypeProse__string_string_));
4934	5001	break;
4935		case 151:
	5002	case 152:
4936	5003	resp->insertSignedInt(calcPlayerLevel(inv->getAsciiParameter(_param0_calcPlayerLevel__string_)));
4937	5004	break;
4938		case 152:
	5005	case 153:
4939	5006	removeFromDuelList((Player*) inv->getObjectParameter());
4940	5007	break;
4941		case 153:
	5008	case 154:
4942	5009	addToDuelList((Player*) inv->getObjectParameter());
4943	5010	break;
4944		case 154:
	5011	case 155:
4945	5012	resp->insertBoolean(isInDuelWith((Player*) inv->getObjectParameter(), inv->getBooleanParameter()));
4946	5013	break;
4947		case 155:
	5014	case 156:
4948	5015	resp->insertLong(getDuelListObject(inv->getSignedIntParameter())->_getObjectID());
4949	5016	break;
4950		case 156:
	5017	case 157:
4951	5018	resp->insertBoolean(requestedDuelTo((Player*) inv->getObjectParameter()));
4952	5019	break;
4953		case 157:
	5020	case 158:
4954	5021	resp->insertBoolean(isDuelListEmpty());
4955	5022	break;
4956		case 158:
	5023	case 159:
4957	5024	resp->insertSignedInt(getDuelListSize());
4958	5025	break;
4959		case 159:
	5026	case 160:
4960	5027	resp->insertBoolean(setGuild(inv->getUnsignedIntParameter()));
4961	5028	break;
4962		case 160:
	5029	case 161:
4963	5030	setGuild((Guild*) inv->getObjectParameter());
4964	5031	break;
4965		case 161:
	5032	case 162:
4966	5033	resp->insertBoolean(updateGuild(inv->getUnsignedIntParameter()));
4967	5034	break;
4968		case 162:
	5035	case 163:
4969	5036	updateGuild((Guild*) inv->getObjectParameter());
4970	5037	break;
4971		case 163:
	5038	case 164:
4972	5039	addChatRoom((ChatRoom*) inv->getObjectParameter());
4973	5040	break;
4974		case 164:
	5041	case 165:
4975	5042	removeChatRoom((ChatRoom*) inv->getObjectParameter());
4976	5043	break;
4977		case 165:
	5044	case 166:
4978	5045	sendSystemMessage(inv->getAsciiParameter(_param0_sendSystemMessage__string_));
4979	5046	break;
4980		case 166:
	5047	case 167:
4981	5048	sendSystemMessage(inv->getUnicodeParameter(_param0_sendSystemMessage__unicode_));
4982	5049	break;
4983		case 167:
	5050	case 168:
4984	5051	sendSystemMessage(inv->getAsciiParameter(_param0_sendSystemMessage__string_string_long_), inv->getAsciiParameter(_param1_sendSystemMessage__string_string_long_), inv->getUnsignedLongParameter());
4985	5052	break;
4986		case 168:
	5053	case 169:
4987	5054	sendSystemMessage(inv->getAsciiParameter(_param0_sendSystemMessage__string_string_StfParameter_), inv->getAsciiParameter(_param1_sendSystemMessage__string_string_StfParameter_), (StfParameter*) inv->getObjectParameter());
4988	5055	break;
4989		case 169:
	5056	case 170:
4990	5057	sendBattleFatigueMessage((CreatureObject*) inv->getObjectParameter());
4991	5058	break;
4992		case 170:
	5059	case 171:
4993	5060	sendHealMessage((CreatureObject*) inv->getObjectParameter(), inv->getSignedIntParameter(), inv->getSignedIntParameter(), inv->getSignedIntParameter());
4994	5061	break;
4995		case 171:
	5062	case 172:
4996	5063	setConversatingCreature((CreatureObject*) inv->getObjectParameter());
4997	5064	break;
4998		case 172:
	5065	case 173:
4999	5066	setFirstName(inv->getAsciiParameter(_param0_setFirstName__string_));
5000	5067	break;
5001		case 173:
	5068	case 174:
5002	5069	setLastName(inv->getAsciiParameter(_param0_setLastName__string_));
5003	5070	break;
5004		case 174:
	5071	case 175:
5005	5072	setFirstNameProper(inv->getAsciiParameter(_param0_setFirstNameProper__string_));
5006	5073	break;
5007		case 175:
	5074	case 176:
5008	5075	setBiography(inv->getAsciiParameter(_param0_setBiography__string_));
5009	5076	break;
5010		case 176:
	5077	case 177:
5011	5078	setBiography(inv->getUnicodeParameter(_param0_setBiography__unicode_));
5012	5079	break;
5013		case 177:
	5080	case 178:
5014	5081	resp->insertBoolean(changeForcePowerBar(inv->getSignedIntParameter()));
5015	5082	break;
5016		case 178:
	5083	case 179:
5017	5084	setForcePowerBar(inv->getSignedIntParameter());
5018	5085	break;
5019		case 179:
	5086	case 180:
5020	5087	updateMaxForcePowerBar(inv->getBooleanParameter());
5021	5088	break;
5022		case 180:
	5089	case 181:
5023	5090	setFoodFilling(inv->getSignedIntParameter(), inv->getBooleanParameter());
5024	5091	break;
5025		case 181:
	5092	case 182:
5026	5093	setDrinkFilling(inv->getSignedIntParameter(), inv->getBooleanParameter());
5027	5094	break;
5028		case 182:
	5095	case 183:
5029	5096	changeFoodFilling(inv->getSignedIntParameter(), inv->getBooleanParameter());
5030	5097	break;
5031		case 183:
	5098	case 184:
5032	5099	changeDrinkFilling(inv->getSignedIntParameter(), inv->getBooleanParameter());
5033	5100	break;
5034		case 184:
	5101	case 185:
5035	5102	resp->insertBoolean(isAttackableBy((CreatureObject*) inv->getObjectParameter()));
5036	5103	break;
5037		case 185:
	5104	case 186:
5038	5105	resp->insertSignedInt(getFoodFilling());
5039	5106	break;
5040		case 186:
	5107	case 187:
5041	5108	resp->insertSignedInt(getDrinkFilling());
5042	5109	break;
5043		case 187:
	5110	case 188:
5044	5111	activateDigest();
5045	5112	break;
5046		case 188:
	5113	case 189:
5047	5114	activateQueueAction();
5048	5115	break;
5049		case 189:
	5116	case 190:
5050	5117	setCharacterID(inv->getUnsignedLongParameter());
5051	5118	break;
5052		case 190:
	5119	case 191:
5053	5120	setStartingProfession(inv->getAsciiParameter(_param0_setStartingProfession__string_));
5054	5121	break;
5055		case 191:
	5122	case 192:
5056	5123	setHairObject(inv->getAsciiParameter(_param0_setHairObject__string_));
5057	5124	break;
5058		case 192:
	5125	case 193:
5059	5126	updateHair();
5060	5127	break;
5061		case 193:
	5128	case 194:
5062	5129	setPlayerObject((PlayerObject*) inv->getObjectParameter());
5063	5130	break;
5064		case 194:
	5131	case 195:
5065	5132	setOnline();
5066	5133	break;
5067		case 195:
	5134	case 196:
5068	5135	clearDisconnectEvent();
5069	5136	break;
5070		case 196:
	5137	case 197:
5071	5138	setClient((ZoneClientSession*) inv->getObjectParameter());
5072	5139	break;
5073		case 197:
	5140	case 198:
5074	5141	setOvert();
5075	5142	break;
5076		case 198:
	5143	case 199:
5077	5144	setCovert();
5078	5145	break;
5079		case ~~199~~:
	5146	case 200:
5080	5147	setOnLeave();
5081	5148	break;
5082		case 200:
	5149	case 201:
5083	5150	resp->insertBoolean(isOvert());
5084	5151	break;
5085		case 201:
	5152	case 202:
5086	5153	resp->insertBoolean(isCovert());
5087	5154	break;
5088		case 202:
	5155	case 203:
5089	5156	resp->insertBoolean(isOnLeave());
5090	5157	break;
5091		case 203:
	5158	case 204:
5092	5159	newChangeFactionStatusEvent(inv->getUnsignedCharParameter(), inv->getUnsignedIntParameter());
5093	5160	break;
5094		case 204:
	5161	case 205:
5095	5162	setRaceFileName(inv->getAsciiParameter(_param0_setRaceFileName__string_));
5096	5163	break;
5097		case 205:
	5164	case 206:
5098	5165	setRaceID(inv->getUnsignedCharParameter());
5099	5166	break;
5100		case 206:
	5167	case 207:
5101	5168	setStartingLocation(inv->getAsciiParameter(_param0_setStartingLocation__string_));
5102	5169	break;
5103		case 207:
	5170	case 208:
5104	5171	setItemShift(inv->getUnsignedIntParameter());
5105	5172	break;
5106		case 208:
	5173	case 209:
5107	5174	toggleCharacterBit(inv->getUnsignedIntParameter());
5108	5175	break;
5109		case 209:
	5176	case 210:
5110	5177	resp->insertBoolean(awardBadge(inv->getUnsignedIntParameter()));
5111	5178	break;
5112		case 210:
	5179	case 211:
5113	5180	setLinkDead();
5114	5181	break;
5115		case 211:
	5182	case 212:
5116	5183	setLoggingIn();
5117	5184	break;
5118		case 212:
	5185	case 213:
5119	5186	setAdminLevel(inv->getSignedIntParameter());
5120	5187	break;
5121		case 213:
	5188	case 214:
5122	5189	resp->insertSignedInt(getAdminLevel());
5123	5190	break;
5124		case 214:
	5191	case 215:
5125	5192	setLastTestPositionX(inv->getFloatParameter());
5126	5193	break;
5127		case 215:
	5194	case 216:
5128	5195	setLastTestPositionY(inv->getFloatParameter());
5129	5196	break;
5130		case 216:
	5197	case 217:
5131	5198	setTradeRequestedPlayer(inv->getUnsignedLongParameter());
5132	5199	break;
5133		case 217:
	5200	case 218:
5134	5201	resp->insertLong(getTradeRequestedPlayer());
5135	5202	break;
5136		case 218:
	5203	case 219:
5137	5204	launchFirework(inv->getSignedIntParameter());
5138	5205	break;
5139		case 219:
	5206	case 220:
5140	5207	sendMessage((BaseMessage*) inv->getObjectParameter());
5141	5208	break;
5142		case 220:
	5209	case 221:
5143	5210	sendMessage((StandaloneBaseMessage*) inv->getObjectParameter());
5144	5211	break;
5145		case 221:
	5212	case 222:
5146	5213	resp->insertBoolean(isJedi());
5147	5214	break;
5148		case 222:
	5215	case 223:
5149	5216	mutePlayer();
5150	5217	break;
5151		case 223:
	5218	case 224:
5152	5219	toggleImmune();
5153	5220	break;
5154		case 224:
	5221	case 225:
5155	5222	resp->insertBoolean(hasSuiBox(inv->getUnsignedIntParameter()));
5156	5223	break;
5157		case 225:
	5224	case 226:
5158	5225	resp->insertBoolean(hasSuiBoxType(inv->getUnsignedIntParameter()));
5159	5226	break;
5160		case 226:
	5227	case 227:
5161	5228	resp->insertInt(getSuiBoxFromType(inv->getUnsignedIntParameter()));
5162	5229	break;
5163		case 227:
	5230	case 228:
5164	5231	removeSuiBox(inv->getUnsignedIntParameter());
5165	5232	break;
5166		case 228:
	5233	case 229:
5167	5234	resp->insertLong(getSuiBox(inv->getUnsignedIntParameter())->_getObjectID());
5168	5235	break;
5169		case 229:
	5236	case 230:
5170	5237	addSuiBox((SuiBox*) inv->getObjectParameter());
5171	5238	break;
5172		case 230:
	5239	case 231:
5173	5240	resp->insertInt(getNewSuiBoxID(inv->getUnsignedIntParameter()));
5174	5241	break;
5175		case 231:
	5242	case 232:
5176	5243	resp->insertBoolean(isOnline());
5177	5244	break;
5178		case 232:
	5245	case 233:
5179	5246	resp->insertBoolean(isOffline());
5180	5247	break;
5181		case 233:
	5248	case 234:
5182	5249	resp->insertBoolean(isLinkDead());
5183	5250	break;
5184		case 234:
	5251	case 235:
5185	5252	resp->insertBoolean(isLoggingIn());
5186	5253	break;
5187		case 235:
	5254	case 236:
5188	5255	resp->insertBoolean(isLoggingOut());
5189	5256	break;
5190		case 236:
	5257	case 237:
5191	5258	resp->insertLong(getPlayerObject()->_getObjectID());
5192	5259	break;
5193		case 237:
	5260	case 238:
5194	5261	resp->insertLong(getConversatingCreature()->_getObjectID());
5195	5262	break;
5196		case 238:
	5263	case 239:
5197	5264	resp->insertAscii(getFirstName());
5198	5265	break;
5199		case 239:
	5266	case 240:
5200	5267	resp->insertAscii(getLastName());
5201	5268	break;
5202		case 240:
	5269	case 241:
5203	5270	resp->insertAscii(getFirstNameProper());
5204	5271	break;
5205		case 241:
	5272	case 242:
5206	5273	resp->insertAscii(getRaceFileName());
5207	5274	break;
5208		case 242:
	5275	case 243:
5209	5276	resp->insertByte(getRaceID());
5210	5277	break;
5211		case 243:
	5278	case 244:
5212	5279	resp->insertUnicode(getBiography());
5213	5280	break;
5214		case 244:
	5281	case 245:
5215	5282	resp->insertLong(getCharacterID());
5216	5283	break;
5217		case 245:
	5284	case 246:
5218	5285	resp->insertAscii(getStartingProfession());
5219	5286	break;
5220		case 246:
	5287	case 247:
5221	5288	resp->insertSignedInt(getZoneIndex());
5222	5289	break;
5223		case 247:
	5290	case 248:
5224	5291	resp->insertAscii(getHairObject());
5225	5292	break;
5226		case 248:
	5293	case 249:
5227	5294	resp->insertLong(getClient()->_getObjectID());
5228	5295	break;
5229		case 249:
	5296	case 250:
5230	5297	resp->insertLong(getGroupObject()->_getObjectID());
5231	5298	break;
5232		case 250:
	5299	case 251:
5233	5300	resp->insertSignedInt(getPvpRating());
5234	5301	break;
5235		case 251:
	5302	case 252:
5236	5303	setPvpRating(inv->getSignedIntParameter());
5237	5304	break;
5238		case 252:
	5305	case 253:
5239	5306	increasePvpRating(inv->getSignedIntParameter());
5240	5307	break;
5241		case 253:
	5308	case 254:
5242	5309	decreasePvpRating(inv->getSignedIntParameter());
5243	5310	break;
5244		case 254:
	5311	case 255:
5245	5312	getPlayersNearYou();
5246	5313	break;
5247		case 255:
	5314	case 256:
5248	5315	resp->insertSignedInt(getRegionID());
5249	5316	break;
5250		case 256:
	5317	case 257:
5251	5318	resp->insertSignedInt(getCertificationListSize());
5252	5319	break;
5253		case 257:
	5320	case 258:
5254	5321	resp->insertAscii(getCertification(inv->getSignedIntParameter()));
5255	5322	break;
5256		case 258:
	5323	case 259:
5257	5324	resp->insertBoolean(checkCertification(inv->getAsciiParameter(_param0_checkCertification__string_)));
5258	5325	break;
5259		case 259:
	5326	case 260:
5260	5327	resp->insertSignedInt(getSlicingAbility());
5261	5328	break;
5262		case 260:
	5329	case 261:
5263	5330	resp->insertBoolean(isChatMuted());
5264	5331	break;
5265		case 261:
	5332	case 262:
5266	5333	resp->insertBoolean(isImmune());
5267	5334	break;
5268		case 262:
	5335	case 263:
5269	5336	resp->insertAscii(getInputBoxReturnBuffer());
5270	5337	break;
5271		case 263:
	5338	case 264:
5272	5339	resp->insertInt(nextMisoRFC());
5273	5340	break;
5274		case 264:
	5341	case 265:
5275	5342	resp->insertSignedInt(checkMisoBSB(inv->getSignedIntParameter()));
5276	5343	break;
5277		case 265:
	5344	case 266:
5278	5345	setMisoBSB(inv->getSignedIntParameter());
5279	5346	break;
5280		case 266:
	5347	case 267:
5281	5348	addToCurMisoKeys(inv->getAsciiParameter(_param0_addToCurMisoKeys__string_));
5282	5349	break;
5283		case 267:
	5350	case 268:
5284	5351	resp->insertBoolean(isOnCurMisoKey(inv->getAsciiParameter(_param0_isOnCurMisoKey__string_)));
5285	5352	break;
5286		case 268:
	5353	case 269:
5287	5354	removeFromCurMisoKeys(inv->getAsciiParameter(_param0_removeFromCurMisoKeys__string_));
5288	5355	break;
5289		case 269:
	5356	case 270:
5290	5357	addToFinMisoKeys(inv->getAsciiParameter(_param0_addToFinMisoKeys__string_));
5291	5358	break;
5292		case 270:
	5359	case 271:
5293	5360	resp->insertBoolean(hasCompletedMisoKey(inv->getAsciiParameter(_param0_hasCompletedMisoKey__string_)));
5294	5361	break;
5295		case 271:
	5362	case 272:
5296	5363	resp->insertLong(getCurrentCraftingTool()->_getObjectID());
5297	5364	break;
5298		case 272:
	5365	case 273:
5299	5366	resp->insertLong(getCraftingTool(inv->getSignedIntParameter(), inv->getBooleanParameter())->_getObjectID());
5300	5367	break;
5301		case 273:
	5368	case 274:
5302	5369	setCurrentCraftingTool((CraftingTool*) inv->getObjectParameter());
5303	5370	break;
5304		case 274:
	5371	case 275:
5305	5372	clearCurrentCraftingTool();
5306	5373	break;
5307		case 275:
	5374	case 276:
5308	5375	prepareCraftingSession((CraftingTool) inv->getObjectParameter(), (DraftSchematic) inv->getObjectParameter());
5309	5376	break;
5310		case 276:
	5377	case 277:
5311	5378	addIngredientToSlot((TangibleObject*) inv->getObjectParameter(), inv->getSignedIntParameter(), inv->getSignedIntParameter());
5312	5379	break;
5313		case 277:
	5380	case 278:
5314	5381	removeResourceFromCraft(inv->getUnsignedLongParameter(), inv->getSignedIntParameter(), inv->getSignedIntParameter());
5315	5382	break;
5316		case 278:
	5383	case 279:
5317	5384	nextCraftingStage(inv->getAsciiParameter(_param0_nextCraftingStage__string_));
5318	5385	break;
5319		case 279:
	5386	case 280:
5320	5387	craftingCustomization(inv->getAsciiParameter(_param0_craftingCustomization__string_int_), inv->getSignedIntParameter());
5321	5388	break;
5322		case 280:
	5389	case 281:
5323	5390	createPrototype(inv->getAsciiParameter(_param0_createPrototype__string_));
5324	5391	break;
5325		case 281:
	5392	case 282:
5326	5393	createSchematic(inv->getAsciiParameter(_param0_createSchematic__string_));
5327	5394	break;
5328		case 282:
	5395	case 283:
5329	5396	handleExperimenting(inv->getSignedIntParameter(), inv->getSignedIntParameter(), inv->getAsciiParameter(_param2_handleExperimenting__int_int_string_));
5330	5397	break;
5331		case 283:
	5398	case 284:
5332	5399	sendDraftSchematics();
5333	5400	break;
5334		case 284:
	5401	case 285:
5335	5402	addDraftSchematicsFromGroupName(inv->getAsciiParameter(_param0_addDraftSchematicsFromGroupName__string_));
5336	5403	break;
5337		case 285:
	5404	case 286:
5338	5405	subtractDraftSchematicsFromGroupName(inv->getAsciiParameter(_param0_subtractDraftSchematicsFromGroupName__string_));
5339	5406	break;
5340		case 286:
	5407	case 287:
5341	5408	addDraftSchematic((DraftSchematic*) inv->getObjectParameter());
5342	5409	break;
5343		case 287:
	5410	case 288:
5344	5411	subtractDraftSchematic((DraftSchematic*) inv->getObjectParameter());
5345	5412	break;
5346		case 288:
	5413	case 289:
5347	5414	resp->insertInt(getDraftSchematicListSize());
5348	5415	break;
5349		case 289:
	5416	case 290:
5350	5417	resp->insertInt(getDraftSchematicUpdateCount(inv->getUnsignedIntParameter()));
5351	5418	break;
5352		case 290:
	5419	case 291:
5353	5420	resp->insertLong(getDraftSchematic(inv->getUnsignedIntParameter())->_getObjectID());
5354	5421	break;
5355		case 291:
	5422	case 292:
5356	5423	resp->insertLong(getDraftSchematic(inv->getSignedIntParameter())->_getObjectID());
5357	5424	break;
5358		case 292:
	5425	case 293:
5359	5426	resp->insertBoolean(isChangingFactionStatus());
5360	5427	break;
5361		case 293:
	5428	case 294:
5362	5429	resp->insertLong(getDatapad()->_getObjectID());
5363	5430	break;
5364		case 294:
	5431	case 295:
5365	5432	resp->insertLong(getNewItemID());
5366	5433	break;
5367		case 295:
	5434	case 296:
5368	5435	resp->insertInt(getItemShift());
5369	5436	break;
5370		case 296:
	5437	case 297:
5371	5438	resp->insertFloat(getLastTestPositionX());
5372	5439	break;
5373		case 297:
	5440	case 298:
5374	5441	resp->insertFloat(getLastTestPositionY());
5375	5442	break;
5376		case 298:
	5443	case 299:
5377	5444	resp->insertInt(getForcePower());
5378	5445	break;
5379		case ~~299~~:
	5446	case 300:
5380	5447	resp->insertInt(getForcePowerMax());
5381	5448	break;
5382		case 300:
	5449	case 301:
5383	5450	resp->insertBoolean(isGuildLeader());
5384	5451	break;
5385		case 301:
	5452	case 302:
5386	5453	resp->insertLong(getCurrentStructureID());
5387	5454	break;
5388		case 302:
	5455	case 303:
5389	5456	setCurrentStructureID(inv->getUnsignedLongParameter());
5390	5457	break;
5391		case 303:
	5458	case 304:
5392	5459	resp->insertLong(getSurveyTool()->_getObjectID());
5393	5460	break;
5394		case 304:
	5461	case 305:
5395	5462	resp->insertLong(getSampleTool()->_getObjectID());
5396	5463	break;
5397		case 305:
	5464	case 306:
5398	5465	setSurveyTool((SurveyTool*) inv->getObjectParameter());
5399	5466	break;
5400		case 306:
	5467	case 307:
5401	5468	setSampleTool((SurveyTool*) inv->getObjectParameter());
5402	5469	break;
5403		case 307:
	5470	case 308:
5404	5471	setSurveyWaypoint((WaypointObject*) inv->getObjectParameter());
5405	5472	break;
5406		case 308:
	5473	case 309:
5407	5474	resp->insertLong(getSurveyWaypoint()->_getObjectID());
5408	5475	break;
5409		case 309:
	5476	case 310:
5410	5477	resp->insertBoolean(getCanSurvey());
5411	5478	break;
5412		case 310:
	5479	case 311:
5413	5480	resp->insertBoolean(getCanSample());
5414	5481	break;
5415		case 311:
	5482	case 312:
5416	5483	setCanSurvey();
5417	5484	break;
5418		case 312:
	5485	case 313:
5419	5486	setCanSample();
5420	5487	break;
5421		case 313:
	5488	case 314:
5422	5489	setSurveyEvent(inv->getAsciiParameter(_param0_setSurveyEvent__string_));
5423	5490	break;
5424		case 314:
	5491	case 315:
5425	5492	setSampleEvent(inv->getAsciiParameter(_param0_setSampleEvent__string_bool_), inv->getBooleanParameter());
5426	5493	break;
5427		case 315:
	5494	case 316:
5428	5495	setCancelSample(inv->getBooleanParameter());
5429	5496	break;
5430		case 316:
	5497	case 317:
5431	5498	resp->insertBoolean(getCancelSample());
5432	5499	break;
5433		case 317:
	5500	case 318:
5434	5501	sendSampleTimeRemaining();
5435	5502	break;
5436		case 318:
	5503	case 319:
5437	5504	setSurveyErrorMessage();
5438	5505	break;
5439		case 319:
	5506	case 320:
5440	5507	setSampleErrorMessage();
5441	5508	break;
5442		case 320:
	5509	case 321:
5443	5510	resp->insertBoolean(getSurveyErrorMessage());
5444	5511	break;
5445		case 321:
	5512	case 322:
5446	5513	resp->insertBoolean(getSampleErrorMessage());
5447	5514	break;
5448		case 322:
	5515	case 323:
5449	5516	sendMail(inv->getAsciiParameter(_param0_sendMail__string_unicode_unicode_string_), inv->getUnicodeParameter(_param1_sendMail__string_unicode_unicode_string_), inv->getUnicodeParameter(_param2_sendMail__string_unicode_unicode_string_), inv->getAsciiParameter(_param3_sendMail__string_unicode_unicode_string_));
5450	5517	break;
5451		case 323:
	5518	case 324:
5452	5519	setEntertainerEvent();
5453	5520	break;
5454		case 324:
	5521	case 325:
5455	5522	clearEntertainerEvent();
5456	5523	break;
5457		case 325:
	5524	case 326:
5458	5525	setLastNpcConvStr(inv->getAsciiParameter(_param0_setLastNpcConvStr__string_));
5459	5526	break;
5460		case 326:
	5527	case 327:
5461	5528	setLastNpcConvMessStr(inv->getAsciiParameter(_param0_setLastNpcConvMessStr__string_));
5462	5529	break;
5463		case 327:
	5530	case 328:
5464	5531	resp->insertAscii(getLastNpcConvStr());
5465	5532	break;
5466		case 328:
	5533	case 329:
5467	5534	resp->insertAscii(getLastNpcConvMessStr());
5468	5535	break;
5469		case 329:
	5536	case 330:
	5537	resp->insertAscii(getLastNpcConvOption(inv->getSignedIntParameter()));
	5538	break;
	5539	case 331:
	5540	addLastNpcConvOptions(inv->getAsciiParameter(_param0_addLastNpcConvOptions__string_));
	5541	break;
	5542	case 332:
	5543	clearLastNpcConvOptions();
	5544	break;
	5545	case 333:
	5546	resp->insertSignedInt(countLastNpcConvOptions());
	5547	break;
	5548	case 334:
5470	5549	setInputBoxReturnBuffer(inv->getAsciiParameter(_param0_setInputBoxReturnBuffer__string_));
5471	5550	break;
5472		case 330:
	5551	case 335:
5473	5552	setGuildLeader(inv->getBooleanParameter());
5474	5553	break;
5475		case 331:
	5554	case 336:
5476	5555	loadGuildChat();
5477	5556	break;
5478		case 332:
	5557	case 337:
5479	5558	setGuildPermissions(inv->getUnsignedIntParameter());
5480	5559	break;
5481		case 333:
	5560	case 338:
5482	5561	resp->insertInt(getGuildPermissions());
5483	5562	break;
5484		case 334:
	5563	case 339:
5485	5564	resp->insertBoolean(setGuildPermissionsBit(inv->getUnsignedIntParameter(), inv->getBooleanParameter()));
5486	5565	break;
5487		case 335:
	5566	case 340:
5488	5567	toggleGuildPermissionsBit(inv->getUnsignedIntParameter());
5489	5568	break;
5490		case 336:
	5569	case 341:
5491	5570	resp->insertBoolean(clearGuildPermissionsBit(inv->getUnsignedIntParameter(), inv->getBooleanParameter()));
5492	5571	break;
5493		case 337:
	5572	case 342:
5494	5573	resp->insertSignedInt(getFactionPoints(inv->getAsciiParameter(_param0_getFactionPoints__string_)));
5495	5574	break;
5496		case 338:
	5575	case 343:
5497	5576	addFactionPoints(inv->getAsciiParameter(_param0_addFactionPoints__string_int_), inv->getUnsignedIntParameter());
5498	5577	break;
5499		case 339:
	5578	case 344:
5500	5579	subtractFactionPoints(inv->getAsciiParameter(_param0_subtractFactionPoints__string_int_), inv->getUnsignedIntParameter());
5501	5580	break;
5502		case 340:
	5581	case 345:
5503	5582	resp->insertSignedInt(getFactionStatus());
5504	5583	break;
5505		case 341:
	5584	case 346:
5506	5585	setFactionStatus(inv->getSignedIntParameter());
5507	5586	break;
5508		case 342:
	5587	case 347:
5509	5588	resp->insertLong(getFactionList()->_getObjectID());
5510	5589	break;
5511		case 343:
	5590	case 348:
5512	5591	resp->insertInt(getMaxFactionPoints(inv->getAsciiParameter(_param0_getMaxFactionPoints__string_)));
5513	5592	break;
5514		case 344:
	5593	case 349:
5515	5594	delFactionPoints((Player*) inv->getObjectParameter(), inv->getUnsignedIntParameter());
5516	5595	break;
5517		case 345:
	5596	case 350:
5518	5597	addSuiBoxChoice(inv->getAsciiParameter(_param0_addSuiBoxChoice__string_));
5519	5598	break;
5520		case 346:
	5599	case 351:
5521	5600	removeLastSuiBoxChoice();
5522	5601	break;
5523		case 347:
	5602	case 352:
5524	5603	setSuiBoxChoices((SuiListBoxVector*) inv->getObjectParameter());
5525	5604	break;
5526		case 348:
	5605	case 353:
5527	5606	resp->insertLong(getSuiBoxChoices()->_getObjectID());
5528	5607	break;
5529		case 349:
	5608	case 354:
5530	5609	clearSuiBoxChoices();
5531	5610	break;
5532		case 350:
	5611	case 355:
5533	5612	setResourceDeedID(inv->getUnsignedLongParameter());
5534	5613	break;
5535		case 351:
	5614	case 356:
5536	5615	resp->insertLong(getResourceDeedID());
5537	5616	break;
…	…
6095	6174	}
6096	6175
	6176	int PlayerAdapter::getXp(const string& xpType) {
	6177	return ((PlayerImplementation*) impl)->getXp(xpType);
	6178	}
	6179
6097	6180	void PlayerAdapter::addXp(string& xpType, int xp, bool updateClient) {
6098	6181	return ((PlayerImplementation*) impl)->addXp(xpType, xp, updateClient);
…	…
6833	6916	string& PlayerAdapter::getLastNpcConvMessStr() {
6834	6917	return ((PlayerImplementation*) impl)->getLastNpcConvMessStr();
	6918	}
	6919
	6920	string& PlayerAdapter::getLastNpcConvOption(int idx) {
	6921	return ((PlayerImplementation*) impl)->getLastNpcConvOption(idx);
	6922	}
	6923
	6924	void PlayerAdapter::addLastNpcConvOptions(const string& option) {
	6925	return ((PlayerImplementation*) impl)->addLastNpcConvOptions(option);
	6926	}
	6927
	6928	void PlayerAdapter::clearLastNpcConvOptions() {
	6929	return ((PlayerImplementation*) impl)->clearLastNpcConvOptions();
	6930	}
	6931
	6932	int PlayerAdapter::countLastNpcConvOptions() {
	6933	return ((PlayerImplementation*) impl)->countLastNpcConvOptions();
6835	6934	}
6836	6935

core3/branches/CombatTest/src/server/zone/objects/player/Player.h

r908	r916
344	344	void queueHeal(TangibleObject* medpack, unsigned int actionCRC, const string& attribute);
345	345
	346	int getXp(const string& xpType);
	347
346	348	void addXp(string& xpType, int xp, bool updateClient);
347	349
…	…
713	715
714	716	string& getLastNpcConvMessStr();
	717
	718	string& getLastNpcConvOption(int idx);
	719
	720	void addLastNpcConvOptions(const string& option);
	721
	722	void clearLastNpcConvOptions();
	723
	724	int countLastNpcConvOptions();
715	725
716	726	void setInputBoxReturnBuffer(const string& message);
…	…
773	783	string _return_getLastName;
774	784	string _return_getLastNpcConvMessStr;
	785	string _return_getLastNpcConvOption;
775	786	string _return_getLastNpcConvStr;
776	787	string _return_getNextSkillBox;
…	…
1068	1079	void queueHeal(TangibleObject* medpack, unsigned int actionCRC, const string& attribute);
1069	1080
	1081	int getXp(const string& xpType);
	1082
1070	1083	void addXp(string& xpType, int xp, bool updateClient);
1071	1084
…	…
1437	1450
1438	1451	string& getLastNpcConvMessStr();
	1452
	1453	string& getLastNpcConvOption(int idx);
	1454
	1455	void addLastNpcConvOptions(const string& option);
	1456
	1457	void clearLastNpcConvOptions();
	1458
	1459	int countLastNpcConvOptions();
1439	1460
1440	1461	void setInputBoxReturnBuffer(const string& message);
…	…
1495	1516	string _param1_searchWaypoint__Player_string_int_;
1496	1517	string _param2_queueHeal__TangibleObject_int_string_;
	1518	string _param0_getXp__string_;
1497	1519	string _param0_addXp__string_int_bool_;
1498	1520	string _param0_removeXp__string_int_bool_;
…	…
1538	1560	string _param0_setLastNpcConvStr__string_;
1539	1561	string _param0_setLastNpcConvMessStr__string_;
	1562	string _param0_addLastNpcConvOptions__string_;
1540	1563	string _param0_setInputBoxReturnBuffer__string_;
1541	1564	string _param0_getFactionPoints__string_;

core3/branches/CombatTest/src/server/zone/objects/player/Player.idl

r908	r916
310	310
311	311	// Experience
	312	int getXp(const string xpType);
312	313	void addXp(string xpType, int xp, boolean updateClient);
313	314	void removeXp(string xpType, int xp, boolean updateClient);
…	…
603	604	string getLastNpcConvStr();
604	605	string getLastNpcConvMessStr();
	606
	607	string getLastNpcConvOption(int idx);
	608	void addLastNpcConvOptions(const string option);
	609	void clearLastNpcConvOptions();
	610	int countLastNpcConvOptions();
605	611
606	612	void setInputBoxReturnBuffer(const string message);

core3/branches/CombatTest/src/server/zone/objects/player/PlayerImplementation.h

r908	r916
245	245	string lastNpcConvoMessage;
246	246	string lastNpcConvo;
	247	Vector<string> lastNpcConvoOptions;
247	248
248	249	// Stat Migration Targets
…	…
1074	1075	}
1075	1076
	1077	int getXp(const string& xpType) {
	1078	return playerObject->getExperience(xpType);
	1079	}
1076	1080	void addXp(const string& xpType, int xp, bool updateClient) {
1077	1081	playerObject->addExperience(xpType, xp, updateClient);
…	…
1600	1604	return lastNpcConvoMessage;
1601	1605	}
	1606
	1607	inline string& getLastNpcConvOption(int idx) {
	1608	return lastNpcConvoOptions.get(idx);
	1609	}
	1610
	1611	inline void addLastNpcConvOptions(const string& option) {
	1612	lastNpcConvoOptions.add(option);
	1613	}
	1614
	1615	inline int countLastNpcConvOptions() {
	1616	return lastNpcConvoOptions.size();
	1617	}
	1618
	1619	inline void clearLastNpcConvOptions() {
	1620	lastNpcConvoOptions.removeAll();
	1621	}
1602	1622
1603	1623	inline void setCurrentStructureID(uint64 oid){

core3/branches/CombatTest/src/server/zone/objects/player/PlayerObject.cpp

r843	r916
62	62	}
63	63
64		~~void PlayerObject::addExperience(const string& xpType, int xp, bool updateClient~~) {
	64	int PlayerObject::getExperience(const string& xpType) {
65	65	if (_impl == NULL) {
66	66	if (!deployed)
…	…
69	69	DistributedMethod method(this, 8);
70	70	method.addAsciiParameter(xpType);
71		method.addSignedIntParameter(xp);
72		method.addBooleanParameter(updateClient);
73
74		method.executeWithVoidReturn();
75		} else
76		((PlayerObjectImplementation*) _impl)->addExperience(xpType, xp, updateClient);
77		}
78
79		void PlayerObject::removeExperience(const string& xpType, int xp, bool updateClient) {
	71
	72	return method.executeWithSignedIntReturn();
	73	} else
	74	return ((PlayerObjectImplementation*) _impl)->getExperience(xpType);
	75	}
	76
	77	void PlayerObject::addExperience(const string& xpType, int xp, bool updateClient) {
80	78	if (_impl == NULL) {
81	79	if (!deployed)
…	…
89	87	method.executeWithVoidReturn();
90	88	} else
	89	((PlayerObjectImplementation*) _impl)->addExperience(xpType, xp, updateClient);
	90	}
	91
	92	void PlayerObject::removeExperience(const string& xpType, int xp, bool updateClient) {
	93	if (_impl == NULL) {
	94	if (!deployed)
	95	throw ObjectNotDeployedException(this);
	96
	97	DistributedMethod method(this, 10);
	98	method.addAsciiParameter(xpType);
	99	method.addSignedIntParameter(xp);
	100	method.addBooleanParameter(updateClient);
	101
	102	method.executeWithVoidReturn();
	103	} else
91	104	((PlayerObjectImplementation*) _impl)->removeExperience(xpType, xp, updateClient);
92	105	}
…	…
97	110	throw ObjectNotDeployedException(this);
98	111
99		DistributedMethod method(this, 10);
	112	DistributedMethod method(this, 11);
100	113	method.addAsciiParameter(xpStr);
101	114
…	…
110	123	throw ObjectNotDeployedException(this);
111	124
112		DistributedMethod method(this, 11);
	125	DistributedMethod method(this, 12);
113	126
114	127	method.executeWithAsciiReturn(_return_saveExperience);
…	…
119	132
120	133	bool PlayerObject::setCharacterBit(unsigned int bit, bool updateClient) {
121		~~if (_impl == NULL) {~~
122		~~if (!deployed)~~
123		~~throw ObjectNotDeployedException(this);~~
124
125		~~DistributedMethod method(this, 12);~~
126		~~method.addUnsignedIntParameter(bit);~~
127		~~method.addBooleanParameter(updateClient);~~
128
129		~~return method.executeWithBooleanReturn();~~
130		~~} else~~
131		~~return ((PlayerObjectImplementation*) _impl)->setCharacterBit(bit, updateClient);~~
132		}
133
134		~~bool PlayerObject::clearCharacterBit(unsigned int bit, bool updateClient) {~~
135	134	if (_impl == NULL) {
136	135	if (!deployed)
…	…
143	142	return method.executeWithBooleanReturn();
144	143	} else
	144	return ((PlayerObjectImplementation*) _impl)->setCharacterBit(bit, updateClient);
	145	}
	146
	147	bool PlayerObject::clearCharacterBit(unsigned int bit, bool updateClient) {
	148	if (_impl == NULL) {
	149	if (!deployed)
	150	throw ObjectNotDeployedException(this);
	151
	152	DistributedMethod method(this, 14);
	153	method.addUnsignedIntParameter(bit);
	154	meth