Advertisement
Guest User

Untitled

a guest
Apr 26th, 2018
64
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 28.52 KB | None | 0 0
  1. /*
  2. * SlicingSessionImplementation.cpp
  3. *
  4. * Created on: Mar 5, 2011
  5. * Author: polonel
  6. */
  7.  
  8. #include "server/zone/objects/player/sessions/SlicingSession.h"
  9. #include "server/zone/objects/player/sui/SuiWindowType.h"
  10. #include "server/zone/objects/player/sui/listbox/SuiListBox.h"
  11. #include "server/zone/objects/tangible/tool/smuggler/SlicingTool.h"
  12. #include "server/zone/objects/player/PlayerObject.h"
  13. #include "server/zone/managers/player/PlayerManager.h"
  14. #include "server/zone/managers/loot/LootManager.h"
  15. #include "server/zone/managers/gcw/GCWManager.h"
  16. #include "server/zone/managers/gcw/tasks/SecuritySliceTask.h"
  17. #include "server/zone/objects/tangible/Container.h"
  18. #include "server/zone/objects/tangible/RelockLootContainerEvent.h"
  19. #include "server/zone/objects/tangible/weapon/WeaponObject.h"
  20. #include "server/zone/objects/tangible/wearables/ArmorObject.h"
  21. #include "server/zone/objects/tangible/terminal/mission/MissionTerminal.h"
  22. #include "server/zone/objects/tangible/tool/smuggler/PrecisionLaserKnife.h"
  23. #include "server/zone/objects/tangible/powerup/PowerupObject.h"
  24.  
  25. #include "server/zone/objects/player/sessions/sui/SlicingSessionSuiCallback.h"
  26.  
  27. #include "server/zone/ZoneServer.h"
  28.  
  29. #include "server/zone/Zone.h"
  30. #include "server/zone/objects/scene/SceneObjectType.h"
  31.  
  32. int SlicingSessionImplementation::initializeSession() {
  33. firstCable = System::random(1);
  34. nodeCable = 0;
  35.  
  36. cableBlue = false;
  37. cableRed = false;
  38.  
  39. usedNode = false;
  40. usedClamp = false;
  41.  
  42. selectableSlice = false;
  43. selectedSlice = false;
  44. firstRun = true;
  45. sliceOption = 0;
  46.  
  47. relockEvent = NULL;
  48.  
  49. baseSlice = false;
  50.  
  51. return 0;
  52. }
  53.  
  54. void SlicingSessionImplementation::initalizeSlicingMenu(CreatureObject* pl, TangibleObject* obj) {
  55. player = pl;
  56. tangibleObject = obj;
  57.  
  58. ManagedReference<CreatureObject*> player = pl;
  59. ManagedReference<TangibleObject*> tangibleObject = obj;
  60.  
  61. if (player == NULL || tangibleObject == NULL)
  62. return;
  63.  
  64. if (!tangibleObject->isSliceable() && !isBaseSlice())
  65. return;
  66.  
  67. if (tangibleObject->containsActiveSession(SessionFacadeType::SLICING)) {
  68. player->sendSystemMessage("@slicing/slicing:slicing_underway");
  69. return;
  70. }
  71.  
  72. if (!hasPrecisionLaserKnife(false)) { // do not remove the item on inital window
  73. player->sendSystemMessage("@slicing/slicing:no_knife");
  74. return;
  75. }
  76.  
  77. //bugfix 814,819
  78. ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
  79. if (inventory == NULL)
  80. return;
  81.  
  82. if(!isBaseSlice()){
  83. if (!inventory->hasObjectInContainer(tangibleObject->getObjectID()) && tangibleObject->getGameObjectType() != SceneObjectType::STATICLOOTCONTAINER
  84. && tangibleObject->getGameObjectType() != SceneObjectType::MISSIONTERMINAL ) {
  85. player->sendSystemMessage("The object must be in your inventory in order to perform the slice.");
  86. return;
  87. }
  88.  
  89. if (tangibleObject->isWeaponObject() && !hasWeaponUpgradeKit()) {
  90. player->sendSystemMessage("@slicing/slicing:no_weapon_kit");
  91. return;
  92. }
  93.  
  94. if (tangibleObject->isArmorObject() && !hasArmorUpgradeKit()) {
  95. player->sendSystemMessage("@slicing/slicing:no_armor_kit");
  96. return;
  97. }
  98. }
  99.  
  100. slicingSuiBox = new SuiListBox(player, SuiWindowType::SLICING_MENU, 2);
  101. slicingSuiBox->setCallback(new SlicingSessionSuiCallback(player->getZoneServer()));
  102.  
  103. if (tangibleObject->getGameObjectType() == SceneObjectType::PLAYERLOOTCRATE)
  104. // Don't close the window when we remove PlayerLootContainer from the player's inventory.
  105. slicingSuiBox->setForceCloseDisabled();
  106.  
  107. slicingSuiBox->setPromptTitle("@slicing/slicing:title");
  108. slicingSuiBox->setUsingObject(tangibleObject);
  109. slicingSuiBox->setCancelButton(true, "@cancel");
  110. generateSliceMenu(slicingSuiBox);
  111.  
  112. player->getPlayerObject()->addSuiBox(slicingSuiBox);
  113.  
  114. player->addActiveSession(SessionFacadeType::SLICING, _this.getReferenceUnsafeStaticCast());
  115. tangibleObject->addActiveSession(SessionFacadeType::SLICING, _this.getReferenceUnsafeStaticCast());
  116.  
  117. }
  118.  
  119. void SlicingSessionImplementation::generateSliceMenu(SuiListBox* suiBox) {
  120. ManagedReference<CreatureObject*> player = this->player.get();
  121. ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
  122.  
  123. if (player == NULL || tangibleObject == NULL)
  124. return;
  125.  
  126. uint8 progress = getProgress();
  127. suiBox->removeAllMenuItems();
  128.  
  129. StringBuffer prompt;
  130. prompt << "@slicing/slicing:";
  131. prompt << getPrefix(tangibleObject);
  132.  
  133. selectableSlice = tangibleObject->isArmorObject() || tangibleObject->isWeaponObject();
  134.  
  135. if (progress == 0) {
  136. if (usedClamp)
  137. prompt << "clamp_" << firstCable;
  138. else if (usedNode)
  139. prompt << "analyze_" << nodeCable;
  140. else
  141. prompt << progress;
  142.  
  143. if(!firstRun || !selectableSlice){
  144.  
  145. suiBox->addMenuItem("@slicing/slicing:blue_cable", 0);
  146. suiBox->addMenuItem("@slicing/slicing:red_cable", 1);
  147.  
  148. if (!usedClamp && !usedNode) {
  149. suiBox->addMenuItem("@slicing/slicing:use_clamp", 2);
  150. suiBox->addMenuItem("@slicing/slicing:use_analyzer", 3);
  151. }
  152. }
  153. if(selectableSlice && !selectedSlice && firstRun){
  154. if(tangibleObject->isArmorObject()){
  155. suiBox->addMenuItem("Slice for base effectiveness.", 4);
  156. suiBox->addMenuItem("Slice for encumbrance.", 5);
  157. }else if(tangibleObject->isWeaponObject()){
  158. suiBox->addMenuItem("Slice for speed.", 6);
  159. suiBox->addMenuItem("Slice for damage.", 7);
  160. }
  161. suiBox->addMenuItem("Random slice.", 8);
  162.  
  163. }
  164.  
  165. } else if (progress == 1) {
  166. prompt << progress;
  167.  
  168. suiBox->addMenuItem((cableBlue) ? "@slicing/slicing:blue_cable_cut" : "@slicing/slicing:blue_cable", 0);
  169. suiBox->addMenuItem((cableRed) ? "@slicing/slicing:red_cable_cut" : "@slicing/slicing:red_cable", 1);
  170. }
  171.  
  172. suiBox->setPromptText(prompt.toString());
  173. player->getPlayerObject()->addSuiBox(suiBox);
  174. player->sendMessage(suiBox->generateMessage());
  175.  
  176. }
  177.  
  178. void SlicingSessionImplementation::handleMenuSelect(CreatureObject* pl, byte menuID, SuiListBox* suiBox) {
  179. ManagedReference<CreatureObject*> player = this->player.get();
  180. ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
  181.  
  182. if (tangibleObject == NULL || player == NULL || player != pl)
  183. return;
  184.  
  185. ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
  186. if (inventory == NULL)
  187. return;
  188.  
  189. if(!isBaseSlice() && tangibleObject->getGameObjectType() != SceneObjectType::STATICLOOTCONTAINER && tangibleObject->getGameObjectType() != SceneObjectType::MISSIONTERMINAL){
  190. if (!inventory->hasObjectInContainer(tangibleObject->getObjectID())) {
  191. player->sendSystemMessage("The object must be in your inventory in order to perform the slice.");
  192. return;
  193. }
  194. }
  195.  
  196. uint8 progress = getProgress();
  197.  
  198. if (progress == 0) {
  199. switch(menuID) {
  200. case 0: {
  201. if (firstRun && selectableSlice) {
  202. player->sendSystemMessage("No option selected. You must select a slicing type option.");
  203. }
  204. else {
  205. if (hasPrecisionLaserKnife()) {
  206. if (firstCable != 0)
  207. handleSliceFailed(); // Handle failed slice attempt
  208. else
  209. cableBlue = true;
  210.  
  211. }
  212. else {
  213. player->sendSystemMessage("@slicing/slicing:no_knife");
  214. }
  215. }
  216. break;
  217. }
  218. case 1: {
  219. if (hasPrecisionLaserKnife()) {
  220. if (firstCable != 1)
  221. handleSliceFailed(); // Handle failed slice attempt
  222. else
  223. cableRed = true;
  224. } else
  225. player->sendSystemMessage("@slicing/slicing:no_knife");
  226. break;
  227. }
  228. case 2:
  229. handleUseClamp(); // Handle Use of Molecular Clamp
  230. break;
  231.  
  232. case 3: {
  233. handleUseFlowAnalyzer(); // Handle Use of Flow Analyzer
  234. break;
  235. }
  236. case 4: {
  237. selectedSlice = true;
  238. sliceOption = 1;
  239. firstRun = false;
  240. break;
  241. }
  242. case 5: {
  243. selectedSlice = true;
  244. sliceOption = 2;
  245. firstRun = false;
  246. break;
  247. }
  248. case 6: {
  249. selectedSlice = true;
  250. sliceOption = 1;
  251. firstRun = false;
  252. break;
  253. }
  254. case 7: {
  255. selectedSlice = true;
  256. sliceOption = 2;
  257. firstRun = false;
  258. break;
  259. }
  260. case 8: {
  261. firstRun = false; // Random slice type
  262. break;
  263. }
  264. default:
  265. cancelSession();
  266. break;
  267. }
  268. } else {
  269. if (hasPrecisionLaserKnife()) {
  270. if (firstCable != menuID)
  271. handleSlice(suiBox); // Handle Successful Slice
  272. else
  273. handleSliceFailed(); // Handle failed slice attempt //bugfix 820
  274. return;
  275. } else
  276. player->sendSystemMessage("@slicing/slicing:no_knife");
  277. }
  278.  
  279. generateSliceMenu(suiBox);
  280.  
  281. }
  282.  
  283. void SlicingSessionImplementation::endSlicing() {
  284. ManagedReference<CreatureObject*> player = this->player.get();
  285. ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
  286.  
  287. if (player == NULL || tangibleObject == NULL) {
  288. cancelSession();
  289. return;
  290. }
  291.  
  292. if (tangibleObject->isMissionTerminal())
  293. player->addCooldown("slicing.terminal", (2 * (60 * 1000))); // 2min Cooldown
  294.  
  295. cancelSession();
  296.  
  297. }
  298.  
  299. int SlicingSessionImplementation::getSlicingSkill(CreatureObject* slicer) {
  300.  
  301. String skill0 = "combat_smuggler_novice";
  302. String skill1 = "combat_smuggler_slicing_01";
  303. String skill2 = "combat_smuggler_slicing_02";
  304. String skill3 = "combat_smuggler_slicing_03";
  305. String skill4 = "combat_smuggler_slicing_04";
  306. String skill5 = "combat_smuggler_master";
  307.  
  308. if (slicer->hasSkill(skill5))
  309. return 5;
  310. else if (slicer->hasSkill(skill4))
  311. return 4;
  312. else if (slicer->hasSkill(skill3))
  313. return 3;
  314. else if (slicer->hasSkill(skill2))
  315. return 2;
  316. else if (slicer->hasSkill(skill1))
  317. return 1;
  318. else if (slicer->hasSkill(skill0))
  319. return 0;
  320.  
  321. return -1;
  322.  
  323. }
  324.  
  325. bool SlicingSessionImplementation::hasPrecisionLaserKnife(bool removeItem) {
  326. ManagedReference<CreatureObject*> player = this->player.get();
  327.  
  328. if (player == NULL)
  329. return 0;
  330.  
  331. ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
  332.  
  333. if (inventory == NULL)
  334. return false;
  335.  
  336. Locker inventoryLocker(inventory);
  337.  
  338. for (int i = 0; i < inventory->getContainerObjectsSize(); ++i) {
  339. ManagedReference<SceneObject*> sceno = inventory->getContainerObject(i);
  340.  
  341. uint32 objType = sceno->getGameObjectType();
  342.  
  343. if (objType == SceneObjectType::LASERKNIFE) {
  344. PrecisionLaserKnife* knife = sceno.castTo<PrecisionLaserKnife*>();
  345.  
  346. if (knife != NULL) {
  347. if (removeItem) {
  348. Locker locker(knife);
  349. knife->useCharge(player);
  350. }
  351. return 1;
  352. }
  353. }
  354. }
  355.  
  356. return 0;
  357. }
  358.  
  359. bool SlicingSessionImplementation::hasWeaponUpgradeKit() {
  360. ManagedReference<CreatureObject*> player = this->player.get();
  361.  
  362. if (player == NULL)
  363. return false;
  364.  
  365. ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
  366.  
  367. if (inventory == NULL)
  368. return false;
  369.  
  370. for (int i = 0; i < inventory->getContainerObjectsSize(); ++i) {
  371. ManagedReference<SceneObject*> sceno = inventory->getContainerObject(i);
  372.  
  373. uint32 objType = sceno->getGameObjectType();
  374.  
  375. if (objType == SceneObjectType::WEAPONUPGRADEKIT) {
  376. Locker locker(sceno);
  377. sceno->destroyObjectFromWorld(true);
  378. sceno->destroyObjectFromDatabase(true);
  379. return true;
  380. }
  381. }
  382.  
  383. return false;
  384. }
  385.  
  386. bool SlicingSessionImplementation::hasArmorUpgradeKit() {
  387. ManagedReference<CreatureObject*> player = this->player.get();
  388.  
  389. if (player == NULL)
  390. return false;
  391.  
  392. ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
  393.  
  394. if (inventory == NULL)
  395. return false;
  396.  
  397. for (int i = 0; i < inventory->getContainerObjectsSize(); ++i) {
  398. ManagedReference<SceneObject*> sceno = inventory->getContainerObject(i);
  399.  
  400. uint32 objType = sceno->getGameObjectType();
  401.  
  402. if (objType == SceneObjectType::ARMORUPGRADEKIT) {
  403. Locker locker(sceno);
  404. sceno->destroyObjectFromWorld(true);
  405. sceno->destroyObjectFromDatabase(true);
  406. return true;
  407. }
  408. }
  409.  
  410. return false;
  411. }
  412.  
  413. void SlicingSessionImplementation::useClampFromInventory(SlicingTool* clamp) {
  414. ManagedReference<CreatureObject*> player = this->player.get();
  415.  
  416. if (clamp == NULL || clamp->getGameObjectType() != SceneObjectType::MOLECULARCLAMP)
  417. return;
  418.  
  419. ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
  420.  
  421. Locker locker(clamp);
  422.  
  423. //inventory->removeObject(clamp, true);
  424. clamp->destroyObjectFromWorld(true);
  425. clamp->destroyObjectFromDatabase(true);
  426. player->sendSystemMessage("@slicing/slicing:used_clamp");
  427. usedClamp = true;
  428.  
  429. //if (player->hasSuiBox(slicingSuiBox->getBoxID()))
  430. // player->closeSuiWindowType(SuiWindowType::SLICING_MENU);
  431. }
  432.  
  433. void SlicingSessionImplementation::handleUseClamp() {
  434. ManagedReference<CreatureObject*> player = this->player.get();
  435.  
  436. if (player == NULL)
  437. return;
  438.  
  439. ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
  440.  
  441. Locker inventoryLocker(inventory);
  442.  
  443. for (int i = 0; i < inventory->getContainerObjectsSize(); ++i) {
  444. ManagedReference<SceneObject*> sceno = inventory->getContainerObject(i);
  445.  
  446. uint32 objType = sceno->getGameObjectType();
  447.  
  448. if (objType == SceneObjectType::MOLECULARCLAMP) {
  449. Locker locker(sceno);
  450. sceno->destroyObjectFromWorld(true);
  451. sceno->destroyObjectFromDatabase(true);
  452.  
  453. player->sendSystemMessage("@slicing/slicing:used_clamp");
  454. usedClamp = true;
  455. return;
  456. }
  457. }
  458.  
  459. player->sendSystemMessage("@slicing/slicing:no_clamp");
  460. }
  461.  
  462. void SlicingSessionImplementation::handleUseFlowAnalyzer() {
  463. ManagedReference<CreatureObject*> player = this->player.get();
  464.  
  465. if (player == NULL)
  466. return;
  467.  
  468. ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
  469.  
  470. Locker inventoryLocker(inventory);
  471.  
  472. for (int i = 0; i < inventory->getContainerObjectsSize(); ++i) {
  473. ManagedReference<SceneObject*> sceno = inventory->getContainerObject(i);
  474.  
  475. uint32 objType = sceno->getGameObjectType();
  476.  
  477. if (objType == SceneObjectType::FLOWANALYZER) {
  478. SlicingTool* node = cast<SlicingTool*>(sceno.get());
  479.  
  480. if (node == NULL)
  481. continue;
  482.  
  483. nodeCable = node->calculateSuccessRate();
  484.  
  485. if (nodeCable) // PASSED
  486. nodeCable = firstCable;
  487. else if (nodeCable == firstCable) { // Failed but the cables are Correct
  488. if (firstCable)
  489. nodeCable = 0; // Failed - Make the Cable incorrect
  490. }
  491.  
  492. Locker locker(sceno);
  493. sceno->destroyObjectFromWorld(true);
  494. sceno->destroyObjectFromDatabase(true);
  495.  
  496. player->sendSystemMessage("@slicing/slicing:used_node");
  497. usedNode = true;
  498. return;
  499. }
  500. }
  501.  
  502. player->sendSystemMessage("@slicing/slicing:no_node");
  503. }
  504.  
  505. void SlicingSessionImplementation::handleSlice(SuiListBox* suiBox) {
  506. ManagedReference<CreatureObject*> player = this->player.get();
  507. ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
  508.  
  509. if (player == NULL || tangibleObject == NULL)
  510. return;
  511.  
  512. Locker locker(player);
  513. Locker clocker(tangibleObject, player);
  514.  
  515. PlayerManager* playerManager = player->getZoneServer()->getPlayerManager();
  516.  
  517. suiBox->removeAllMenuItems();
  518. suiBox->setCancelButton(false,"@cancel");
  519.  
  520. StringBuffer prompt;
  521. prompt << "@slicing/slicing:";
  522. prompt << getPrefix(tangibleObject) + "examine";
  523. suiBox->setPromptText(prompt.toString());
  524.  
  525. player->getPlayerObject()->addSuiBox(suiBox);
  526. player->sendMessage(suiBox->generateMessage());
  527.  
  528. if (tangibleObject->isContainerObject() || tangibleObject->getGameObjectType() == SceneObjectType::PLAYERLOOTCRATE) {
  529. handleContainerSlice();
  530. playerManager->awardExperience(player, "slicing", 550, true); // Container Slice XP
  531. } else if (tangibleObject->isMissionTerminal()) {
  532. MissionTerminal* term = cast<MissionTerminal*>( tangibleObject.get());
  533. playerManager->awardExperience(player, "slicing", 300, true); // Terminal Slice XP
  534. term->addSlicer(player);
  535. player->sendSystemMessage("@slicing/slicing:terminal_success");
  536. } else if (tangibleObject->isWeaponObject()) {
  537. handleWeaponSlice();
  538. playerManager->awardExperience(player, "slicing", 550, true); // Weapon Slice XP
  539. } else if (tangibleObject->isArmorObject()) {
  540. handleArmorSlice();
  541. playerManager->awardExperience(player, "slicing", 550, true); // Armor Slice XP
  542. } else if ( isBaseSlice()){
  543. playerManager->awardExperience(player,"slicing", 2000, true); // Base slicing
  544.  
  545. Zone* zone = player->getZone();
  546.  
  547. if (zone != NULL){
  548. GCWManager* gcwMan = zone->getGCWManager();
  549.  
  550. if (gcwMan != NULL){
  551. SecuritySliceTask* task = new SecuritySliceTask(gcwMan, tangibleObject.get(), player);
  552. task->execute();
  553. }
  554. }
  555.  
  556. }
  557.  
  558. endSlicing();
  559.  
  560. }
  561.  
  562. void SlicingSessionImplementation::handleWeaponSlice() {
  563. ManagedReference<CreatureObject*> player = this->player.get();
  564. ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
  565.  
  566. if (player == NULL || tangibleObject == NULL || !tangibleObject->isWeaponObject())
  567. return;
  568.  
  569. int sliceSkill = getSlicingSkill(player);
  570. uint8 min = 0;
  571. uint8 max = 0;
  572.  
  573. switch (sliceSkill) {
  574. case 5:
  575. min += 5;
  576. max += 5;
  577. case 4:
  578. min += 5;
  579. max += 5;
  580. case 3:
  581. case 2:
  582. min += 10;
  583. max += 25;
  584. break;
  585. default:
  586. return;
  587.  
  588. }
  589.  
  590. uint8 percentage = System::random(max - min) + min;
  591.  
  592. if(!selectedSlice){
  593. switch(System::random(1)) {
  594. case 0:
  595. handleSliceDamage(percentage);
  596. break;
  597. case 1:
  598. handleSliceSpeed(percentage);
  599. break;
  600. }
  601. }else{
  602. percentage = ceil(percentage * 0.85); // 15% penalty for choosing type of slice
  603. switch(sliceOption) {
  604. case 2:
  605. handleSliceDamage(percentage);
  606. break;
  607. case 1:
  608. handleSliceSpeed(percentage);
  609. break;
  610. }
  611. }
  612. }
  613.  
  614. void SlicingSessionImplementation::detachPowerUp(CreatureObject* player, WeaponObject* weap) {
  615. ManagedReference<PowerupObject*> pup = weap->removePowerup();
  616. if (pup == NULL)
  617. return;
  618.  
  619. Locker locker(pup);
  620.  
  621. pup->destroyObjectFromWorld(true);
  622. pup->destroyObjectFromDatabase(true);
  623.  
  624. locker.release();
  625.  
  626. StringIdChatParameter message("powerup", "prose_remove_powerup"); //You detach your powerup from %TT.
  627. message.setTT(weap->getDisplayedName());
  628. player->sendSystemMessage(message);
  629.  
  630. }
  631.  
  632. void SlicingSessionImplementation::handleSliceDamage(uint8 percent) {
  633. ManagedReference<CreatureObject*> player = this->player.get();
  634. ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
  635.  
  636. if (tangibleObject == NULL || player == NULL || !tangibleObject->isWeaponObject())
  637. return;
  638.  
  639. WeaponObject* weap = cast<WeaponObject*>(tangibleObject.get());
  640.  
  641. Locker locker(weap);
  642.  
  643. if (weap->hasPowerup())
  644. this->detachPowerUp(player, weap);
  645.  
  646. weap->setDamageSlice(percent / 100.f);
  647. weap->setSliced(true);
  648.  
  649. StringIdChatParameter params;
  650. params.setDI(percent);
  651. params.setStringId("@slicing/slicing:dam_mod");
  652.  
  653. player->sendSystemMessage(params);
  654.  
  655. }
  656.  
  657. void SlicingSessionImplementation::handleSliceSpeed(uint8 percent) {
  658. ManagedReference<CreatureObject*> player = this->player.get();
  659. ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
  660.  
  661. if (tangibleObject == NULL || player == NULL || !tangibleObject->isWeaponObject())
  662. return;
  663.  
  664. WeaponObject* weap = cast<WeaponObject*>(tangibleObject.get());
  665.  
  666. Locker locker(weap);
  667.  
  668. if (weap->hasPowerup())
  669. this->detachPowerUp(player, weap);
  670.  
  671. weap->setSpeedSlice(percent / 100.f);
  672. weap->setSliced(true);
  673.  
  674. StringIdChatParameter params;
  675. params.setDI(percent);
  676. params.setStringId("@slicing/slicing:spd_mod");
  677.  
  678. player->sendSystemMessage(params);
  679. }
  680.  
  681. void SlicingSessionImplementation::handleArmorSlice() {
  682. ManagedReference<CreatureObject*> player = this->player.get();
  683. ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
  684.  
  685. if (tangibleObject == NULL || player == NULL)
  686. return;
  687.  
  688. uint8 sliceType = 0;
  689. int sliceSkill = getSlicingSkill(player);
  690. uint8 min = 0;
  691. uint8 max = 0;
  692.  
  693. if(!selectedSlice) sliceType=System::random(1);
  694.  
  695. else{
  696. switch (sliceOption) {
  697. case 1:
  698. sliceType=0; // Effectiveness Slice
  699. break;
  700. case 2:
  701. sliceType=1; // Encumbrance Slice
  702. break;
  703. }
  704. }
  705.  
  706. switch (sliceSkill) {
  707. case 5:
  708. min += (sliceType == 0) ? 6 : 5;
  709. max += 5;
  710. case 4:
  711. min += (sliceType == 0) ? 0 : 10;
  712. max += 10;
  713. case 3:
  714. min += 5;
  715. max += (sliceType == 0) ? 20 : 30;
  716. break;
  717. default:
  718. return;
  719. }
  720.  
  721. uint8 percent = System::random(max - min) + min;
  722.  
  723. if(!selectedSlice){
  724. switch (sliceType) {
  725. case 0:
  726. handleSliceEffectiveness(percent);
  727. break;
  728. case 1:
  729. handleSliceEncumbrance(percent);
  730. break;
  731. }
  732. }else{
  733. percent = ceil(percent * 0.85); // 15% penalty for choosing type of slice
  734. switch (sliceOption) {
  735. case 1:
  736. handleSliceEffectiveness(percent);
  737. break;
  738. case 2:
  739. handleSliceEncumbrance(percent);
  740. break;
  741. }
  742. }
  743. }
  744.  
  745. void SlicingSessionImplementation::handleSliceEncumbrance(uint8 percent) {
  746. ManagedReference<CreatureObject*> player = this->player.get();
  747. ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
  748.  
  749. if (tangibleObject == NULL || player == NULL || !tangibleObject->isArmorObject())
  750. return;
  751.  
  752. ArmorObject* armor = cast<ArmorObject*>(tangibleObject.get());
  753.  
  754. Locker locker(armor);
  755.  
  756. armor->setEncumbranceSlice(percent / 100.f);
  757. armor->setSliced(true);
  758.  
  759. StringIdChatParameter params;
  760. params.setDI(percent);
  761. params.setStringId("@slicing/slicing:enc_mod");
  762.  
  763. player->sendSystemMessage(params);
  764. }
  765.  
  766. void SlicingSessionImplementation::handleSliceEffectiveness(uint8 percent) {
  767. ManagedReference<CreatureObject*> player = this->player.get();
  768. ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
  769.  
  770. if (tangibleObject == NULL || player == NULL || !tangibleObject->isArmorObject())
  771. return;
  772.  
  773. ArmorObject* armor = cast<ArmorObject*>(tangibleObject.get());
  774.  
  775. Locker locker(armor);
  776.  
  777. armor->setEffectivenessSlice(percent / 100.f);
  778. armor->setSliced(true);
  779.  
  780. StringIdChatParameter params;
  781. params.setDI(percent);
  782. params.setStringId("@slicing/slicing:eff_mod");
  783.  
  784. player->sendSystemMessage(params);
  785. }
  786.  
  787. void SlicingSessionImplementation::handleContainerSlice() {
  788. ManagedReference<CreatureObject*> player = this->player.get();
  789. ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
  790.  
  791. if (tangibleObject == NULL || player == NULL)
  792. return;
  793.  
  794. ManagedReference<SceneObject*> inventory = player->getSlottedObject("inventory");
  795.  
  796. if (inventory == NULL)
  797. return;
  798.  
  799. Locker inventoryLocker(inventory);
  800.  
  801. LootManager* lootManager = player->getZoneServer()->getLootManager();
  802.  
  803. if (tangibleObject->getGameObjectType() == SceneObjectType::PLAYERLOOTCRATE) {
  804. Reference<SceneObject*> containerSceno = player->getZoneServer()->createObject(STRING_HASHCODE("object/tangible/container/loot/loot_crate.iff"), 1);
  805.  
  806. if (containerSceno == NULL)
  807. return;
  808.  
  809. Locker clocker(containerSceno, player);
  810.  
  811. Container* container = dynamic_cast<Container*>(containerSceno.get());
  812.  
  813. if (container == NULL) {
  814. containerSceno->destroyObjectFromDatabase(true);
  815. return;
  816. }
  817.  
  818. if (System::random(10) != 4)
  819. lootManager->createLoot(container, "looted_container");
  820.  
  821. inventory->transferObject(container, -1);
  822. container->sendTo(player, true);
  823.  
  824. if (inventory->hasObjectInContainer(tangibleObject->getObjectID())) {
  825. //inventory->removeObject(tangibleObject, true);
  826. tangibleObject->destroyObjectFromWorld(true);
  827. }
  828.  
  829. tangibleObject->destroyObjectFromDatabase(true);
  830.  
  831. } else if (tangibleObject->getGameObjectType() == SceneObjectType::PLAYERLOOTCRATE) {
  832. Reference<SceneObject*> containerSceno = player->getZoneServer()->createObject(STRING_HASHCODE("object/tangible/container/loot/mysterious_container.iff.iff"), 1);
  833.  
  834. if (containerSceno == NULL)
  835. return;
  836.  
  837. Locker clocker(containerSceno, player);
  838.  
  839. Container* container = dynamic_cast<Container*>(containerSceno.get());
  840.  
  841. if (container == NULL) {
  842. containerSceno->destroyObjectFromDatabase(true);
  843. return;
  844. }
  845.  
  846. if (System::random(10) != 4)
  847. lootManager->createLoot(container, "rngbox1_lootgroup");
  848.  
  849. inventory->transferObject(container, -1);
  850. container->sendTo(player, true);
  851.  
  852. if (inventory->hasObjectInContainer(tangibleObject->getObjectID())) {
  853. //inventory->removeObject(tangibleObject, true);
  854. tangibleObject->destroyObjectFromWorld(true);
  855. }
  856.  
  857. tangibleObject->destroyObjectFromDatabase(true);
  858.  
  859. } else if (tangibleObject->getGameObjectType() == SceneObjectType::PLAYERLOOTCRATE) {
  860. Reference<SceneObject*> containerSceno = player->getZoneServer()->createObject(STRING_HASHCODE("object/tangible/container/loot/large_mysterious_container.iff"), 1);
  861.  
  862. if (containerSceno == NULL)
  863. return;
  864.  
  865. Locker clocker(containerSceno, player);
  866.  
  867. Container* container = dynamic_cast<Container*>(containerSceno.get());
  868.  
  869. if (container == NULL) {
  870. containerSceno->destroyObjectFromDatabase(true);
  871. return;
  872. }
  873.  
  874. if (System::random(10) != 4)
  875. lootManager->createLoot(container, "rngbox2_lootgroup");
  876.  
  877. inventory->transferObject(container, -1);
  878. container->sendTo(player, true);
  879.  
  880. if (inventory->hasObjectInContainer(tangibleObject->getObjectID())) {
  881. //inventory->removeObject(tangibleObject, true);
  882. tangibleObject->destroyObjectFromWorld(true);
  883. }
  884.  
  885. tangibleObject->destroyObjectFromDatabase(true);
  886.  
  887. } else if (tangibleObject->getGameObjectType() == SceneObjectType::PLAYERLOOTCRATE) {
  888. Reference<SceneObject*> containerSceno = player->getZoneServer()->createObject(STRING_HASHCODE("object/tangible/container/loot/glowing_mysterious_container.iff"), 1);
  889.  
  890. if (containerSceno == NULL)
  891. return;
  892.  
  893. Locker clocker(containerSceno, player);
  894.  
  895. Container* container = dynamic_cast<Container*>(containerSceno.get());
  896.  
  897. if (container == NULL) {
  898. containerSceno->destroyObjectFromDatabase(true);
  899. return;
  900. }
  901.  
  902. if (System::random(10) != 4)
  903. lootManager->createLoot(container, "rngbox3_lootgroup");
  904.  
  905. inventory->transferObject(container, -1);
  906. container->sendTo(player, true);
  907.  
  908. if (inventory->hasObjectInContainer(tangibleObject->getObjectID())) {
  909. //inventory->removeObject(tangibleObject, true);
  910. tangibleObject->destroyObjectFromWorld(true);
  911. }
  912.  
  913. tangibleObject->destroyObjectFromDatabase(true);
  914.  
  915. } else if (tangibleObject->isContainerObject()) {
  916.  
  917. Container* container = dynamic_cast<Container*>(tangibleObject.get());
  918. if (container == NULL)
  919. return;
  920.  
  921. container->setSliced(true);
  922. container->setLockedStatus(false);
  923.  
  924. if(!container->isRelocking())
  925. {
  926. relockEvent = new RelockLootContainerEvent(container);
  927. relockEvent->schedule(container->getLockTime());
  928. }
  929. } else
  930. return;
  931.  
  932. player->sendSystemMessage("@slicing/slicing:container_success");
  933. }
  934.  
  935. void SlicingSessionImplementation::handleSliceFailed() {
  936. ManagedReference<CreatureObject*> player = this->player.get();
  937. ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
  938.  
  939. if (tangibleObject == NULL || player == NULL)
  940. return;
  941.  
  942. if (tangibleObject->isMissionTerminal())
  943. player->sendSystemMessage("@slicing/slicing:terminal_fail");
  944. else if (tangibleObject->isWeaponObject())
  945. player->sendSystemMessage("@slicing/slicing:fail_weapon");
  946. else if (tangibleObject->isArmorObject())
  947. player->sendSystemMessage("@slicing/slicing:fail_armor");
  948. else if (tangibleObject->isContainerObject() || tangibleObject->getGameObjectType() == SceneObjectType::PLAYERLOOTCRATE)
  949. player->sendSystemMessage("@slicing/slicing:container_fail");
  950. else if (isBaseSlice())
  951. player->sendSystemMessage("@slicing/slicing:hq_security_fail"); // Unable to sucessfully slice the terminal, you realize that the only away
  952. else
  953. player->sendSystemMessage("Your attempt to slice the object has failed.");
  954.  
  955. if (tangibleObject->isContainerObject()) {
  956.  
  957. ManagedReference<Container*> container = tangibleObject.castTo<Container*>();
  958. Locker clocker(container, player);
  959.  
  960. if (!container)
  961. return;
  962.  
  963. container->setSliced(true);
  964. if (!container->isRelocking())
  965. {
  966. relockEvent = new RelockLootContainerEvent(container);
  967. relockEvent->schedule(container->getLockTime()); // This will reactivate the 'broken' lock. (1 Hour)
  968. }
  969.  
  970. } else if (isBaseSlice()){
  971.  
  972. Zone* zone = player->getZone();
  973. if (zone != NULL) {
  974. GCWManager* gcwMan = zone->getGCWManager();
  975. if(gcwMan != NULL)
  976. gcwMan->failSecuritySlice(tangibleObject.get());
  977.  
  978. }
  979. } else if (!tangibleObject->isMissionTerminal()) {
  980. tangibleObject->setSliced(true);
  981. }
  982.  
  983. endSlicing();
  984.  
  985. }
  986. int SlicingSessionImplementation::cancelSession() {
  987. ManagedReference<CreatureObject*> player = this->player.get();
  988. ManagedReference<TangibleObject*> tangibleObject = this->tangibleObject.get();
  989. if (player != NULL) {
  990. player->dropActiveSession(SessionFacadeType::SLICING);
  991. player->getPlayerObject()->removeSuiBoxType(SuiWindowType::SLICING_MENU);
  992. }
  993. if (tangibleObject != NULL)
  994. tangibleObject->dropActiveSession(SessionFacadeType::SLICING);
  995. clearSession();
  996. return 0;
  997. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement