Compare commits

..

247 Commits

Author SHA1 Message Date
MagicBot 44b9ba911d Indices added to command output. 2023-09-15 17:29:51 -04:00
MagicBot c24f8fc85b Login check modified for testing. 2023-09-15 14:23:34 -04:00
MagicBot 75c56cbeee Devcmd output updated. 2023-09-14 14:11:26 -04:00
MagicBot 15f42c9658 Devcmd output updated. 2023-09-14 13:54:22 -04:00
MagicBot 525d0c21bb Devcmd output updated. 2023-09-14 13:41:07 -04:00
MagicBot cbf05cfe5b Devcmd output updated. 2023-09-14 13:30:46 -04:00
MagicBot aaa506a581 Divisor testing. 2023-09-14 13:21:02 -04:00
MagicBot a2fbfad00e Revert initialize. 2023-09-14 13:07:32 -04:00
MagicBot 031c52e25a Divisor test. 2023-09-14 13:03:06 -04:00
MagicBot 693dfd827c Updated dev cmd output 2023-09-14 13:01:22 -04:00
MagicBot d26a2d35bf Multiple not divide 2023-09-14 12:39:31 -04:00
MagicBot 9839de128c Variable initialized. 2023-09-14 12:38:47 -04:00
MagicBot 12872ee51e Variable initialized. 2023-09-14 12:30:54 -04:00
MagicBot 2af08d6823 Reformat file. 2023-09-14 12:29:26 -04:00
MagicBot f646075311 Static method to save memory. 2023-09-14 12:28:36 -04:00
MagicBot dfca767476 Multiple not divide. 2023-09-14 12:25:18 -04:00
MagicBot fd7b5952c2 Dev command updated 2023-09-14 12:21:12 -04:00
MagicBot 4b46eddc47 Dev command updated 2023-09-14 12:09:50 -04:00
MagicBot e26121177f World altitude set in setparent. 2023-09-14 12:07:08 -04:00
MagicBot 91eb0c314f SeAudit command created 2023-09-14 10:14:31 -04:00
MagicBot 1d7a2d4eae Added sea level info to command. 2023-09-14 10:09:10 -04:00
MagicBot e4235d4d75 Bugfix in setparent. 2023-09-14 09:13:02 -04:00
FatBoy 41a83115be safehold guard exclusion from equipment dropping 2023-09-13 22:34:57 -05:00
FatBoy 3ce887cb34 NPC are immune to all 2023-09-13 22:30:24 -05:00
FatBoy 874eb6189e NPC apply runes 2023-09-13 22:24:10 -05:00
FatBoy 5c5c491597 debug code 2023-09-13 22:10:22 -05:00
FatBoy ff78c1443c null check 2023-09-13 22:04:23 -05:00
FatBoy cdc1c2d776 region assignment 2023-09-13 21:58:20 -05:00
FatBoy a004c247ab abstract character cleanup 2023-09-13 21:57:17 -05:00
FatBoy 048e90fb8f NPC all apply "shopkeeper" rune 2023-09-13 21:56:18 -05:00
FatBoy c1498145e6 NPC rune work 2023-09-13 21:45:15 -05:00
FatBoy 7654d5183a region lookup and height offset for AbstractCharacters when setLoc is called 2023-09-13 21:28:20 -05:00
FatBoy 9b7fc0a93b region height work 2023-09-13 21:07:57 -05:00
FatBoy 200318ddcf add region height to world height in setLoc 2023-09-13 20:48:02 -05:00
FatBoy 1fdd0a1b32 initialize runes array list for NPC 2023-09-13 20:45:21 -05:00
FatBoy 8869772fa4 print effects command 2023-09-13 20:34:48 -05:00
FatBoy 96bc894962 print runes command 2023-09-13 20:27:38 -05:00
FatBoy 5a9f5f2eca NPCs apply runes from set 2023-09-13 20:22:56 -05:00
FatBoy bd9dbcbb42 NPCs load rune sets 2023-09-13 20:12:07 -05:00
FatBoy f8269bb764 character runes moved form PlayerCharacter to AbstractCharacter 2023-09-13 20:06:12 -05:00
FatBoy c215047c00 teleport method removed form PLayerCharacter to use AbstractCharacter.teleport instead 2023-09-13 20:00:23 -05:00
FatBoy a313e3f364 setRegion removal 2023-09-13 19:56:54 -05:00
FatBoy b34be1184e null region assignment 2023-09-13 19:53:13 -05:00
FatBoy e23c5527da null region assignment 2023-09-13 19:52:17 -05:00
FatBoy 847e62dd27 setLoc now handles region assignment 2023-09-13 19:51:39 -05:00
MagicBot f5d83aa259 Class cleanup of bonus code and unused methods. 2023-09-13 09:38:10 -04:00
MagicBot 4a5c0ae5a0 Cities don't actually have a location. They are a property of a zone. Let's start here. 2023-09-13 09:29:42 -04:00
MagicBot b4a4323906 Minor formatting cleanup. 2023-09-13 09:24:40 -04:00
MagicBot 48fc5af5f7 Removed unused variables from class. 2023-09-13 07:33:02 -04:00
MagicBot a1753a28ec Player cities write correct offset. 2023-09-13 07:29:29 -04:00
MagicBot fa4039cf63 Add y offset to zone altitude. 2023-09-12 16:25:46 -04:00
MagicBot 4b0814c0a1 Add y offset to zone altitude. 2023-09-12 16:24:47 -04:00
MagicBot 78d0b06b36 Revert for testing. 2023-09-12 16:22:41 -04:00
MagicBot 426bdf5df3 Removed yoffset from world altitude. 2023-09-12 16:13:27 -04:00
MagicBot 5dbad7ebd0 Player cities set to white. 2023-09-12 15:33:52 -04:00
MagicBot 6ef33c5b7f Update to world altitude calculation 2023-09-12 15:27:00 -04:00
MagicBot 3737a6eace Sea level logic updated. 2023-09-12 15:18:09 -04:00
MagicBot 967e129724 Sea level logic updated. 2023-09-12 15:09:52 -04:00
MagicBot e9d549377e Sea level logic updated. 2023-09-12 15:06:26 -04:00
MagicBot 924b8af827 Sea level logic updated. 2023-09-12 14:57:47 -04:00
MagicBot 045ee73b61 rework of world altitude calculation. 2023-09-12 14:51:04 -04:00
MagicBot 5d9d13ce07 Any argument rebuilds world altitude. 2023-09-12 13:06:46 -04:00
MagicBot 5a1347ec50 Devcmd updated 2023-09-12 13:01:32 -04:00
MagicBot c705f45856 Devcmd updated 2023-09-12 12:38:20 -04:00
MagicBot 83fc129d05 Dev command output update. 2023-09-11 15:59:08 -04:00
MagicBot d7cde3a77f Grid flip testing 2023-09-11 15:41:44 -04:00
MagicBot afb1ad8e94 Grid flip testing 2023-09-11 15:36:59 -04:00
MagicBot 15a79ee9bd devcmd output updated with grid. 2023-09-11 14:37:16 -04:00
MagicBot 68794c170b Removed usless method: added grid to cmd output. 2023-09-11 14:30:14 -04:00
MagicBot a9d84749ba Removed worthless command. 2023-09-11 14:26:06 -04:00
MagicBot dd5fc323ef bugfix in array loading 2023-09-11 14:06:22 -04:00
MagicBot cf1547d077 DevCmd Updated 2023-09-11 13:57:05 -04:00
MagicBot 9664c99e06 DevCmd Updated 2023-09-11 13:50:56 -04:00
MagicBot 17b7fb6999 Unused method 2023-09-11 13:48:16 -04:00
MagicBot 21a4db8a81 Pixels set to 0 2023-09-11 13:40:47 -04:00
MagicBot eabdabcfcd No insane bucket widths. 2023-09-11 12:38:46 -04:00
MagicBot c548383a4c Should not be putting empty maps into the collection with id 0. 2023-09-11 12:35:58 -04:00
MagicBot 7337f4be1e DevCmd update. 2023-09-11 12:14:42 -04:00
MagicBot d84f223b9d DevCmd update. 2023-09-11 12:08:39 -04:00
MagicBot 5431112186 DevCmd update. 2023-09-11 11:35:53 -04:00
MagicBot ff743151c6 DevCmd update. 2023-09-11 11:25:28 -04:00
MagicBot b923392b53 DevCmd update. 2023-09-11 11:18:22 -04:00
MagicBot 15d272c621 DevCmd update. 2023-09-11 11:17:34 -04:00
MagicBot eefa50b2c3 DevCmd update. 2023-09-11 11:14:55 -04:00
MagicBot ecc7a152f7 DevCmd update. 2023-09-11 11:08:03 -04:00
MagicBot 7bf31f9a47 Rework of class interface. 2023-09-11 11:01:09 -04:00
MagicBot 7dc970ff53 Rework of dev command; junk deleted. 2023-09-11 10:50:01 -04:00
FatBoy 97d71ec361 move to point handler revert 2023-09-11 01:36:45 -05:00
FatBoy 003b939d33 Move to point message variable naming and handler cleanup 2023-09-10 19:37:46 -05:00
FatBoy 9989cbff24 pc.teleport uneeded 2023-09-10 17:20:30 -05:00
FatBoy 426ef989f8 can no longer run to invalid targets 2023-09-10 16:45:17 -05:00
FatBoy ca6e079053 fresh start 2023-09-10 15:51:25 -05:00
FatBoy 13644fd308 use target from message in move to point 2023-09-10 15:02:26 -05:00
FatBoy 1ec76ae3fc use target from message in move to point 2023-09-10 14:58:56 -05:00
FatBoy 51d75146cc NPC added to attack message handler switch 2023-09-10 14:28:32 -05:00
FatBoy bc4222646d combat target usage 2023-09-10 14:12:01 -05:00
FatBoy c3e206e3b1 null check 2023-09-10 14:09:48 -05:00
FatBoy 04147e11cc logic for moveToPoint message handler 2023-09-10 14:08:54 -05:00
FatBoy 545cb4cddf null check for building pulled 2023-09-10 13:40:19 -05:00
FatBoy 0f948d4e2a removed redundant setCombatTarget 2023-09-10 13:39:27 -05:00
FatBoy 5fb3e0fe14 switch for target type in attack message handler 2023-09-10 13:38:07 -05:00
MagicBot fb87dfd91e TargetType declared. 2023-09-10 14:33:04 -04:00
FatBoy be8967b05f null set for target 2023-09-10 13:28:46 -05:00
FatBoy 8acfff7faa null check for target 2023-09-10 13:26:28 -05:00
FatBoy 18e1f4bd28 early exits for attack message handler 2023-09-10 13:25:08 -05:00
MagicBot 74f88a6643 Unused variable removed 2023-09-10 14:04:48 -04:00
FatBoy 47fe764cb0 early exits for attack message handler 2023-09-10 12:58:24 -05:00
MagicBot 9e53770e6c Handler added to protocol class. 2023-09-10 13:55:16 -04:00
MagicBot a9cc001791 Handler added to protocol class. 2023-09-10 13:53:12 -04:00
MagicBot c24913d124 Handler filled in with logic. 2023-09-10 13:52:04 -04:00
MagicBot 63bf0b6070 Handler created for AttackMsg 2023-09-10 13:43:28 -04:00
FatBoy 50792327a4 moveToPoint attack handling 2023-09-10 12:31:39 -05:00
FatBoy 46e67be8ca player character attacks added to city outlaws 2023-09-10 11:57:52 -05:00
FatBoy e7c3ba5eba guards and siege engines ignore idle state with no players loaded 2023-09-09 22:30:45 -05:00
FatBoy ea86ab2300 guards will revert cmbat target to null if its a player and is no longer loaded 2023-09-09 22:23:25 -05:00
FatBoy 501e8c937f guards use city player memory to determine whether they go idle or not 2023-09-09 22:10:10 -05:00
FatBoy cae5c36d84 guards will aggro siege equipment not belonging to the guild 2023-09-09 22:01:59 -05:00
FatBoy 1b92fa76e1 characters that attack city friendly buildings are added to cityOutlaws 2023-09-09 21:48:22 -05:00
FatBoy bbdb683061 players who attack buildinsg added to cityOutlaw list 2023-09-09 21:43:29 -05:00
FatBoy 2d04547c74 display seeInvis level in aiInfo command 2023-09-09 21:19:29 -05:00
FatBoy 5192c801f7 CombatUtilities cleanup 2023-09-09 20:56:19 -05:00
FatBoy d966d50bd5 removed duplicate variables in MobBase 2023-09-09 20:40:52 -05:00
FatBoy 7e20db33f2 final guard stat revisions 2023-09-09 20:37:47 -05:00
FatBoy 669ee7215b added range modification for guards 2023-09-09 20:11:00 -05:00
FatBoy 6fa00a43a4 removed unused method 2023-09-09 20:06:33 -05:00
FatBoy 4edf740179 finished modifications for guards 2023-09-09 19:57:17 -05:00
FatBoy c7abb4c920 stance modifiers for guards 2023-09-09 19:41:32 -05:00
FatBoy df3964110a stances for guards 2023-09-09 19:23:46 -05:00
FatBoy 96231260bc consolidated all guards to GuardLogic 2023-09-09 10:37:40 -05:00
FatBoy 967303d2de outlaw and hate value moved to modifyHealth 2023-09-09 10:20:25 -05:00
FatBoy 955481773d wall archer early exit for canCast 2023-09-09 09:52:47 -05:00
FatBoy d66a7049e8 guard walking bug fix 2023-09-09 09:35:03 -05:00
MagicBot e73b8d2826 Harden against null 2023-09-09 10:20:20 -04:00
MagicBot ea23003807 Hirelings removed from zone mob set 2023-09-09 10:16:36 -04:00
MagicBot 23f41f8ae7 Minions always have offset not determined by captain being alive. 2023-09-09 09:26:55 -04:00
MagicBot 3f416f83d3 Patrol points only set once. 2023-09-09 09:11:43 -04:00
MagicBot 931d1992b6 Patrol points are reset each patrol. 2023-09-09 09:10:08 -04:00
MagicBot fd927a7052 New method implemented. 2023-09-09 08:58:41 -04:00
MagicBot dd46224afe New method implemented. 2023-09-09 08:44:00 -04:00
MagicBot be2b29ccc7 New method implemented. 2023-09-09 08:38:00 -04:00
MagicBot c93e3bc947 Update to ordering of logic 2023-09-09 08:34:09 -04:00
MagicBot 7d49395c41 New method implemented. 2023-09-09 08:31:20 -04:00
MagicBot f4c9e6d7b8 Remove hireling method defined in manager. 2023-09-09 08:28:03 -04:00
MagicBot b7a907c8c8 db method to support removing all minions 2023-09-09 08:04:56 -04:00
MagicBot 36485a0f01 Formation enforced when captain is dead. 2023-09-08 12:44:36 -04:00
MagicBot efec1b4444 Load data only. 2023-09-08 12:39:04 -04:00
MagicBot bdf6500260 Outlaw moved before guild check. 2023-09-07 14:14:21 -04:00
MagicBot db4eb0579e Aggro code removed from check to send mob home. 2023-09-07 13:37:32 -04:00
MagicBot 76f33534d4 Captains force march minions 2023-09-07 13:09:25 -04:00
MagicBot 39fea5bc2f Captains order minions to patrol 2023-09-07 12:42:43 -04:00
MagicBot 660d5c1270 Captains order minions to patrol 2023-09-07 12:41:20 -04:00
MagicBot 781e2fc9b2 Comment adjusted 2023-09-07 12:27:23 -04:00
MagicBot c2a2464fe8 Errant delimiter removed. 2023-09-07 12:25:52 -04:00
MagicBot beb3c15eb3 Miniond patrol on own if captain is dead. 2023-09-07 12:24:45 -04:00
MagicBot 553010bb7b Minions get marching orders from captain 2023-09-07 12:07:39 -04:00
MagicBot 8d12bbf453 Formation offset for minions. 2023-09-07 11:48:42 -04:00
MagicBot fa7588826a Pets set to not alive when dismissing. 2023-09-07 11:15:30 -04:00
MagicBot 332f191e19 Merged switch cases. 2023-09-07 10:56:46 -04:00
MagicBot 8151382a6b Patrol points inherited from barracks not captain. 2023-09-07 10:49:07 -04:00
MagicBot ae44a21be1 Duplicate range check removed. 2023-09-07 10:40:27 -04:00
MagicBot b0ff0995de Start consolidation of guard logic 2023-09-07 10:37:09 -04:00
MagicBot e711095ecd Start consolidation of guard logic 2023-09-07 10:36:18 -04:00
MagicBot 08de97a2a8 Guild check removed from outlaw condition. 2023-09-07 09:55:55 -04:00
MagicBot 5eb6302d2a Null check is made before this method call. 2023-09-05 15:56:49 -04:00
MagicBot 2e346ae7fd Rework of combat deference to captain. 2023-09-05 15:51:14 -04:00
MagicBot 1285d12915 Consolidated cast methods. 2023-09-05 14:25:24 -04:00
MagicBot 8b5cb9258e dd roll removed 2023-09-05 14:09:48 -04:00
MagicBot ef3e3a0392 .contains check needed. 2023-09-05 13:43:09 -04:00
MagicBot 8fca6572f9 Typo in comment fixed. 2023-09-05 13:10:17 -04:00
MagicBot 33eaf0e583 Outlaws added to aiinfo. 2023-09-05 13:04:56 -04:00
MagicBot 16acd1c08c Simplify logic; variable is provided. 2023-09-05 12:55:12 -04:00
MagicBot a8e8804ce3 Attacking guard flags you as an outlaw. 2023-09-05 12:34:46 -04:00
MagicBot b8c0f997f6 Fix typo in thread name. 2023-09-05 12:30:47 -04:00
MagicBot 11e63f38b1 Update to mob retaliate logic. 2023-09-05 12:19:50 -04:00
MagicBot ff36d8f3db Modification to minion retaliate. 2023-09-05 08:27:34 -04:00
MagicBot 975542d8af sql column update. 2023-09-04 15:21:04 -04:00
MagicBot d71a9415b4 Integer object not int signature. 2023-09-04 15:09:51 -04:00
MagicBot e948da95b5 Column name updated. 2023-09-04 14:58:13 -04:00
MagicBot 9a6510c320 Minions now use copyonwrite collection. Slot agnostic. 2023-09-04 14:50:59 -04:00
MagicBot 57ff1ede97 Name is all that's needed. 2023-09-04 14:16:36 -04:00
MagicBot 7c0f2563f7 Already added to collection at this point. 2023-09-04 13:09:32 -04:00
FatBoy d11a954b40 remove test block 2023-09-03 20:41:21 -05:00
FatBoy f354339af1 null checks 2023-09-03 20:38:48 -05:00
FatBoy 89658bb77a null checks 2023-09-03 20:28:17 -05:00
FatBoy 1ff0238b6e skill loading bypass for guards 2023-09-03 20:22:01 -05:00
FatBoy e777434d57 Mob specific rune skill loading 2023-09-03 20:10:57 -05:00
FatBoy ee6efc30a3 rune skill loading broken into static method in NPCManager 2023-09-03 19:52:16 -05:00
FatBoy 0758bb5f38 SkillsBase are now cached when missing for mobs 2023-09-03 19:44:33 -05:00
FatBoy 299d5725a6 lookup using name 2023-09-03 19:31:04 -05:00
FatBoy d7c9b31ec7 indentation and comment 2023-09-03 19:24:34 -05:00
FatBoy 6c78bee5c1 null check 2023-09-03 19:24:06 -05:00
FatBoy dba0cbd5f9 skill type not name used 2023-09-03 19:22:28 -05:00
FatBoy 0752e780f2 mobs load skills 2023-09-03 19:19:18 -05:00
MagicBot c43919ce01 Level loaded into object. 2023-09-03 09:48:37 -04:00
MagicBot 0d95510b72 captain uuid added to aiInfoCmd 2023-09-03 09:15:20 -04:00
MagicBot 60fb2571a2 Support for loading of skill adjustment map. 2023-09-03 08:18:48 -04:00
MagicBot 90cbe90492 Merge remote-tracking branch 'origin/mobile-effects' into magicbox-1.5.2 2023-09-03 07:33:50 -04:00
FatBoy 95c203b0ed load and apply mobbaseSkill 2023-09-02 20:39:36 -05:00
FatBoy 449c5c5c77 infrastructure for mob skills loading 2023-09-02 20:29:03 -05:00
FatBoy 9aff208403 guard captains to move tot heir first patrol point right away 2023-09-02 19:43:40 -05:00
FatBoy 4318849127 minion relatiate handled inside retaliate function 2023-09-02 19:34:08 -05:00
FatBoy 29e8cdf699 attacking guard minion will no longer be ignored 2023-09-02 19:23:33 -05:00
MagicBot 4427dbdcad Fix in exception for werwolf/werebear (magic numbers) 2023-09-02 16:28:16 -04:00
MagicBot af4c3819b9 contract added to aiInfoCmd 2023-09-02 16:18:05 -04:00
MagicBot 39379e1ac0 Sight check moved out of cancast. 2023-09-02 16:04:40 -04:00
MagicBot 71eeb3f6b8 Variable hidden elevated to abschar. 2023-09-02 15:57:23 -04:00
MagicBot d409ef49af Can cast added to aiinfo. 2023-09-02 15:44:42 -04:00
MagicBot e7a80e9280 Comment cleanup 2023-09-02 15:33:12 -04:00
MagicBot 65c2d2ea0b Logic cleanup when dealing with contracts. 2023-09-02 15:30:10 -04:00
MagicBot 92666dca21 Invis check precedes power check. 2023-09-02 15:25:19 -04:00
MagicBot 3e1a79c248 AI info dev command updated. 2023-09-02 15:11:17 -04:00
MagicBot 73a1ce083a Unused method removed. 2023-09-02 15:00:38 -04:00
MagicBot 22dacebc5e Override unnecessary. 2023-09-02 15:00:06 -04:00
MagicBot 80d0948e24 Contract power handling now additive. 2023-09-02 14:04:47 -04:00
MagicBot 58b427b977 Contract support added to mobile ai when gathering powers. 2023-09-02 13:34:26 -04:00
MagicBot a4cab3565a Value cannot be null. Set early in runafterload. 2023-09-02 13:16:34 -04:00
MagicBot 205c9580e3 sql column name fix. 2023-09-02 12:52:55 -04:00
MagicBot 70a0ed135b Refactored mob powers to rune powers. Now uses rune_id to call into system which is derived in the getter to support minions. 2023-09-02 12:47:04 -04:00
FatBoy f556181d77 guardlist serialization displays correct minion rank 2023-09-01 22:15:29 -05:00
FatBoy d48e26904e revert last commit 2023-09-01 22:06:21 -05:00
FatBoy 19232ac405 archers added to human guards as minions 2023-09-01 22:01:09 -05:00
FatBoy 9ee2ccc8af werebear and werewolf guard can use powers 2023-09-01 21:48:57 -05:00
FatBoy 7079bb6a63 resist loading refactored as static method to NPCManager 2023-09-01 21:39:34 -05:00
FatBoy 0ab5827ee5 mobs to load equipment resists 2023-09-01 21:34:48 -05:00
FatBoy c5443f622c utilization and assignment of aiAgentType 2023-09-01 20:57:09 -05:00
FatBoy e4aa276cca cleanup old code 2023-09-01 20:42:33 -05:00
FatBoy 90ff2d679e create and use applyMobbaseEffects method, remove old unused methods 2023-09-01 20:39:31 -05:00
FatBoy da26c35d5a mobbase loads effectsList 2023-09-01 20:36:07 -05:00
MagicBot 779e3da74e Cleanup of clear minion logic. 2023-09-01 14:33:33 -04:00
MagicBot e358c08773 Removed msg from handler. 2023-09-01 14:23:55 -04:00
MagicBot 2945fa3a47 Class reformat and removal of try block. 2023-09-01 14:17:07 -04:00
MagicBot ab1541e741 Class not needed on login server. 2023-09-01 14:09:48 -04:00
MagicBot 3aeaa709a5 Comment cleanup 2023-09-01 14:07:00 -04:00
MagicBot 91e627df6b AI moved to top of runafterload. 2023-09-01 14:05:50 -04:00
MagicBot d0795e9e1c Rework of agent type init in runafterload. Only used for 2 instances from disk. 2023-09-01 13:57:58 -04:00
MagicBot 0e12dd4874 Contract powers loaded first to preserve ordering. 2023-09-01 12:57:20 -04:00
MagicBot 25c0e48181 Loot bypass now uses agent type. 2023-09-01 12:55:33 -04:00
MagicBot 0d43c3620d Value is set earlier. 2023-09-01 12:50:57 -04:00
MagicBot 2f6137f8df Minion agent type set properly. 2023-09-01 12:38:23 -04:00
FatBoy 2843b86a93 Moved agent type to top of constructor. 2023-09-01 12:29:06 -04:00
MagicBot 8235de07ff Updated output of devcmd. 2023-08-31 14:00:34 -04:00
MagicBot e2f9a4c7f0 Guard minions inherit powers from captain. 2023-08-31 13:57:46 -04:00
MagicBot 55c6e3cf93 Refactored out duplicate power collection. 2023-08-31 13:42:15 -04:00
MagicBot 11c154e564 Assignment fix and comment cleanup. 2023-08-31 08:58:55 -04:00
MagicBot 7fc0d27c3c Siege engine agent type set properly. 2023-08-31 08:31:48 -04:00
MagicBot 1ac76cfcd8 isPlayerguard refactored to derive from agenttype. 2023-08-31 08:13:37 -04:00
MagicBot c8ed04aaaf Refactor to separate persistence and write fsm to table. 2023-08-31 08:03:30 -04:00
158 changed files with 3962 additions and 6450 deletions
+10 -40
View File
@@ -139,8 +139,8 @@ public class Enum {
HALFGIANTMALE(2010, MonsterType.HalfGiant, RunSpeed.STANDARD, CharacterSex.MALE, 1.15f),
HUMANMALE(2011, MonsterType.Human, RunSpeed.STANDARD, CharacterSex.MALE, 1),
HUMANFEMALE(2012, MonsterType.Human, RunSpeed.STANDARD, CharacterSex.FEMALE, 1),
IREKEIMALE(2013, MonsterType.Irekei, RunSpeed.IREKEI, CharacterSex.MALE, 1.1f),
IREKEIFEMALE(2014, MonsterType.Irekei, RunSpeed.IREKEI, CharacterSex.FEMALE, 1.1f),
IREKEIMALE(2013, MonsterType.Irekei, RunSpeed.STANDARD, CharacterSex.MALE, 1.1f),
IREKEIFEMALE(2014, MonsterType.Irekei, RunSpeed.STANDARD, CharacterSex.FEMALE, 1.1f),
SHADEMALE(2015, MonsterType.Shade, RunSpeed.STANDARD, CharacterSex.MALE, 1),
SHADEFEMALE(2016, MonsterType.Shade, RunSpeed.STANDARD, CharacterSex.FEMALE, 1),
MINOMALE(2017, MonsterType.Minotaur, RunSpeed.MINOTAUR, CharacterSex.MALE, 1.3f),
@@ -152,9 +152,7 @@ public class Enum {
NEPHFEMALE(2026, MonsterType.Nephilim, RunSpeed.STANDARD, CharacterSex.FEMALE, 1.1f),
HALFGIANTFEMALE(2027, MonsterType.HalfGiant, RunSpeed.STANDARD, CharacterSex.FEMALE, 1.15f),
VAMPMALE(2028, MonsterType.Vampire, RunSpeed.STANDARD, CharacterSex.MALE, 1),
VAMPFEMALE(2029, MonsterType.Vampire, RunSpeed.STANDARD, CharacterSex.FEMALE, 1),
SAETOR(1999, MonsterType.Minotaur, RunSpeed.MINOTAUR, CharacterSex.MALE, 0.80000001f),
LIZARDMAN(1998, MonsterType.Reptile, RunSpeed.STANDARD, CharacterSex.MALE, 1.05f);
VAMPFEMALE(2029, MonsterType.Vampire, RunSpeed.STANDARD, CharacterSex.FEMALE, 1);
@SuppressWarnings("unchecked")
private static HashMap<Integer, RaceType> _raceTypeByID = new HashMap<>();
@@ -210,7 +208,6 @@ public class Enum {
SENTINEL(0, 0, 0, 0, 0, 0, 0),
STANDARD(6.1900001f, 13.97f, 4.2199998f, 13.97f, 6.3299999f, 18.379999f, 6.5f),
CENTAUR(6.1900001f, 16.940001f, 5.5500002f, 16.940001f, 6.3299999f, 18.379999f, 6.5f),
IREKEI(6.35f, 15.25f, 4.2199998f, 14.5f, 6.3299999f, 18.379999f, 6.5f),
MINOTAUR(6.6300001f, 15.95f, 4.2199998f, 15.95f, 6.3299999f, 18.379999f, 6.5f);
private float walkStandard;
@@ -963,17 +960,7 @@ public class Enum {
SourceType returnMod;
if (modName.isEmpty())
return SourceType.None;
switch(modName) {
case "Piercing":
modName = "Pierce";
break;
case "Crushing":
modName = "Crush";
break;
case "Slashing":
modName = "Slash";
break;
}
try {
returnMod = SourceType.valueOf(modName.replace(",", ""));
} catch (Exception e) {
@@ -1665,24 +1652,6 @@ public class Enum {
return extents;
}
public boolean isTrainerBuilding(){
switch(this){
case AMAZONHALL:
case CATHEDRAL:
case GREATHALL:
case KEEP:
case THIEFHALL:
case TEMPLEHALL:
case WIZARDHALL:
case ELVENHALL:
case ELVENSANCTUM:
case IREKEIHALL:
case FORESTHALL:
return true;
}
return false;
}
}
public enum UpdateType {
@@ -2338,8 +2307,8 @@ public class Enum {
public enum CityBoundsType {
GRID(640),
ZONE(680),
PLACEMENT(681);
ZONE(875),
PLACEMENT(876);
public final float extents;
@@ -2908,10 +2877,11 @@ public class Enum {
public enum AIAgentType {
MOBILE,
GUARDCAPTAIN,
GUARDMINION,
GUARDWALLARCHER,
PET,
CHARMED,
SIEGEENGINE,
GUARD;
SIEGEENGINE;
}
}
+59 -304
View File
@@ -14,9 +14,7 @@ import engine.gameManager.DbManager;
import engine.gameManager.ZoneManager;
import engine.math.Vector2f;
import engine.math.Vector3fImmutable;
import engine.objects.AbstractWorldObject;
import engine.objects.Zone;
import engine.util.MapLoader;
import org.pmw.tinylog.Logger;
import javax.imageio.ImageIO;
@@ -32,6 +30,7 @@ public class HeightMap {
// Class variables
public static float SCALEVALUE = 1.0f / 256;
// Heightmap data for all zones.
public static final HashMap<Integer, HeightMap> heightmapByLoadNum = new HashMap<>();
@@ -45,17 +44,17 @@ public class HeightMap {
public BufferedImage heightmapImage;
private int heightMapID;
private int maxHeight;
private int fullExtentsX;
private int fullExtentsY;
private final int heightMapID;
private final int maxHeight;
private final int fullExtentsX;
private final int fullExtentsY;
private float bucketWidthX;
private float bucketWidthY;
private int zoneLoadID;
private final int zoneLoadID;
private float seaLevel = 0;
private float outsetX;
private float outsetZ;
private final float outsetX;
private final float outsetZ;
private int[][] pixelColorValues;
public HeightMap(ResultSet rs) throws SQLException {
@@ -88,12 +87,12 @@ public class HeightMap {
try {
this.heightmapImage = ImageIO.read(imageFile);
} catch (IOException e) {
Logger.error("***Error loading heightmap data for heightmap " + this.heightMapID + e.toString());
Logger.error("***Error loading heightmap data for heightmap " + this.heightMapID + e);
}
// We needed to flip the image as OpenGL and Shadowbane both use the bottom left corner as origin.
this.heightmapImage = MapLoader.flipImage(this.heightmapImage);
// this.heightmapImage = MapLoader.flipImage(this.heightmapImage);
// Calculate the data we do not load from table
@@ -104,7 +103,7 @@ public class HeightMap {
// Generate pixel array from image data
generatePixelData();
generatePixelData(this);
HeightMap.heightmapByLoadNum.put(this.zoneLoadID, this);
@@ -123,35 +122,26 @@ public class HeightMap {
this.outsetX = 128;
this.outsetZ = 128;
// Cache the full extents to avoid the calculation
this.fullExtentsX = halfExtentsX * 2;
this.fullExtentsY = halfExtentsY * 2;
// load the heightmap image.
// We needed to flip the image as OpenGL and Shadowbane both use the bottom left corner as origin.
this.heightmapImage = null;
// Calculate the data we do not load from table
this.bucketWidthX = 1;
this.bucketWidthY = 1;
this.bucketWidthX = halfExtentsX;
this.bucketWidthY = halfExtentsY;
this.pixelColorValues = new int[this.fullExtentsX + 1][this.fullExtentsY + 1];
this.pixelColorValues = new int[this.fullExtentsX][this.fullExtentsY];
for (int y = 0; y <= this.fullExtentsY; y++) {
for (int x = 0; x <= this.fullExtentsX; x++) {
for (int y = 0; y < this.fullExtentsY; y++) {
for (int x = 0; x < this.fullExtentsX; x++) {
pixelColorValues[x][y] = 255;
}
}
HeightMap.heightmapByLoadNum.put(this.zoneLoadID, this);
}
public HeightMap(Zone zone) {
@@ -170,26 +160,21 @@ public class HeightMap {
this.fullExtentsX = halfExtentsX * 2;
this.fullExtentsY = halfExtentsY * 2;
// We needed to flip the image as OpenGL and Shadowbane both use the bottom left corner as origin.
this.heightmapImage = null;
// Calculate the data we do not load from table
this.bucketWidthX = 1;
this.bucketWidthY = 1;
this.bucketWidthX = halfExtentsX;
this.bucketWidthY = halfExtentsY;
this.pixelColorValues = new int[this.fullExtentsX + 1][this.fullExtentsY + 1];
this.pixelColorValues = new int[this.fullExtentsX][this.fullExtentsY];
for (int y = 0; y <= this.fullExtentsY; y++) {
for (int x = 0; x <= this.fullExtentsX; x++) {
pixelColorValues[x][y] = 255;
for (int y = 0; y < this.fullExtentsY; y++) {
for (int x = 0; x < this.fullExtentsX; x++) {
pixelColorValues[x][y] = 0;
}
}
HeightMap.heightmapByLoadNum.put(this.zoneLoadID, this);
}
public static void GeneratePlayerCityHeightMap() {
@@ -222,113 +207,9 @@ public class HeightMap {
return nextZone;
}
public static float getWorldHeight(AbstractWorldObject worldObject) {
public static float getWorldHeight(Zone currentZone, Vector3fImmutable worldLoc) {
Vector2f parentLoc = new Vector2f(-1, -1);
Zone currentZone = ZoneManager.findSmallestZone(worldObject.getLoc());
if (currentZone == null)
return worldObject.getAltitude();
currentZone = getNextZoneWithTerrain(currentZone);
if (currentZone == ZoneManager.getSeaFloor())
return currentZone.getAbsY() + worldObject.getAltitude();
Zone parentZone = getNextZoneWithTerrain(currentZone.getParent());
HeightMap heightMap = currentZone.getHeightMap();
Vector2f zoneLoc = ZoneManager.worldToZoneSpace(worldObject.getLoc(), currentZone);
Vector3fImmutable localLocFromCenter = ZoneManager.worldToLocal(worldObject.getLoc(), currentZone);
if ((parentZone != null) && (parentZone.getHeightMap() != null))
parentLoc = ZoneManager.worldToZoneSpace(worldObject.getLoc(), parentZone);
float interaltitude = currentZone.getHeightMap().getInterpolatedTerrainHeight(zoneLoc);
float worldAltitude = currentZone.getWorldAltitude();
float realWorldAltitude = interaltitude + worldAltitude;
//OUTSET
if (parentZone != null) {
float parentXRadius = currentZone.getBounds().getHalfExtents().x;
float parentZRadius = currentZone.getBounds().getHalfExtents().y;
float offsetX = Math.abs((localLocFromCenter.x / parentXRadius));
float offsetZ = Math.abs((localLocFromCenter.z / parentZRadius));
float bucketScaleX = heightMap.outsetX / parentXRadius;
float bucketScaleZ = heightMap.outsetZ / parentZRadius;
if (bucketScaleX <= 0.40000001)
bucketScaleX = heightMap.outsetZ / parentXRadius;
if (bucketScaleX > 0.40000001)
bucketScaleX = 0.40000001f;
if (bucketScaleZ <= 0.40000001)
bucketScaleZ = heightMap.outsetX / parentZRadius;
if (bucketScaleZ > 0.40000001)
bucketScaleZ = 0.40000001f;
float outsideGridSizeX = 1 - bucketScaleX; //32/256
float outsideGridSizeZ = 1 - bucketScaleZ;
float weight;
double scale;
if (offsetX > outsideGridSizeX && offsetX > offsetZ) {
weight = (offsetX - outsideGridSizeX) / bucketScaleX;
scale = Math.atan2((.5 - weight) * 3.1415927, 1);
float scaleChild = (float) ((scale + 1) * .5);
float scaleParent = 1 - scaleChild;
float parentAltitude = parentZone.getHeightMap().getInterpolatedTerrainHeight(parentLoc);
float parentCenterAltitude = parentZone.getHeightMap().getInterpolatedTerrainHeight(ZoneManager.worldToZoneSpace(currentZone.getLoc(), parentZone));
parentCenterAltitude += currentZone.getYCoord();
parentCenterAltitude += interaltitude;
float firstScale = parentAltitude * scaleParent;
float secondScale = parentCenterAltitude * scaleChild;
float outsetALt = firstScale + secondScale;
outsetALt += currentZone.getParent().getWorldAltitude();
realWorldAltitude = outsetALt;
} else if (offsetZ > outsideGridSizeZ) {
weight = (offsetZ - outsideGridSizeZ) / bucketScaleZ;
scale = Math.atan2((.5 - weight) * 3.1415927, 1);
float scaleChild = (float) ((scale + 1) * .5);
float scaleParent = 1 - scaleChild;
float parentAltitude = parentZone.getHeightMap().getInterpolatedTerrainHeight(parentLoc);
float parentCenterAltitude = parentZone.getHeightMap().getInterpolatedTerrainHeight(ZoneManager.worldToZoneSpace(currentZone.getLoc(), parentZone));
parentCenterAltitude += currentZone.getYCoord();
parentCenterAltitude += interaltitude;
float firstScale = parentAltitude * scaleParent;
float secondScale = parentCenterAltitude * scaleChild;
float outsetALt = firstScale + secondScale;
outsetALt += currentZone.getParent().getWorldAltitude();
realWorldAltitude = outsetALt;
}
}
return realWorldAltitude;
}
public static float getWorldHeight(Vector3fImmutable worldLoc) {
Vector2f parentLoc = new Vector2f(-1, -1);
Zone currentZone = ZoneManager.findSmallestZone(worldLoc);
if (currentZone == null)
return 0;
@@ -352,7 +233,7 @@ public class HeightMap {
float interaltitude = currentZone.getHeightMap().getInterpolatedTerrainHeight(zoneLoc);
float worldAltitude = currentZone.getWorldAltitude();
float worldAltitude = currentZone.worldAltitude;
float realWorldAltitude = interaltitude + worldAltitude;
@@ -360,9 +241,6 @@ public class HeightMap {
if (parentZone != null) {
// if (currentZone.getHeightMap() != null && parentZone.getHeightMap() != null && parentZone.getParent() != null && parentZone.getParent().getHeightMap() != null)
// return realWorldAltitude;
float parentXRadius = currentZone.getBounds().getHalfExtents().x;
float parentZRadius = currentZone.getBounds().getHalfExtents().y;
@@ -378,7 +256,6 @@ public class HeightMap {
double scale;
if (offsetX > outsideGridSizeX && offsetX > offsetZ) {
weight = (offsetX - outsideGridSizeX) / bucketScaleX;
scale = Math.atan2((.5 - weight) * 3.1415927, 1);
@@ -396,7 +273,7 @@ public class HeightMap {
float secondScale = parentCenterAltitude * scaleChild;
float outsetALt = firstScale + secondScale;
outsetALt += currentZone.getParent().getWorldAltitude();
outsetALt += currentZone.getParent().worldAltitude;
realWorldAltitude = outsetALt;
} else if (offsetZ > outsideGridSizeZ) {
@@ -415,7 +292,7 @@ public class HeightMap {
float secondScale = parentCenterAltitude * scaleChild;
float outsetALt = firstScale + secondScale;
outsetALt += currentZone.getParent().getWorldAltitude();
outsetALt += currentZone.getParent().worldAltitude;
realWorldAltitude = outsetALt;
}
}
@@ -423,85 +300,13 @@ public class HeightMap {
return realWorldAltitude;
}
public static float getOutsetHeight(float interpolatedAltitude, Zone zone, Vector3fImmutable worldLocation) {
public static float getWorldHeight(Vector3fImmutable worldLoc) {
Vector2f parentLoc;
float outsetALt = 0;
Zone currentZone = ZoneManager.findSmallestZone(worldLoc);
if (zone.getParent() == null || zone.getParent().getHeightMap() == null)
return interpolatedAltitude + zone.getWorldAltitude();
if (zone.getParent() != null && zone.getParent().getHeightMap() != null) {
parentLoc = ZoneManager.worldToZoneSpace(worldLocation, zone.getParent());
Vector3fImmutable localLocFromCenter = ZoneManager.worldToLocal(worldLocation, zone);
float parentXRadius = zone.getBounds().getHalfExtents().x;
float parentZRadius = zone.getBounds().getHalfExtents().y;
float bucketScaleX = zone.getHeightMap().outsetX / parentXRadius;
float bucketScaleZ = zone.getHeightMap().outsetZ / parentZRadius;
float outsideGridSizeX = 1 - bucketScaleX; //32/256
float outsideGridSizeZ = 1 - bucketScaleZ;
float weight;
double scale;
float offsetX = Math.abs((localLocFromCenter.x / parentXRadius));
float offsetZ = Math.abs((localLocFromCenter.z / parentZRadius));
if (offsetX > outsideGridSizeX && offsetX > offsetZ) {
weight = (offsetX - outsideGridSizeX) / bucketScaleX;
scale = Math.atan2((.5 - weight) * 3.1415927, 1);
float scaleChild = (float) ((scale + 1) * .5);
float scaleParent = 1 - scaleChild;
float parentAltitude = zone.getParent().getHeightMap().getInterpolatedTerrainHeight(parentLoc);
float parentCenterAltitude = zone.getParent().getHeightMap().getInterpolatedTerrainHeight(ZoneManager.worldToZoneSpace(zone.getLoc(), zone.getParent()));
parentCenterAltitude += zone.getYCoord();
parentCenterAltitude += interpolatedAltitude;
float firstScale = parentAltitude * scaleParent;
float secondScale = parentCenterAltitude * scaleChild;
outsetALt = firstScale + secondScale;
outsetALt += zone.getParent().getAbsY();
} else if (offsetZ > outsideGridSizeZ) {
weight = (offsetZ - outsideGridSizeZ) / bucketScaleZ;
scale = Math.atan2((.5 - weight) * 3.1415927, 1);
float scaleChild = (float) ((scale + 1) * .5);
float scaleParent = 1 - scaleChild;
float parentAltitude = zone.getParent().getHeightMap().getInterpolatedTerrainHeight(parentLoc);
float parentCenterAltitude = zone.getHeightMap().getInterpolatedTerrainHeight(ZoneManager.worldToZoneSpace(zone.getLoc(), zone));
parentCenterAltitude += zone.getYCoord();
parentCenterAltitude += interpolatedAltitude;
float firstScale = parentAltitude * scaleParent;
float secondScale = parentCenterAltitude * scaleChild;
outsetALt = firstScale + secondScale;
outsetALt += zone.getParent().getAbsY();
}
}
return outsetALt;
}
public static Vector2f getGridOffset(Vector2f gridSquare) {
int floorX = (int) gridSquare.x;
int floorY = (int) gridSquare.y;
return new Vector2f(gridSquare.x - floorX, gridSquare.y - floorY);
if (currentZone == null)
return 0;
return getWorldHeight(currentZone, worldLoc);
}
@@ -515,7 +320,6 @@ public class HeightMap {
HeightMap.GeneratePlayerCityHeightMap();
// Clear all heightmap image data as it's no longer needed.
for (HeightMap heightMap : HeightMap.heightmapByLoadNum.values()) {
@@ -530,10 +334,25 @@ public class HeightMap {
float localAltitude = HeightMap.getWorldHeight(currentLoc);
Zone zone = ZoneManager.findSmallestZone(currentLoc);
if (localAltitude < zone.getSeaLevel())
return true;
return localAltitude < zone.getSeaLevel();
}
private static void generatePixelData(HeightMap heightMap) {
Color color;
// Generate altitude lookup table for this heightmap
heightMap.pixelColorValues = new int[heightMap.heightmapImage.getWidth()][heightMap.heightmapImage.getHeight()];
for (int y = 0; y < heightMap.heightmapImage.getHeight(); y++) {
for (int x = 0; x < heightMap.heightmapImage.getWidth(); x++) {
color = new Color(heightMap.heightmapImage.getRGB(x, y));
heightMap.pixelColorValues[x][y] = color.getRed();
}
}
return false;
}
public Vector2f getGridSquare(Vector2f zoneLoc) {
@@ -541,14 +360,18 @@ public class HeightMap {
if (zoneLoc.x < 0)
zoneLoc.setX(0);
if (zoneLoc.x > this.fullExtentsX - 1)
zoneLoc.setX((this.fullExtentsX - 1) + .9999999f);
if (zoneLoc.x >= this.fullExtentsX)
zoneLoc.setX(this.fullExtentsX);
if (zoneLoc.y < 0)
zoneLoc.setY(0);
if (zoneLoc.y > this.fullExtentsY - 1)
zoneLoc.setY((this.fullExtentsY - 1) + .9999999f);
if (zoneLoc.y > this.fullExtentsY)
zoneLoc.setY(this.fullExtentsY);
// Flip Y coordinates
zoneLoc.setY(this.fullExtentsY - zoneLoc.y);
float xBucket = (zoneLoc.x / this.bucketWidthX);
float yBucket = (zoneLoc.y / this.bucketWidthY);
@@ -569,13 +392,10 @@ public class HeightMap {
int maxX = (int) (this.fullExtentsX / this.bucketWidthX);
int maxY = (int) (this.fullExtentsY / this.bucketWidthY);
//flip the Y so it grabs from the bottom left instead of top left.
//zoneLoc.setY(maxZoneHeight - zoneLoc.y);
gridSquare = getGridSquare(zoneLoc);
int gridX = (int) gridSquare.x;
int gridY = (int) (gridSquare.y);
int gridY = (int) gridSquare.y;
if (gridX > maxX)
gridX = maxX;
@@ -613,76 +433,11 @@ public class HeightMap {
interpolatedHeight += (bottomLeftHeight * (1 - offsetX) * offsetY);
interpolatedHeight += (topLeftHeight * (1 - offsetX) * (1 - offsetY));
interpolatedHeight *= (float) this.maxHeight / 256; // Scale height
interpolatedHeight *= (float) this.maxHeight * SCALEVALUE; // Scale height
return interpolatedHeight;
}
public float getInterpolatedTerrainHeight(Vector3fImmutable zoneLoc3f) {
Vector2f zoneLoc = new Vector2f(zoneLoc3f.x, zoneLoc3f.z);
Vector2f gridSquare;
if (zoneLoc.x < 0 || zoneLoc.x > this.fullExtentsX)
return -1;
if (zoneLoc.y < 0 || zoneLoc.y > this.fullExtentsY)
return -1;
//flip the Y so it grabs from the bottom left instead of top left.
//zoneLoc.setY(maxZoneHeight - zoneLoc.y);
gridSquare = getGridSquare(zoneLoc);
int gridX = (int) gridSquare.x;
int gridY = (int) (gridSquare.y);
float offsetX = (gridSquare.x - gridX);
float offsetY = gridSquare.y - gridY;
//get height of the 4 vertices.
float topLeftHeight = pixelColorValues[gridX][gridY];
float topRightHeight = pixelColorValues[gridX + 1][gridY];
float bottomLeftHeight = pixelColorValues[gridX][gridY + 1];
float bottomRightHeight = pixelColorValues[gridX + 1][gridY + 1];
float interpolatedHeight;
interpolatedHeight = topRightHeight * (1 - offsetY) * (offsetX);
interpolatedHeight += (bottomRightHeight * offsetY * offsetX);
interpolatedHeight += (bottomLeftHeight * (1 - offsetX) * offsetY);
interpolatedHeight += (topLeftHeight * (1 - offsetX) * (1 - offsetY));
interpolatedHeight *= (float) this.maxHeight / 256; // Scale height
return interpolatedHeight;
}
private void generatePixelData() {
Color color;
// Generate altitude lookup table for this heightmap
this.pixelColorValues = new int[this.heightmapImage.getWidth()][this.heightmapImage.getHeight()];
for (int y = 0; y < this.heightmapImage.getHeight(); y++) {
for (int x = 0; x < this.heightmapImage.getWidth(); x++) {
color = new Color(this.heightmapImage.getRGB(x, y));
pixelColorValues[x][y] = color.getRed();
}
}
}
public float getScaledHeightForColor(float color) {
return (color / 256) * this.maxHeight;
}
public float getBucketWidthX() {
return bucketWidthX;
}
@@ -25,7 +25,6 @@ import engine.net.client.msg.MoveToPointMsg;
import engine.net.client.msg.UnloadObjectsMsg;
import engine.objects.*;
import engine.server.MBServerStatics;
import engine.util.BoxTracker;
import org.pmw.tinylog.Logger;
import java.util.ArrayList;
@@ -110,7 +109,7 @@ public enum InterestManager implements Runnable {
origin.sendMsg(moveMsg);
}
public static void reloadCharacter(AbstractCharacter absChar, boolean sendToSelf) {
public static void reloadCharacter(AbstractCharacter absChar) {
UnloadObjectsMsg uom = new UnloadObjectsMsg();
uom.addObject(absChar);
@@ -141,7 +140,7 @@ public enum InterestManager implements Runnable {
else {
if (pc != null)
if (pcc.getSeeInvis() < pc.getHidden())
if (pcc.getSeeInvis() < pc.hidden)
continue;
if (!cc.sendMsg(uom)) {
@@ -211,7 +210,7 @@ public enum InterestManager implements Runnable {
if (origin == null)
continue;
if (!playerCharacter.enteredWorld)
if (!playerCharacter.isEnteredWorld())
continue;
if (playerCharacter.getTeleportLock().readLock().tryLock()) {
@@ -341,7 +340,7 @@ public enum InterestManager implements Runnable {
if (loadedPlayer.getObjectUUID() == player.getObjectUUID())
continue;
if (player.getSeeInvis() < loadedPlayer.getHidden())
if (player.getSeeInvis() < loadedPlayer.hidden)
continue;
if (loadedPlayer.safemodeInvis())
@@ -373,7 +372,7 @@ public enum InterestManager implements Runnable {
if (playerLoadedObject.getObjectType().equals(GameObjectType.PlayerCharacter)) {
PlayerCharacter loadedPlayer = (PlayerCharacter) playerLoadedObject;
if (player.getSeeInvis() < loadedPlayer.getHidden())
if (player.getSeeInvis() < loadedPlayer.hidden)
toRemove.add(playerLoadedObject);
else if (loadedPlayer.safemodeInvis())
toRemove.add(playerLoadedObject);
@@ -438,7 +437,7 @@ public enum InterestManager implements Runnable {
// dont load if invis
if (player.getSeeInvis() < awopc.getHidden())
if (player.getSeeInvis() < awopc.hidden)
continue;
lcm = new LoadCharacterMsg(awopc, PlayerCharacter.hideNonAscii());
@@ -525,7 +524,6 @@ public enum InterestManager implements Runnable {
player.setDirtyLoad(true);
updateStaticList(player, origin);
updateMobileList(player, origin);
BoxTracker.addPlayer(origin.machineID,player);
}
@@ -73,14 +73,6 @@ public class dbBlueprintHandler extends dbHandlerBase {
Blueprint._meshLookup.putIfAbsent(thisBlueprint.getMeshForRank(3), thisBlueprint);
Blueprint._meshLookup.putIfAbsent(thisBlueprint.getMeshForRank(7), thisBlueprint);
if(thisBlueprint.getName().contains("Vampire Shrine")){
Blueprint saetorShrine = new Blueprint(rs);
saetorShrine.setBlueprintUUID(1720000);
saetorShrine.rank1UUID = 1720000;
saetorShrine.rank3UUID = 1720000;
saetorShrine.rank7UUID = 1720000;
}
}
} catch (SQLException e) {
@@ -14,7 +14,6 @@ import engine.gameManager.DbManager;
import engine.objects.AbstractCharacter;
import engine.objects.CharacterSkill;
import engine.objects.PlayerCharacter;
import engine.objects.SkillsBase;
import engine.server.MBServerStatics;
import org.pmw.tinylog.Logger;
@@ -63,9 +63,6 @@ public abstract class dbHandlerBase {
} else {
AbstractGameObject toAdd = localClass.getConstructor(ResultSet.class).newInstance(rs);
DbManager.addToCache(toAdd);
if(toAdd.getObjectType().equals(GameObjectType.Zone) && rs.getInt("canLoad") == 0){
continue;
}
objectList.add((T) toAdd);
if (toAdd != null && toAdd instanceof AbstractWorldObject)
+2 -66
View File
@@ -28,67 +28,10 @@ public class dbItemBaseHandler extends dbHandlerBase {
public void LOAD_BAKEDINSTATS(ItemBase itemBase) {
int itemBaseID = itemBase.getUUID();
switch(itemBaseID){
case 27550://bow
case 27560://dagger
case 27570://hammer
case 27580://axe
case 27590://sword
//return new String[]{"PRE-010","SUF-260"};
itemBaseID = 8000000;
break;
case 27600://staff
//return new String[]{"PRE-334","PRE-315"};
itemBaseID = 8000010;
break;
case 188500://HA chest
case 188510://HA arms
case 188520://HA legs
case 188530://HA gloves
case 188550://HA helm
case 188720://CC hood
case 188900://MA chest
case 188910://MA Sleeves
case 188920://MA Legs
case 188930://MA gloves
case 188950://MA helm
case 189100://la chest
case 189110://la arms
case 189120://la legs
case 189130://la gloves
case 189150://la helm
case 189550://CC gloves
//return new String[]{"PRE-130", "PRE-232", "PRE-212", "PRE-222", "SUF-007"};
itemBaseID = 8000020;
break;
case 188540://HA boots
case 188940://MA boots
case 189140://LA boots
case 189560://CC boots
//return new String[]{"PRE-133", "PRE-230", "PRE-210", "PRE-220", "SUF-003","SUF-150"};
itemBaseID = 8000030;
break;
case 188700://CC robe
//return new String[]{"PRE-130", "PRE-232", "PRE-212", "PRE-222","SUF-317","SUF-317","SUF-317"};
itemBaseID = 8000040;
break;
case 189500://MA shield
case 189510://HA shield
//return new String[]{"PRE-125","PRE-125","PRE-125", "PRE-230", "PRE-210", "PRE-220"};
itemBaseID = 8000050;
}
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_item_bakedinstat` WHERE `itemID` = ?")) {
preparedStatement.setInt(1, itemBaseID);
preparedStatement.setInt(1, itemBase.getUUID());
ResultSet rs = preparedStatement.executeQuery();
while (rs.next()) {
@@ -144,19 +87,12 @@ public class dbItemBaseHandler extends dbHandlerBase {
recordsRead++;
itemBase = new ItemBase(rs);
ItemBase.addToCache(itemBase);
//copy the vampire shrine for saetor and change uuid and name
if(itemBase.getName().contains("Vampire Shrine")){
ItemBase saetorShrine = new ItemBase(rs);
saetorShrine.setUUID(1035);
saetorShrine.setName(saetorShrine.getName().replace("Vampire","Saetor"));
ItemBase.addToCache(saetorShrine);
}
}
} catch (SQLException e) {
Logger.error(e);
}
Logger.info("read: " + recordsRead + " cached: " + ItemBase.getUUIDCache().size());
}
+2 -24
View File
@@ -135,11 +135,7 @@ public class dbItemHandler extends dbHandlerBase {
ResultSet rs = preparedStatement.executeQuery();
if (rs.next())
try {
worked = rs.getBoolean("result");
}catch(Exception e){
return true;
}
worked = rs.getBoolean("result");
} catch (SQLException e) {
Logger.error(e);
@@ -354,11 +350,7 @@ public class dbItemHandler extends dbHandlerBase {
ResultSet rs = preparedStatement.executeQuery();
if (rs.next())
try {
worked = rs.getBoolean("result");
} catch(Exception e){
worked = true;
}
worked = rs.getBoolean("result");
} catch (SQLException e) {
Logger.error(e);
@@ -504,18 +496,4 @@ public class dbItemHandler extends dbHandlerBase {
return false;
}
}
public boolean UPDATE_NUM_ITEMS(final Item item, int newValue) {
if (item.getItemBase().getType().equals(ItemType.GOLD))
return false;
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_item` SET `item_numberOfItems`=? WHERE `UID`=?")) {
preparedStatement.setInt(1, newValue);
preparedStatement.setLong(2, item.getObjectUUID());
return (preparedStatement.executeUpdate() > 0);
} catch (SQLException e) {
Logger.error(e);
return false;
}
}
}
+4 -36
View File
@@ -9,14 +9,12 @@
package engine.db.handlers;
import engine.Enum;
import engine.gameManager.BuildingManager;
import engine.gameManager.DbManager;
import engine.objects.Mine;
import engine.objects.MineProduction;
import engine.objects.Resource;
import org.pmw.tinylog.Logger;
import java.net.UnknownHostException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
@@ -34,24 +32,8 @@ public class dbMineHandler extends dbHandlerBase {
if (id == 0)
return null;
Mine mine = (Mine) DbManager.getFromCache(Enum.GameObjectType.Mine, id);
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM obj_mine;")) {
//preparedStatement.setInt(1, id);
ResultSet rs = preparedStatement.executeQuery();
while(rs.next()){
if(rs.getInt("UID") == id){
int towerUID = rs.getInt("mine_buildingUID");
mine = Mine.getMineFromTower(towerUID);
}
}
} catch (SQLException e) {
Logger.error(e);
}
if (mine != null)
return mine;
@@ -74,27 +56,13 @@ public class dbMineHandler extends dbHandlerBase {
ArrayList<Mine> mines = new ArrayList<>();
//try (Connection connection = DbManager.getConnection();
// PreparedStatement preparedStatement = connection.prepareStatement("SELECT `obj_mine`.*, `object`.`parent` FROM `object` INNER JOIN `obj_mine` ON `obj_mine`.`UID` = `object`.`UID`")) {
// ResultSet rs = preparedStatement.executeQuery();
// mines = getObjectsFromRs(rs, 1000);
// } catch (SQLException e) {
// Logger.error(e);
//}
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM obj_mine;")) {
PreparedStatement preparedStatement = connection.prepareStatement("SELECT `obj_mine`.*, `object`.`parent` FROM `object` INNER JOIN `obj_mine` ON `obj_mine`.`UID` = `object`.`UID`")) {
ResultSet rs = preparedStatement.executeQuery();
while(rs.next()){
if(BuildingManager.getBuildingFromCache(rs.getInt("mine_buildingUID")) == null)
continue;
mines = getObjectsFromRs(rs, 1000);
mines.add(new Mine(rs));
}
} catch (SQLException | UnknownHostException e) {
} catch (SQLException e) {
Logger.error(e);
}
return mines;
@@ -21,7 +21,6 @@ import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
public class dbMobBaseHandler extends dbHandlerBase {
@@ -113,25 +112,6 @@ public class dbMobBaseHandler extends dbHandlerBase {
return mobBaseStats;
}
public void LOAD_ALL_MOBBASE_RACES() {
MobBase.mobbase_race_types = new HashMap<>();
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_npc_mobbase`;")) {
ResultSet rs = preparedStatement.executeQuery();
while (rs.next()) {
int id = rs.getInt("loadID");
if(MobBase.mobbase_race_types.containsKey(id) == false){
MobBase.mobbase_race_types.put(id,rs.getString("raceType"));
}
}
} catch (SQLException e) {
Logger.error(e);
}
}
public void LOAD_ALL_MOBBASE_SPEEDS(MobBase mobBase) {
if (mobBase.getLoadID() == 0)
+23 -11
View File
@@ -33,7 +33,7 @@ public class dbMobHandler extends dbHandlerBase {
Mob mobile = null;
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("CALL `mob_CREATE`(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);")) {
PreparedStatement preparedStatement = connection.prepareStatement("CALL `mob_CREATE`(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);")) {
preparedStatement.setLong(1, toAdd.parentZoneUUID);
preparedStatement.setInt(2, toAdd.loadID);
@@ -48,6 +48,7 @@ public class dbMobHandler extends dbHandlerBase {
preparedStatement.setInt(11, toAdd.buildingUUID);
preparedStatement.setInt(12, toAdd.level);
preparedStatement.setString(13, toAdd.firstName);
preparedStatement.setString(14, toAdd.behaviourType.toString());
ResultSet rs = preparedStatement.executeQuery();
@@ -110,7 +111,7 @@ public class dbMobHandler extends dbHandlerBase {
ResultSet rs = preparedStatement.executeQuery();
while (rs.next()) {
String minionName = rs.getString("name");
String minionName = rs.getString("minionName");
Mob toCreate = Mob.createGuardMinion(guardCaptain, guardCaptain.getLevel(), minionName);
if (toCreate == null)
@@ -126,15 +127,13 @@ public class dbMobHandler extends dbHandlerBase {
}
}
public boolean ADD_TO_GUARDS(final long captainUID, final int mobBaseID, final String name, final int slot) {
public boolean ADD_GUARD_MINION(final long captainUID, final String minionName) {
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO `dyn_guards` (`captainUID`, `mobBaseID`,`name`, `slot`) VALUES (?,?,?,?)")) {
PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO `dyn_guards` (`captainUID`, `minionName`) VALUES (?,?)")) {
preparedStatement.setLong(1, captainUID);
preparedStatement.setInt(2, mobBaseID);
preparedStatement.setString(3, name);
preparedStatement.setInt(4, slot);
preparedStatement.setString(2, minionName);
return (preparedStatement.executeUpdate() > 0);
@@ -144,14 +143,13 @@ public class dbMobHandler extends dbHandlerBase {
}
}
public boolean REMOVE_FROM_GUARDS(final long captainUID, final int mobBaseID, final int slot) {
public boolean REMOVE_GUARD_MINION(final long captainUID, final String minionName) {
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("DELETE FROM `dyn_guards` WHERE `captainUID`=? AND `mobBaseID`=? AND `slot` =?")) {
PreparedStatement preparedStatement = connection.prepareStatement("DELETE FROM `dyn_guards` WHERE `captainUID`=? AND `minionName`=? LIMIT 1;")) {
preparedStatement.setLong(1, captainUID);
preparedStatement.setInt(2, mobBaseID);
preparedStatement.setInt(3, slot);
preparedStatement.setString(2, minionName);
return (preparedStatement.executeUpdate() > 0);
@@ -161,6 +159,20 @@ public class dbMobHandler extends dbHandlerBase {
}
}
public boolean REMOVE_ALL_MINIONS(final long captainUID) {
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("DELETE FROM `dyn_guards` WHERE `captainUID`=?;")) {
preparedStatement.setLong(1, captainUID);
return (preparedStatement.executeUpdate() > 0);
} catch (SQLException e) {
Logger.error(e);
return false;
}
}
public ArrayList<Mob> GET_ALL_MOBS_FOR_ZONE(Zone zone) {
@@ -15,15 +15,9 @@ import engine.gameManager.PowersManager;
import engine.objects.Mob;
import engine.objects.PreparedStatementShared;
import engine.powers.EffectsBase;
import engine.powers.MobPowerEntry;
import org.pmw.tinylog.Logger;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
public class dbPowerHandler extends dbHandlerBase {
@@ -86,43 +80,4 @@ public class dbPowerHandler extends dbHandlerBase {
}
}
public static HashMap<Integer, ArrayList<MobPowerEntry>> LOAD_MOB_POWERS() {
HashMap<Integer, ArrayList<MobPowerEntry>> mobPowers = new HashMap<>();
MobPowerEntry mobPowerEntry;
int mobbaseID;
int recordsRead = 0;
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM static_npc_mobbase_powers ORDER BY `id` ASC;")) {
ResultSet rs = preparedStatement.executeQuery();
while (rs.next()) {
recordsRead++;
mobbaseID = rs.getInt("mobbaseUUID");
mobPowerEntry = new MobPowerEntry(rs);
if (mobPowers.get(mobbaseID) == null) {
ArrayList<MobPowerEntry> powerList = new ArrayList<>();
powerList.add(mobPowerEntry);
mobPowers.put(mobbaseID, powerList);
} else {
ArrayList<MobPowerEntry> powerList = mobPowers.get(mobbaseID);
powerList.add(mobPowerEntry);
mobPowers.put(mobbaseID, powerList);
}
}
} catch (SQLException e) {
Logger.error(e);
return mobPowers;
}
Logger.info("read: " + recordsRead + " cached: " + mobPowers.size());
return mobPowers;
}
}
@@ -23,25 +23,7 @@ public class dbResistHandler extends dbHandlerBase {
public dbResistHandler() {
}
public void LOAD_RESISTS_FOR_MOBS() {
Resists resists = null;
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_npc_mob_resists`;")) {
ResultSet rs = preparedStatement.executeQuery();
while(rs.next()){
resists = new Resists(rs);
if(!Resists.mobResists.containsKey(rs.getInt("ID")))
Resists.mobResists.put(rs.getInt("ID"),resists);
}
} catch (SQLException e) {
Logger.error(e);
}
}
public Resists GET_RESISTS_FOR_MOB(int resistID) {
Resists resists = null;
+80 -37
View File
@@ -11,6 +11,8 @@ package engine.db.handlers;
import engine.gameManager.DbManager;
import engine.objects.RuneBase;
import engine.powers.RunePowerEntry;
import engine.powers.RuneSkillAdjustEntry;
import org.pmw.tinylog.Logger;
import java.sql.Connection;
@@ -27,6 +29,84 @@ public class dbRuneBaseHandler extends dbHandlerBase {
this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public static HashMap<Integer, ArrayList<RunePowerEntry>> LOAD_RUNE_POWERS() {
HashMap<Integer, ArrayList<RunePowerEntry>> mobPowers = new HashMap<>();
RunePowerEntry runePowerEntry;
int rune_id;
int recordsRead = 0;
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM static_rune_powers")) {
ResultSet rs = preparedStatement.executeQuery();
while (rs.next()) {
recordsRead++;
rune_id = rs.getInt("rune_id");
runePowerEntry = new RunePowerEntry(rs);
if (mobPowers.get(rune_id) == null) {
ArrayList<RunePowerEntry> runePowerList = new ArrayList<>();
runePowerList.add(runePowerEntry);
mobPowers.put(rune_id, runePowerList);
} else {
ArrayList<RunePowerEntry> powerList = mobPowers.get(rune_id);
powerList.add(runePowerEntry);
mobPowers.put(rune_id, powerList);
}
}
} catch (SQLException e) {
Logger.error(e);
return mobPowers;
}
Logger.info("read: " + recordsRead + " cached: " + mobPowers.size());
return mobPowers;
}
public static HashMap<Integer, ArrayList<RuneSkillAdjustEntry>> LOAD_RUNE_SKILL_ADJUSTS() {
HashMap<Integer, ArrayList<RuneSkillAdjustEntry>> runeSkillAdjusts = new HashMap<>();
RuneSkillAdjustEntry runeSkillAdjustEntry;
int rune_id;
int recordsRead = 0;
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM static_rune_skill_adjusts")) {
ResultSet rs = preparedStatement.executeQuery();
while (rs.next()) {
recordsRead++;
rune_id = rs.getInt("rune_id");
runeSkillAdjustEntry = new RuneSkillAdjustEntry(rs);
if (runeSkillAdjusts.get(rune_id) == null) {
ArrayList<RuneSkillAdjustEntry> skillAdjustList = new ArrayList<>();
skillAdjustList.add(runeSkillAdjustEntry);
runeSkillAdjusts.put(rune_id, skillAdjustList);
} else {
ArrayList<RuneSkillAdjustEntry> powerList = runeSkillAdjusts.get(rune_id);
powerList.add(runeSkillAdjustEntry);
runeSkillAdjusts.put(rune_id, powerList);
}
}
} catch (SQLException e) {
Logger.error(e);
return runeSkillAdjusts;
}
Logger.info("read: " + recordsRead + " cached: " + runeSkillAdjusts.size());
return runeSkillAdjusts;
}
public void GET_RUNE_REQS(final RuneBase rb) {
try (Connection connection = DbManager.getConnection();
@@ -59,43 +139,6 @@ public class dbRuneBaseHandler extends dbHandlerBase {
rb.setLevelRequired(rs.getInt("requiredRuneID"));
break;
}
int id = rs.getInt("runeID");
switch(id) {
case 3001:
case 3002:
case 3003:
case 3004:
case 3007:
case 3008:
case 3009:
case 3013:
case 3014:
case 3016:
case 3017:
case 3018:
case 3019:
case 3020:
case 3021:
case 3026:
case 3030:
case 3031:
case 3033:
case 3037:
case 3040:
case 3045:
case 3046:
case 3047:
case 3048:
case 2514:
rb.getRace().put(1999, true);
break;
case 3035:
rb.getBaseClass().put(2501,true);
break;
case 3049:
rb.getRace().clear();
}
}
} catch (SQLException e) {
@@ -143,13 +143,6 @@ public class dbSkillBaseHandler extends dbHandlerBase {
SkillsBase.runeSkillsCache.get(runeID).put(token, amount);
}
//add saetor skills
HashMap<Integer, Integer> skills = new HashMap<>();
skills.put(71438003,15); // staff
skills.put(-61022283,10); // staff mastery
skills.put(95961104,10); // parry
SkillsBase.runeSkillsCache.put(1999,skills);
} catch (SQLException e) {
Logger.error(e);
+3 -2
View File
@@ -9,6 +9,7 @@
package engine.devcmd.cmds;
import engine.Enum;
import engine.Enum.GameObjectType;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.ChatManager;
@@ -43,7 +44,7 @@ public class AddMobCmd extends AbstractDevCmd {
MobBase mb = (MobBase) mobbaseAGO;
int loadID = mb.getObjectUUID();
Mob mob = Mob.createMob(loadID, Vector3fImmutable.getRandomPointInCircle(pc.getLoc(), 100),
null, zone, null, null, "", 1);
null, zone, null, null, "", 1, Enum.AIAgentType.MOBILE);
if (mob != null) {
mob.updateDatabase();
this.setResult(String.valueOf(mob.getDBID()));
@@ -84,7 +85,7 @@ public class AddMobCmd extends AbstractDevCmd {
Mob mob = Mob.createMob(loadID, pc.getLoc(),
null, zone, null, null, "", 1);
null, zone, null, null, "", 1, Enum.AIAgentType.MOBILE);
if (mob != null) {
mob.updateDatabase();
ChatManager.chatSayInfo(pc,
+18 -21
View File
@@ -13,7 +13,6 @@ import engine.Enum.GameObjectType;
import engine.InterestManagement.WorldGrid;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.*;
import engine.math.Vector3fImmutable;
import engine.objects.*;
import org.pmw.tinylog.Logger;
@@ -71,30 +70,28 @@ public class AddNPCCmd extends AbstractDevCmd {
throwbackError(pc, "Failed to find zone to place npc in.");
return;
}
Building building = null;
if (target != null)
if (target.getObjectType() == GameObjectType.Building) {
building = (Building)target;
Building parentBuilding = (Building) target;
BuildingManager.addHirelingForWorld(parentBuilding, pc, parentBuilding.getLoc(), parentBuilding.getParentZone(), contract, level);
return;
}
NPC created;
Guild guild = null;
Vector3fImmutable loc;
if(building != null){
guild = building.getGuild();
loc = building.loc;
} else{
loc = pc.loc;
NPC npc = NPC.createNPC(name, contractID,
pc.getLoc(), null, zone, (short) level, null);
if (npc != null) {
WorldGrid.addObject(npc, pc);
ChatManager.chatSayInfo(pc,
"NPC with ID " + npc.getDBID() + " added");
this.setResult(String.valueOf(npc.getDBID()));
} else {
throwbackError(pc, "Failed to create npc of contract type "
+ contractID);
Logger.error(
"Failed to create npc of contract type " + contractID);
}
created = NPC.createNPC(name, contractID, loc, guild, zone, (short)level, building);
created.bindLoc = loc;
if(building != null) {
created.buildingUUID = building.getObjectUUID();
created.building = building;
NPCManager.slotCharacterInBuilding(created);
}
created.setLoc(created.bindLoc);
created.updateDatabase();
throwbackInfo(pc, "Created NPC with UUID: " + created.getObjectUUID());
}
@Override
@@ -1,70 +0,0 @@
// ·. · · · · .
// · ·
// · ·
//
// · · ·
// Magicbane Emulator Project © 2013 - 2022
// www.magicbane.com
package engine.devcmd.cmds;
import engine.InterestManagement.HeightMap;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.ZoneManager;
import engine.math.Vector2f;
import engine.math.Vector3fImmutable;
import engine.objects.AbstractGameObject;
import engine.objects.PlayerCharacter;
import engine.objects.Zone;
public class AuditHeightMapCmd extends AbstractDevCmd {
public AuditHeightMapCmd() {
super("auditheightmap");
}
@Override
protected void _doCmd(PlayerCharacter pcSender, String[] words,
AbstractGameObject target) {
int count = Integer.parseInt(words[0]);
long start = System.currentTimeMillis();
for (int i = 0; i < count; i++) {
Zone currentZone = ZoneManager.findSmallestZone(pcSender.getLoc());
Vector3fImmutable currentLoc = Vector3fImmutable.getRandomPointInCircle(currentZone.getLoc(), currentZone.getBounds().getHalfExtents().x < currentZone.getBounds().getHalfExtents().y ? currentZone.getBounds().getHalfExtents().x : currentZone.getBounds().getHalfExtents().y);
Vector2f zoneLoc = ZoneManager.worldToZoneSpace(currentLoc, currentZone);
if (currentZone != null && currentZone.getHeightMap() != null) {
float altitude = currentZone.getHeightMap().getInterpolatedTerrainHeight(zoneLoc);
float outsetAltitude = HeightMap.getOutsetHeight(altitude, currentZone, pcSender.getLoc());
}
}
long end = System.currentTimeMillis();
long delta = end - start;
this.throwbackInfo(pcSender, "Audit Heightmap took " + delta + " ms to run " + count + " times!");
}
@Override
protected String _getUsageString() {
return "' /auditmobs [zone.UUID]'";
}
@Override
protected String _getHelpString() {
return "Audits all the mobs in a zone.";
}
}
+15 -4
View File
@@ -11,7 +11,6 @@ package engine.devcmd.cmds;
import engine.devcmd.AbstractDevCmd;
import engine.objects.*;
import engine.powers.EffectsBase;
public class EnchantCmd extends AbstractDevCmd {
@@ -56,9 +55,21 @@ public class EnchantCmd extends AbstractDevCmd {
this.setResult(String.valueOf(item.getObjectUUID()));
} else {
int cnt = words.length;
String enchant = words[1];
enchant = EffectsBase.getItemEffectsByName(enchant.toLowerCase());
item.addPermanentEnchantmentForDev(enchant, 0);
for (int i = 1; i < cnt; i++) {
String enchant = words[i];
boolean valid = true;
for (Effect eff : item.getEffects().values()) {
if (eff.getEffectsBase().getIDString().equals(enchant)) {
throwbackError(pc, "This item already has that enchantment");
return;
}
}
if (valid) {
item.addPermanentEnchantmentForDev(enchant, rank);
this.setResult(String.valueOf(item.getObjectUUID()));
} else
throwbackError(pc, "Invalid Enchantment. Enchantment must consist of SUF-001 to SUF-328 or PRE-001 to PRE-334. Sent " + enchant + '.');
}
cim.updateInventory();
}
}
+1 -1
View File
@@ -30,7 +30,7 @@ public class FlashMsgCmd extends AbstractDevCmd {
this.sendUsage(pcSender);
return;
}
ChatManager.chatSystemFlash(String.join(" ", args));
ChatManager.chatSystemFlash(args[0]);
}
/**
+32 -180
View File
@@ -13,7 +13,6 @@ import engine.InterestManagement.HeightMap;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.ZoneManager;
import engine.math.Vector2f;
import engine.math.Vector3fImmutable;
import engine.objects.AbstractGameObject;
import engine.objects.PlayerCharacter;
import engine.objects.Zone;
@@ -22,205 +21,58 @@ public class GetHeightCmd extends AbstractDevCmd {
public GetHeightCmd() {
super("getHeight");
this.addCmdString("height");
}
@Override
protected void _doCmd(PlayerCharacter pc, String[] words,
protected void _doCmd(PlayerCharacter playerCharacter, String[] words,
AbstractGameObject target) {
boolean end = true;
Zone currentZone;
Zone parentZone;
Zone heightmapZone;
float height = HeightMap.getWorldHeight(pc);
currentZone = ZoneManager.findSmallestZone(playerCharacter.getLoc());
heightmapZone = HeightMap.getNextZoneWithTerrain(currentZone);
parentZone = HeightMap.getNextZoneWithTerrain(currentZone.getParent());
this.throwbackInfo(pc, "Altitude : " + height);
float currentHeight = HeightMap.getWorldHeight(currentZone, playerCharacter.getLoc());
float parentHeight = HeightMap.getWorldHeight(parentZone, playerCharacter.getLoc());
this.throwbackInfo(pc, "Character Height: " + pc.getCharacterHeight());
this.throwbackInfo(pc, "Character Height to start swimming: " + pc.centerHeight);
Vector2f zoneLoc = ZoneManager.worldToZoneSpace(playerCharacter.getLoc(), heightmapZone);
Vector2f gridSquare = heightmapZone.getHeightMap().getGridSquare(zoneLoc);
Zone zone = ZoneManager.findSmallestZone(pc.getLoc());
this.throwbackInfo(pc, "Water Level : " + zone.getSeaLevel());
this.throwbackInfo(pc, "Character Water Level Above : " + (pc.getCharacterHeight() + height - zone.getSeaLevel()));
this.throwbackInfo(playerCharacter, "Current Zone : " + currentZone.getName());
this.throwbackInfo(playerCharacter, "Heightmap Zone : " + heightmapZone.getName());
this.throwbackInfo(playerCharacter, "Zone Height: " + heightmapZone.worldAltitude);
this.throwbackInfo(playerCharacter, "Sea Level: " + heightmapZone.getSeaLevel());
this.throwbackInfo(playerCharacter, "Grid : " + (int) gridSquare.x + "x" + (int) gridSquare.y);
this.throwbackInfo(playerCharacter, "*** 256: " + currentHeight);
this.throwbackInfo(playerCharacter, "***Adjusted Height: " + (currentHeight + playerCharacter.getCharacterHeight()));
if (end)
return;
Vector2f gridSquare;
Vector2f gridOffset;
Vector2f parentGrid;
Vector2f parentLoc = new Vector2f(-1, -1);
Zone currentZone = ZoneManager.findSmallestZone(pc.getLoc());
if (currentZone == null)
return;
Zone parentZone = currentZone.getParent();
HeightMap heightMap = currentZone.getHeightMap();
//find the next parents heightmap if the currentzone heightmap is null.
while (heightMap == null) {
if (currentZone == ZoneManager.getSeaFloor()) {
this.throwbackInfo(pc, "Could not find a heightmap to get height.");
break;
}
this.throwbackError(pc, "Heightmap does not exist for " + currentZone.getName());
this.throwbackInfo(pc, "Using parent zone instead: ");
currentZone = currentZone.getParent();
heightMap = currentZone.getHeightMap();
}
if ((heightMap == null) || (currentZone == ZoneManager.getSeaFloor())) {
this.throwbackInfo(pc, currentZone.getName() + " has no heightmap ");
this.throwbackInfo(pc, "Current altitude: " + currentZone.absY);
return;
}
Vector2f zoneLoc = ZoneManager.worldToZoneSpace(pc.getLoc(), currentZone);
Vector3fImmutable seaFloorLocalLoc = ZoneManager.worldToLocal(pc.getLoc(), ZoneManager.getSeaFloor());
this.throwbackInfo(pc, "SeaFloor Local : " + seaFloorLocalLoc.x + " , " + seaFloorLocalLoc.y);
this.throwbackInfo(pc, "Local Zone Location : " + zoneLoc.x + " , " + zoneLoc.y);
Vector3fImmutable localLocFromCenter = ZoneManager.worldToLocal(pc.getLoc(), currentZone);
Vector3fImmutable parentLocFromCenter = ZoneManager.worldToLocal(pc.getLoc(), currentZone.getParent());
this.throwbackInfo(pc, "Local Zone Location from center : " + localLocFromCenter);
this.throwbackInfo(pc, "parent Zone Location from center : " + parentLocFromCenter);
Vector2f parentZoneLoc = ZoneManager.worldToZoneSpace(pc.getLoc(), currentZone.getParent());
this.throwbackInfo(pc, "Parent Zone Location from Bottom Left : " + parentZoneLoc);
if ((parentZone != null) && (parentZone.getHeightMap() != null)) {
parentLoc = ZoneManager.worldToZoneSpace(pc.getLoc(), parentZone);
parentGrid = parentZone.getHeightMap().getGridSquare(parentLoc);
} else
parentGrid = new Vector2f(-1, -1);
gridSquare = heightMap.getGridSquare(zoneLoc);
gridOffset = HeightMap.getGridOffset(gridSquare);
float interaltitude = currentZone.getHeightMap().getInterpolatedTerrainHeight(zoneLoc);
this.throwbackInfo(pc, currentZone.getName());
this.throwbackInfo(pc, "Current Grid Square: " + gridSquare.x + " , " + gridSquare.y);
this.throwbackInfo(pc, "Grid Offset: " + gridOffset.x + " , " + gridOffset.y);
this.throwbackInfo(pc, "Parent Grid: " + parentGrid.x + " , " + parentGrid.y);
if (parentGrid.x != -1) {
float parentAltitude = parentZone.getHeightMap().getInterpolatedTerrainHeight(parentLoc);
this.throwbackInfo(pc, "Parent ALTITUDE: " + (parentAltitude));
this.throwbackInfo(pc, "Parent Interpolation: " + (parentAltitude + parentZone.getWorldAltitude()));
}
this.throwbackInfo(pc, "interpolated height: " + interaltitude);
this.throwbackInfo(pc, "interpolated height with World: " + (interaltitude + currentZone.getWorldAltitude()));
float realWorldAltitude = interaltitude + currentZone.getWorldAltitude();
//OUTSET
if (parentZone != null) {
float parentXRadius = currentZone.getBounds().getHalfExtents().x;
float parentZRadius = currentZone.getBounds().getHalfExtents().y;
float offsetX = Math.abs((localLocFromCenter.x / parentXRadius));
float offsetZ = Math.abs((localLocFromCenter.z / parentZRadius));
float bucketScaleX = 100 / parentXRadius;
float bucketScaleZ = 200 / parentZRadius;
float outsideGridSizeX = 1 - bucketScaleX; //32/256
float outsideGridSizeZ = 1 - bucketScaleZ;
float weight;
double scale;
if (offsetX > outsideGridSizeX && offsetX > offsetZ) {
weight = (offsetX - outsideGridSizeX) / bucketScaleX;
scale = Math.atan2((.5 - weight) * 3.1415927, 1);
float scaleChild = (float) ((scale + 1) * .5);
float scaleParent = 1 - scaleChild;
float parentAltitude = parentZone.getHeightMap().getInterpolatedTerrainHeight(parentLoc);
float parentCenterAltitude = parentZone.getHeightMap().getInterpolatedTerrainHeight(ZoneManager.worldToZoneSpace(currentZone.getLoc(), parentZone));
parentCenterAltitude += currentZone.getYCoord();
parentCenterAltitude += interaltitude;
float firstScale = parentAltitude * scaleParent;
float secondScale = parentCenterAltitude * scaleChild;
float outsetALt = firstScale + secondScale;
outsetALt += currentZone.getParent().getAbsY();
realWorldAltitude = outsetALt;
} else if (offsetZ > outsideGridSizeZ) {
weight = (offsetZ - outsideGridSizeZ) / bucketScaleZ;
scale = Math.atan2((.5 - weight) * 3.1415927, 1);
float scaleChild = (float) ((scale + 1) * .5);
float scaleParent = 1 - scaleChild;
float parentAltitude = parentZone.getHeightMap().getInterpolatedTerrainHeight(parentLoc);
float parentCenterAltitude = parentZone.getHeightMap().getInterpolatedTerrainHeight(ZoneManager.worldToZoneSpace(currentZone.getLoc(), parentZone));
parentCenterAltitude += currentZone.getYCoord();
parentCenterAltitude += interaltitude;
float firstScale = parentAltitude * scaleParent;
float secondScale = parentCenterAltitude * scaleChild;
float outsetALt = firstScale + secondScale;
outsetALt += currentZone.getParent().getAbsY();
realWorldAltitude = outsetALt;
}
}
float strMod = pc.statStrBase - 40;
strMod *= .00999999998f;
strMod += 1f;
float radius = 0;
switch (pc.getRaceID()) {
case 2017:
radius = 3.1415927f;
case 2000:
}
strMod *= 1.5707964f;
strMod += 3.1415927f;
strMod -= .5f;
realWorldAltitude += strMod;
this.throwbackInfo(pc, "interpolated height with World: " + realWorldAltitude);
HeightMap.SCALEVALUE = 1f / 255f;
currentHeight = HeightMap.getWorldHeight(currentZone, playerCharacter.getLoc());
HeightMap.SCALEVALUE = 1f / 256f;
this.throwbackInfo(playerCharacter, "***255 Adjusted: " + (currentHeight + playerCharacter.getCharacterHeight()));
this.throwbackInfo(playerCharacter, "Drowning Height: " + (heightmapZone.getSeaLevel() + playerCharacter.getCharacterHeight()));
this.throwbackInfo(playerCharacter, "------------");
this.throwbackInfo(playerCharacter, "Parent : " + parentZone.getName());
this.throwbackInfo(playerCharacter, "Height returned : " + parentHeight);
this.throwbackInfo(playerCharacter, "[" + (gridSquare.x) + "][" + (gridSquare.y) + "]");
this.throwbackInfo(playerCharacter, "[" + (gridSquare.x + 1) + "][" + (gridSquare.y) + "]");
this.throwbackInfo(playerCharacter, "[" + (gridSquare.x) + "][" + (gridSquare.y + 1) + "]");
this.throwbackInfo(playerCharacter, "[" + (gridSquare.x + 1) + "][" + (gridSquare.y + 1) + "]");
}
@Override
protected String _getHelpString() {
return "Temporarily Changes SubRace";
return "Queries heightmap engine";
}
@Override
protected String _getUsageString() {
return "' /subrace mobBaseID";
return "' /getheight";
}
}
+4 -5
View File
@@ -280,7 +280,7 @@ public class InfoCmd extends AbstractDevCmd {
output += newline;
output += "Inventory Weight:" + (targetPC.getCharItemManager().getInventoryWeight() + targetPC.getCharItemManager().getEquipWeight());
output += newline;
output += "Max Inventory Weight:" + targetPC.getInventoryCapacity();
output += "Max Inventory Weight:" + ((int) targetPC.statStrBase * 3);
output += newline;
output += "ALTITUDE :" + targetPC.getAltitude();
output += newline;
@@ -336,9 +336,8 @@ public class InfoCmd extends AbstractDevCmd {
output += "Swimming : " + targetPC.isSwimming();
output += newline;
output += "isMoving : " + targetPC.isMoving() + newline;
output += "Zerg Multiplier: " + targetPC.ZergMultiplier + newline;
output += "isBoxed: " + targetPC.isBoxed + newline;
output += "isMoving : " + targetPC.isMoving();
break;
case NPC:
@@ -526,7 +525,7 @@ public class InfoCmd extends AbstractDevCmd {
ConcurrentHashMap<String, Effect> effects = item.getEffects();
for (String name : effects.keySet()) {
Effect eff = effects.get(name);
output += eff.getEffectsBase().getIDString() + " Static:" + eff.isStatic();
output += eff.getEffectsBase().getIDString();
output += newline;
// output += eff.getEffectToken() + (eff.bakedInStat() ? " (baked in)" : "") + newline;
}
-8
View File
@@ -65,10 +65,6 @@ public class MakeItemCmd extends AbstractDevCmd {
if (item == null || !worked) {
throwbackError(pc, "DB error 2: Unable to create item.");
if(item == null)
throwbackError(pc, "Item Null");
else
throwbackError(pc, "Worked = false");
return;
}
@@ -226,10 +222,6 @@ public class MakeItemCmd extends AbstractDevCmd {
if (item == null || !worked) {
throwbackError(pc, "DB error 2: Unable to create item.");
if(item == null)
throwbackError(pc, "Item Null");
else
throwbackError(pc, "Worked = false");
return;
}
+3 -2
View File
@@ -16,6 +16,7 @@ import engine.objects.AbstractGameObject;
import engine.objects.Building;
import engine.objects.Mine;
import engine.objects.PlayerCharacter;
import engine.workthreads.HourlyJobThread;
/**
*
@@ -40,10 +41,10 @@ public class MineActiveCmd extends AbstractDevCmd {
String trigger = args[0];
switch (trigger) {
case "true":
Mine.mineWindowOpen(mine);
HourlyJobThread.mineWindowOpen(mine);
break;
case "false":
Mine.mineWindowClose(mine);
HourlyJobThread.mineWindowClose(mine);
break;
default:
this.sendUsage(pcSender);
@@ -0,0 +1,67 @@
// ·. · · · · .
// · ·
// · ·
//
// · · ·
// Magicbane Emulator Project © 2013 - 2022
// www.magicbane.com
package engine.devcmd.cmds;
import engine.devcmd.AbstractDevCmd;
import engine.objects.*;
import java.util.HashMap;
/**
*
*/
public class PrintEffectsCmd extends AbstractDevCmd {
public PrintEffectsCmd() {
super("printeffects");
// super("printstats", MBServerStatics.ACCESS_LEVEL_ADMIN);
}
public static ItemBase getWeaponBase(int slot, HashMap<Integer, MobEquipment> equip) {
if (equip.containsKey(slot)) {
MobEquipment item = equip.get(slot);
if (item != null && item.getItemBase() != null) {
return item.getItemBase();
}
}
return null;
}
@Override
protected void _doCmd(PlayerCharacter pc, String[] words,
AbstractGameObject target) {
AbstractCharacter tar;
if (target != null && target instanceof AbstractCharacter) {
tar = (AbstractCharacter) target;
String newline = "\r\n ";
String output = "Effects For Character: " + tar.getName() + newline;
for(String effect : tar.effects.keySet()){
output += effect + newline;
}
throwbackInfo(pc, output);
}
}
@Override
protected String _getHelpString() {
return "Returns the player's current stats";
}
@Override
protected String _getUsageString() {
return "' /printstats'";
}
}
@@ -39,9 +39,6 @@ public class PrintResistsCmd extends AbstractDevCmd {
if (mb != null)
name = mb.getFirstName();
type = "Mob";
throwbackInfo(pc, "Server resists for " + type + ' ' + name);
tar.getResists().printResistsToClient(pc);
return;
} else if (tar instanceof NPC) {
NPC npc = (NPC) tar;
Contract contract = npc.getContract();
+67
View File
@@ -0,0 +1,67 @@
// ·. · · · · .
// · ·
// · ·
//
// · · ·
// Magicbane Emulator Project © 2013 - 2022
// www.magicbane.com
package engine.devcmd.cmds;
import engine.devcmd.AbstractDevCmd;
import engine.objects.*;
import java.util.HashMap;
/**
*
*/
public class PrintRunesCmd extends AbstractDevCmd {
public PrintRunesCmd() {
super("printrunes");
// super("printstats", MBServerStatics.ACCESS_LEVEL_ADMIN);
}
public static ItemBase getWeaponBase(int slot, HashMap<Integer, MobEquipment> equip) {
if (equip.containsKey(slot)) {
MobEquipment item = equip.get(slot);
if (item != null && item.getItemBase() != null) {
return item.getItemBase();
}
}
return null;
}
@Override
protected void _doCmd(PlayerCharacter pc, String[] words,
AbstractGameObject target) {
AbstractCharacter tar;
if (target != null && target instanceof AbstractCharacter) {
tar = (AbstractCharacter) target;
String newline = "\r\n ";
String output = "Applied Runes For Character: " + ((AbstractCharacter) target).getName() + newline;
for(CharacterRune rune : ((AbstractCharacter)target).runes){
output += rune.getRuneBaseID() + " " + rune.getRuneBase().getName() + newline;
}
throwbackInfo(pc, output);
}
}
@Override
protected String _getHelpString() {
return "Returns the player's current stats";
}
@Override
protected String _getUsageString() {
return "' /printstats'";
}
}
+13 -16
View File
@@ -9,7 +9,6 @@
package engine.devcmd.cmds;
import engine.Enum;
import engine.devcmd.AbstractDevCmd;
import engine.objects.*;
@@ -56,7 +55,6 @@ public class PrintStatsCmd extends AbstractDevCmd {
}
public void printStatsPlayer(PlayerCharacter pc, PlayerCharacter tar) {
tar.calculateMaxHealthManaStamina();
String newline = "\r\n ";
String out = "Server stats for Player " + tar.getFirstName() + newline;
out += "Unused Stats: " + tar.getUnusedStatPoints() + newline;
@@ -74,11 +72,6 @@ public class PrintStatsCmd extends AbstractDevCmd {
out += "Main Hand: atr: " + tar.getAtrHandOne() + ", damage: " + tar.getMinDamageHandOne() + " to " + tar.getMaxDamageHandOne() + ", speed: " + tar.getSpeedHandOne() + newline;
out += "Off Hand: atr: " + tar.getAtrHandTwo() + ", damage: " + tar.getMinDamageHandTwo() + " to " + tar.getMaxDamageHandTwo() + ", speed: " + tar.getSpeedHandTwo() + newline;
out += "isAlive: " + tar.isAlive() + ", Combat: " + tar.isCombat() + newline;
out += "Health Regen: " + tar.getRegenModifier(Enum.ModType.HealthRecoverRate) + newline;
out += "Stamina Regen: " + tar.getRegenModifier(Enum.ModType.StaminaRecoverRate) + newline;
out += "Mana Regen: " + tar.getRegenModifier(Enum.ModType.ManaRecoverRate) + newline;
out += "Zerg Multiplier: " + tar.ZergMultiplier + newline;
throwbackInfo(pc, out);
}
@@ -110,15 +103,19 @@ public class PrintStatsCmd extends AbstractDevCmd {
main = getWeaponBase(1, equip);
ItemBase off = null;
if (equip != null)
getWeaponBase(2, equip);
if (main == null && off == null) {
out += "Main Hand: atr: " + tar.getAtrHandOne() + ", damage: " + tar.getMinDamageHandOne() + " to " + tar.getMaxDamageHandOne() + ", speed: " + tar.getSpeedHandOne() + ", range: 6" + newline;
} else {
if (main != null)
out += "Main Hand: atr: " + tar.getAtrHandOne() + ", damage: " + tar.getMinDamageHandOne() + " to " + tar.getMaxDamageHandOne() + ", speed: " + tar.getSpeedHandOne() + ", range: " + main.getRange() + newline;
if (off != null)
out += "Main Hand: atr: " + tar.getAtrHandTwo() + ", damage: " + tar.getMinDamageHandTwo() + " to " + tar.getMaxDamageHandTwo() + ", speed: " + tar.getSpeedHandTwo() + ", range: " + off.getRange() + newline;
if(equip != null){
if(equip.get(2) != null && !equip.get(2).getItemBase().isShield()){
//off hand weapon
out += "Attack Rating: " + tar.atrHandTwo + newline;
out += "Damage: " + tar.minDamageHandTwo + " - " + tar.maxDamageHandTwo + newline;
out += "Range: " + tar.rangeHandTwo + newline;
out += "Attack Speed: " + tar.speedHandTwo + newline;
} else{
out += "Attack Rating: " + tar.atrHandOne + newline;
out += "Damage: " + tar.minDamageHandOne + " - " + tar.maxDamageHandOne + newline;
out += "Range: " + tar.rangeHandOne + newline;
out += "Attack Speed: " + tar.speedHandOne + newline;
}
}
out += "isAlive: " + tar.isAlive() + ", Combat: " + tar.isCombat() + newline;
+13 -8
View File
@@ -59,22 +59,25 @@ public class PurgeObjectsCmd extends AbstractDevCmd {
if (npc != null) {
for (Mob mob : npc.siegeMinionMap.keySet()) {
for (Integer minionUUID : npc.minions) {
Mob mob = Mob.getMob(minionUUID);
WorldGrid.RemoveWorldObject(mob);
WorldGrid.removeObject(mob, pc);
//Mob.getRespawnMap().remove(mob);
if (mob.getParentZone() != null)
mob.getParentZone().zoneMobSet.remove(mob);
}
DbManager.NPCQueries.DELETE_NPC(npc);
DbManager.removeFromCache(GameObjectType.NPC,
npc.getObjectUUID());
WorldGrid.RemoveWorldObject(npc);
} else if (mobA != null) {
for (Mob mob : mobA.getSiegeMinionMap().keySet()) {
for (Integer minionUUID : mobA.minions) {
Mob mob = Mob.getMob(minionUUID);
WorldGrid.RemoveWorldObject(mob);
WorldGrid.removeObject(mob, pc);
//Mob.getRespawnMap().remove(mob);
if (mob.getParentZone() != null)
mob.getParentZone().zoneMobSet.remove(mob);
}
@@ -151,10 +154,11 @@ public class PurgeObjectsCmd extends AbstractDevCmd {
if (npc != null) {
for (Mob mob : npc.siegeMinionMap.keySet()) {
for (Integer minionUUID : npc.minions) {
Mob mob = Mob.getMob(minionUUID);
WorldGrid.RemoveWorldObject(mob);
WorldGrid.removeObject(mob, pc);
//Mob.getRespawnMap().remove(mob);
if (mob.getParentZone() != null)
mob.getParentZone().zoneMobSet.remove(mob);
}
@@ -163,10 +167,11 @@ public class PurgeObjectsCmd extends AbstractDevCmd {
npc.getObjectUUID());
WorldGrid.RemoveWorldObject(npc);
} else if (mobA != null) {
for (Mob mob : mobA.getSiegeMinionMap().keySet()) {
for (Integer minionUUID : mobA.minions) {
Mob mob = Mob.getMob(minionUUID);
WorldGrid.RemoveWorldObject(mob);
WorldGrid.removeObject(mob, pc);
//Mob.getRespawnMap().remove(mob);
if (mob.getParentZone() != null)
mob.getParentZone().zoneMobSet.remove(mob);
}
+8 -33
View File
@@ -9,9 +9,9 @@
package engine.devcmd.cmds;
import engine.Enum;
import engine.devcmd.AbstractDevCmd;
import engine.objects.AbstractGameObject;
import engine.objects.PlayerCharacter;
import engine.objects.*;
import java.lang.reflect.Field;
@@ -25,42 +25,17 @@ public class RegionCmd extends AbstractDevCmd {
protected void _doCmd(PlayerCharacter pc, String[] words,
AbstractGameObject target) {
if (pc.region == null) {
Regions region = ((AbstractCharacter)target).region;
if (region == null) {
this.throwbackInfo(pc, "No Region Found.");
return;
}
String newLine = System.getProperty("line.separator");
String result = "";
result += (pc.region.getClass().getSimpleName());
result += (" {");
result += (newLine);
Field[] fields = pc.region.getClass().getDeclaredFields();
//print field names paired with their values
for (Field field : fields) {
field.setAccessible(true);
result += (" ");
try {
if (field.getName().contains("Furniture"))
continue;
result += (field.getName());
result += (": ");
//requires access to private field:
result += (field.get(pc.region).toString());
} catch (IllegalAccessException ex) {
System.out.println(ex);
}
result.trim();
result += (newLine);
if(region != null) {
this.throwbackInfo(pc, "Region Info: " + ((AbstractCharacter) target).getName());
this.throwbackInfo(pc, "Region Name: " + region);
this.throwbackInfo(pc, "Region Height: " + region.lerpY((AbstractCharacter)target));
}
result += ("}");
this.throwbackInfo(pc, result.toString());
}
+10 -42
View File
@@ -11,7 +11,6 @@ package engine.devcmd.cmds;
import engine.Enum.BuildingGroup;
import engine.Enum.DbObjectType;
import engine.Enum.GameObjectType;
import engine.InterestManagement.WorldGrid;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.BuildingManager;
@@ -138,49 +137,16 @@ public class RemoveObjectCmd extends AbstractDevCmd {
Warehouse.warehouseByBuildingUUID.remove(building.getObjectUUID());
}
//remove cached shrines.
if ((building.getBlueprintUUID() != 0)
&& (building.getBlueprint().getBuildingGroup() == BuildingGroup.SHRINE))
Shrine.RemoveShrineFromCacheByBuilding(building);
for (AbstractCharacter ac : building.getHirelings().keySet()) {
NPC npc = null;
Mob mobA = null;
// Remove hirelings for this building
if (ac.getObjectType() == GameObjectType.NPC)
npc = (NPC) ac;
else if (ac.getObjectType() == GameObjectType.Mob)
mobA = (Mob) ac;
for (AbstractCharacter abstractCharacter : building.getHirelings().keySet())
BuildingManager.removeHireling(building, abstractCharacter);
if (npc != null) {
for (Mob mob : npc.siegeMinionMap.keySet()) {
WorldGrid.RemoveWorldObject(mob);
WorldGrid.removeObject(mob, pc);
//Mob.getRespawnMap().remove(mob);
if (mob.getParentZone() != null)
mob.getParentZone().zoneMobSet.remove(mob);
}
DbManager.NPCQueries.DELETE_NPC(npc);
DbManager.removeFromCache(npc);
WorldGrid.RemoveWorldObject(npc);
WorldGrid.removeObject(npc, pc);
} else if (mobA != null) {
for (Mob mob : mobA.getSiegeMinionMap().keySet()) {
WorldGrid.RemoveWorldObject(mob);
WorldGrid.removeObject(mob, pc);
//Mob.getRespawnMap().remove(mob);
if (mob.getParentZone() != null)
mob.getParentZone().zoneMobSet.remove(mob);
}
DbManager.MobQueries.DELETE_MOB(mobA);
DbManager.removeFromCache(mobA);
WorldGrid.RemoveWorldObject(mobA);
WorldGrid.removeObject(mobA, pc);
}
}
Zone zone = building.getParentZone();
DbManager.BuildingQueries.DELETE_FROM_DATABASE(building);
DbManager.removeFromCache(building);
@@ -209,11 +175,13 @@ public class RemoveObjectCmd extends AbstractDevCmd {
if (npc.building != null)
npc.building.getHirelings().remove(npc);
for (Mob mob : npc.siegeMinionMap.keySet()) {
WorldGrid.RemoveWorldObject(mob);
WorldGrid.removeObject(mob, pc);
if (mob.getParentZone() != null)
mob.getParentZone().zoneMobSet.remove(mob);
for (Integer minionUUID : npc.minions) {
Mob minionMob = Mob.getMob(minionUUID);
WorldGrid.RemoveWorldObject(minionMob);
WorldGrid.removeObject(minionMob, pc);
if (minionMob.getParentZone() != null)
minionMob.getParentZone().zoneMobSet.remove(minionMob);
}
DbManager.NPCQueries.DELETE_NPC(npc);
+43
View File
@@ -0,0 +1,43 @@
// ·. · · · · .
// · ·
// · ·
//
// · · ·
// Magicbane Emulator Project © 2013 - 2022
// www.magicbane.com
package engine.devcmd.cmds;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.ZoneManager;
import engine.objects.AbstractGameObject;
import engine.objects.PlayerCharacter;
import engine.objects.Zone;
public class SeaAuditCmd extends AbstractDevCmd {
public SeaAuditCmd() {
super("seaaudit");
}
@Override
protected void _doCmd(PlayerCharacter playerCharacter, String[] words,
AbstractGameObject target) {
for (Zone zone : ZoneManager.getAllZones())
if (zone.getSeaLevel() > zone.worldAltitude)
this.throwbackInfo(playerCharacter, zone.getObjectUUID() + zone.getName());
}
@Override
protected String _getHelpString() {
return "Queries heightmap engine";
}
@Override
protected String _getUsageString() {
return "' /getheight";
}
}
+1 -1
View File
@@ -62,7 +62,7 @@ public class SetAdminRuneCmd extends AbstractDevCmd {
if (worked) {
ChatManager.chatSayInfo(pcSender,
"rune of ID " + runeID + " removed");
InterestManager.reloadCharacter(pcSender,false);
InterestManager.reloadCharacter(pcSender);
} else
throwbackError(pcSender, "Failed to remove the rune of type "
+ runeID);
+1 -1
View File
@@ -47,7 +47,7 @@ public class SetBaseClassCmd extends AbstractDevCmd {
this.setTarget(pc); //for logging
ChatManager.chatSayInfo(pc,
"BaseClass changed to " + classID);
InterestManager.reloadCharacter(pc,false);
InterestManager.reloadCharacter(pc);
}
+3 -4
View File
@@ -14,7 +14,6 @@ import engine.devcmd.AbstractDevCmd;
import engine.gameManager.ChatManager;
import engine.objects.AbstractGameObject;
import engine.objects.PlayerCharacter;
import engine.server.MBServerStatics;
public class SetLevelCmd extends AbstractDevCmd {
@@ -47,7 +46,7 @@ public class SetLevelCmd extends AbstractDevCmd {
this.sendUsage(pc);
return;
}
if (level < 1 || level > MBServerStatics.LEVELCAP) {
if (level < 1 || level > 75) {
this.sendHelp(pc);
return;
}
@@ -58,12 +57,12 @@ public class SetLevelCmd extends AbstractDevCmd {
tar.setLevel((short) level);
this.setTarget(tar); //for logging
ChatManager.chatSayInfo(pc, tar.getFirstName() + " level changed to " + level);
InterestManager.reloadCharacter(tar,false);
InterestManager.reloadCharacter(tar);
}
@Override
protected String _getHelpString() {
return "Sets your character's level to 'amount'. 'amount' must be between 1-" + MBServerStatics.LEVELCAP;
return "Sets your character's level to 'amount'. 'amount' must be between 1-75";
}
@Override
@@ -42,7 +42,7 @@ public class SetPromotionClassCmd extends AbstractDevCmd {
pc.setPromotionClass(classID);
ChatManager.chatSayInfo(pc,
"PromotionClass changed to " + classID);
InterestManager.reloadCharacter(pc,false);
InterestManager.reloadCharacter(pc);
this.setTarget(pc); //for logging
+1 -1
View File
@@ -57,7 +57,7 @@ public class SetRuneCmd extends AbstractDevCmd {
if (worked) {
ChatManager.chatSayInfo(pcSender,
"rune of ID " + runeID + " removed");
InterestManager.reloadCharacter(pcSender,false);
InterestManager.reloadCharacter(pcSender);
} else
throwbackError(pcSender, "Failed to remove the rune of type "
+ runeID);
+1 -1
View File
@@ -159,7 +159,7 @@ public class SetSubRaceCmd extends AbstractDevCmd {
// pum.setEffectID(token);
// pum.setSourceType(pc.getObjectType().ordinal());
// pum.setSourceID(pc.getObjectUUID());
// pum.setTargetType(pc.getObjectType().ordinal());
// pum.setStartLocType(pc.getObjectType().ordinal());
// pum.setTargetID(pc.getObjectUUID());
// pum.setNumTrains(40);
// pum.setDuration(-1);
+3 -23
View File
@@ -1,12 +1,10 @@
package engine.devcmd.cmds;
import engine.Enum;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.LootManager;
import engine.gameManager.ZoneManager;
import engine.loot.BootySetEntry;
import engine.objects.*;
import org.pmw.tinylog.Logger;
import java.util.ArrayList;
import java.util.concurrent.ThreadLocalRandom;
@@ -28,9 +26,7 @@ public class SimulateBootyCmd extends AbstractDevCmd {
String output;
output = "Booty Simulation:" + newline;
if(target.getObjectType().equals(Enum.GameObjectType.Mob) == false){
return;//ugh what?
}
Mob mob = (Mob) target;
output += "Name: " + mob.getName() + newline;
output += "Special Loot:" + newline;
@@ -55,7 +51,7 @@ public class SimulateBootyCmd extends AbstractDevCmd {
int failures = 0;
int goldAmount = 0;
for (int i = 0; i < 10000; ++i) {
for (int i = 0; i < 100; ++i) {
try {
mob.loadInventory();
@@ -83,19 +79,12 @@ public class SimulateBootyCmd extends AbstractDevCmd {
goldAmount += lootItem.getNumOfItems();
break;
default:
if(Warehouse.maxResources.containsKey(lootItem.getItemBaseID())){
Resources.add(lootItem);
} else {
OtherDrops.add(lootItem);
}
OtherDrops.add(lootItem);
break;
}
}
} catch (Exception ex) {
failures++;
//throwbackError(playerCharacter,ex.getLocalizedMessage());
//Logger.error(ex.fillInStackTrace());
//return;
}
if (mob.getEquip() != null) {
for (MobEquipment me : mob.getEquip().values()) {
@@ -142,17 +131,8 @@ public class SimulateBootyCmd extends AbstractDevCmd {
}
output += "GLASS DROPS: " + GlassItems.size() + newline;
for(Item glass : GlassItems){
output += " " + glass.getName() + newline;
}
output += "RUNE DROPS: " + Runes.size() + newline;
for(Item rune : Runes){
output += " " + rune.getName() + newline;
}
output += "CONTRACTS DROPS: " + Contracts.size() + newline;
for(Item contract : Contracts){
output += " " + contract.getName() + newline;
}
output += "RESOURCE DROPS: " + Resources.size() + newline;
output += "OFFERINGS DROPPED: " + Offerings.size() + newline;
output += "ENCHANTED ITEMS DROPPED: " + OtherDrops.size() + newline;
+1 -1
View File
@@ -71,7 +71,7 @@ public class SlotTestCmd extends AbstractDevCmd {
outString += "Hirelings List:";
for (AbstractCharacter hireling : building.getHirelings().keySet())
outString += "\r\n" + hireling.getName() + "(" + hireling.getObjectUUID() + ") slot : " + building.getHirelings().get(hireling);
outString += "\r\n" + hireling.getName() + " slot : " + building.getHirelings().get(hireling);
}
+2 -1
View File
@@ -1,5 +1,6 @@
package engine.devcmd.cmds;
import engine.Enum;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.ZoneManager;
import engine.math.Vector3fImmutable;
@@ -110,7 +111,7 @@ public class SplatMobCmd extends AbstractDevCmd {
mobile = Mob.createMob(_mobileUUID,
Vector3fImmutable.getRandomPointInCircle(_currentLocation, _targetRange),
null, serverZone, null, null, "", 1);
null, serverZone, null, null, "", 1, Enum.AIAgentType.MOBILE);
if (mobile != null) {
mobile.updateDatabase();
+1 -1
View File
@@ -104,7 +104,7 @@ public class ZoneInfoCmd extends AbstractDevCmd {
output += newline;
output += "Sea Level = " + zone.getSeaLevel();
output += newline;
output += "World Altitude = " + zone.getWorldAltitude();
output += "World Altitude = " + zone.worldAltitude;
throwbackInfo(player, output);
City city = ZoneManager.getCityAtLocation(player.getLoc());
+61 -8
View File
@@ -9,14 +9,17 @@
package engine.devcmd.cmds;
import engine.Enum;
import engine.Enum.GameObjectType;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.PowersManager;
import engine.mobileAI.MobAI;
import engine.objects.AbstractGameObject;
import engine.objects.Mob;
import engine.objects.MobBase;
import engine.objects.PlayerCharacter;
import engine.powers.RunePowerEntry;
import java.util.ArrayList;
import java.util.Map;
@@ -58,6 +61,27 @@ public class aiInfoCmd extends AbstractDevCmd {
Mob mob = (Mob) target;
output = "Mob AI Information:" + newline;
output += mob.getName() + newline;
output += mob.agentType.toString() + newline;
int contractID = 0;
if (mob.isPlayerGuard() == true) {
if (mob.agentType.equals(Enum.AIAgentType.GUARDMINION))
contractID = mob.guardCaptain.contract.getContractID();
else
contractID = mob.contract.getContractID();
}
if (contractID != 0) {
if (mob.agentType.equals(Enum.AIAgentType.GUARDMINION)) {
output += "Captain Contract: " + contractID + newline;
output += "Captain UUID: " + mob.guardCaptain.getObjectUUID() + newline;
} else
output += "Contract: " + contractID + newline;
}
if (mob.behaviourType != null) {
output += "BehaviourType: " + mob.behaviourType.toString() + newline;
if (mob.behaviourType.BehaviourHelperType != null) {
@@ -88,17 +112,46 @@ public class aiInfoCmd extends AbstractDevCmd {
if (mob.guardedCity != null)
output += "Patrolling: " + mob.guardedCity.getCityName() + newline;
output += "See Invis Level: " + mob.mobBase.getSeeInvis() + newline;
output += "Can Cast: " + MobAI.canCast(mob) + newline;
output += "Powers:" + newline;
for (int token : mob.mobPowers.keySet())
output += PowersManager.getPowerByToken(token).getName() + newline;
ArrayList<RunePowerEntry> powerEntries = new ArrayList<>(PowersManager.getPowersForRune(mob.getMobBaseID()));
// Additional powers may come from the contract ID. This is to support
// powers for player guards irrespective of the mobbase used.
if (mob.isPlayerGuard()) {
ArrayList<RunePowerEntry> contractEntries = new ArrayList<>();
if (mob.contract != null)
contractEntries = new ArrayList<>(PowersManager.getPowersForRune(mob.contractUUID));
if (mob.agentType.equals(Enum.AIAgentType.GUARDMINION))
contractEntries = new ArrayList<>(PowersManager.getPowersForRune(mob.guardCaptain.contractUUID));
powerEntries.addAll(contractEntries);
}
for (RunePowerEntry runePowerEntry : powerEntries)
output += PowersManager.getPowerByToken(runePowerEntry.token).getName() + newline;
// List outlaws defined for this player guard's city
if (mob.isPlayerGuard()) {
ArrayList<Integer> outlaws = new ArrayList(mob.guardedCity.cityOutlaws);
if (outlaws.isEmpty() == false)
output += "Outlaws: " + newline;
for (Integer outlawUUID : outlaws)
output += outlawUUID + newline;
}
output += "Race type: " + MobBase.mobbase_race_types.get(mob.getMobBaseID());
throwbackInfo(playerCharacter, output);
throwbackInfo(playerCharacter, "Race Types: " + MobBase.mobbase_race_types.size());
}
@Override
-72
View File
@@ -1,72 +0,0 @@
// ·. · · · · .
// · ·
// · ·
//
// · · ·
// Magicbane Emulator Project © 2013 - 2022
// www.magicbane.com
package engine.devcmd.cmds;
import engine.Enum.GameObjectType;
import engine.InterestManagement.WorldGrid;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.*;
import engine.objects.*;
import org.pmw.tinylog.Logger;
/**
* @author Eighty
*/
public class setProfit extends AbstractDevCmd {
public setProfit() {
super("setprofit");
}
@Override
protected void _doCmd(PlayerCharacter pc, String[] words,
AbstractGameObject target) {
if (words.length < 2) {
this.sendUsage(pc);
return;
}
float updateValue;
try {
updateValue = Float.parseFloat(words[1]);
} catch (NumberFormatException e) {
throwbackError(pc,
"Failed to parse supplied contractID or level to an Integer.");
return; // NaN
}
if(target.getObjectType().equals(GameObjectType.NPC) == false){
return;
}
NPC npc = (NPC)target;
if(words[0].toLowerCase().equals("buy")){
npc.buyPercent = updateValue;
npc.updateDatabase();
return;
}
if(words[0].toLowerCase().equals("sell")){
npc.sellPercent = updateValue;
npc.updateDatabase();
return;
}
}
@Override
protected String _getHelpString() {
return "Sets profit margin of targeted NPC";
}
@Override
protected String _getUsageString() {
return "' /setprofit buy/sell VALUE(1.0)'";
}
}
+104 -41
View File
@@ -308,6 +308,72 @@ public enum BuildingManager {
}
public static void removeHireling(Building building, AbstractCharacter hireling) {
if (hireling.getObjectType().equals(GameObjectType.Mob)) {
Mob guardCaptain = (Mob) hireling;
// Clear minions from database if a guard captain
if (guardCaptain.agentType.equals(Enum.AIAgentType.GUARDCAPTAIN))
DbManager.MobQueries.REMOVE_ALL_MINIONS(hireling.getObjectUUID());
}
// Clear minions from world
for (Integer minionUUID : hireling.minions) {
Mob minionMob = Mob.getMob(minionUUID);
DbManager.removeFromCache(minionMob);
WorldGrid.RemoveWorldObject(minionMob);
WorldGrid.unloadObject(minionMob);
if (minionMob.getParentZone() != null)
minionMob.getParentZone().zoneMobSet.remove(minionMob);
}
// Remove hireling from building
building.getHirelings().remove(hireling);
// Remove from zone mob set
if (hireling.getObjectType().equals(GameObjectType.Mob)) {
Mob hirelingMob = (Mob) hireling;
if (hirelingMob.getParentZone() != null)
if (hirelingMob.getParentZone().zoneMobSet.contains(hirelingMob))
hirelingMob.getParentZone().zoneMobSet.remove(hireling);
}
if (hireling.getObjectType().equals(GameObjectType.NPC)) {
NPC hirelingNPC = (NPC) hireling;
if (hirelingNPC.getParentZone() != null)
if (hirelingNPC.getParentZone().zoneNPCSet.contains(hirelingNPC))
hirelingNPC.getParentZone().zoneNPCSet.remove(hireling);
}
// Unload hireling from world
DbManager.removeFromCache(hireling);
WorldGrid.RemoveWorldObject(hireling);
WorldGrid.removeObject(hireling);
// Delete hireling from database
if (hireling.getObjectType().equals(GameObjectType.Mob))
DbManager.MobQueries.DELETE_MOB((Mob) hireling);
else
DbManager.NPCQueries.DELETE_NPC((NPC) hireling);
}
public static void cleanupHirelings(Building building) {
// Early exit: Cannot have hirelings in a building
@@ -320,42 +386,18 @@ public enum BuildingManager {
if (building.getRank() < 1) {
for (AbstractCharacter slottedNPC : building.getHirelings().keySet()) {
for (AbstractCharacter slottedNPC : building.getHirelings().keySet())
BuildingManager.removeHireling(building, slottedNPC);
if (slottedNPC.getObjectType() == Enum.GameObjectType.NPC)
((NPC) slottedNPC).remove();
else if (slottedNPC.getObjectType() == Enum.GameObjectType.Mob)
NPCManager.removeMobileFromBuilding(((Mob) slottedNPC), building);
}
return;
}
// Delete hireling if building has deranked.
for (AbstractCharacter hireling : building.getHirelings().keySet()) {
NPC npc = null;
Mob mob = null;
if (hireling.getObjectType() == Enum.GameObjectType.NPC)
npc = (NPC) hireling;
else if (hireling.getObjectType() == Enum.GameObjectType.Mob)
mob = (Mob) hireling;
if (building.getHirelings().get(hireling) > building.getBlueprint().getSlotsForRank(building.getRank()))
if (npc != null) {
if (!npc.remove())
Logger.error("Failed to remove npc " + npc.getObjectUUID()
+ "from Building " + building.getObjectUUID());
else
building.getHirelings().remove(npc);
} else if (mob != null) {
if (!NPCManager.removeMobileFromBuilding(mob, building))
Logger.error("Failed to remove npc " + npc.getObjectUUID()
+ "from Building " + building.getObjectUUID());
else
building.getHirelings().remove(npc);
}
BuildingManager.removeHireling(building, hireling);
}
@@ -520,10 +562,9 @@ public enum BuildingManager {
if (building.getBlueprintUUID() == 0)
return false;
if (building.getBlueprint().getSlotsForRank(building.getRank()) == building.getHirelings().size()) {
Logger.error("failed at addHireling with contract: " + contract.getContractID());
if (building.getBlueprint().getMaxSlots() == building.getHirelings().size())
return false;
}
String pirateName = NPCManager.getPirateName(contract.getMobbaseID());
if (item.getChargesRemaining() > 0)
@@ -531,41 +572,63 @@ public enum BuildingManager {
else
rank = 10;
Mob mob;
Mob mobile;
NPC npc;
if (NPC.ISWallArcher(contract)) {
mob = Mob.createMob(contract.getMobbaseID(), Vector3fImmutable.ZERO, contractOwner.getGuild(), zone, building, contract, pirateName, rank);
mobile = Mob.createMob(contract.getMobbaseID(), Vector3fImmutable.ZERO, contractOwner.getGuild(), zone, building, contract, pirateName, rank, Enum.AIAgentType.GUARDWALLARCHER);
if (mob == null)
if (mobile == null)
return false;
mob.setLoc(mob.getLoc());
// Configure AI and write new mobile to disk
mobile.behaviourType = Enum.MobBehaviourType.GuardWallArcher;
mobile = DbManager.MobQueries.PERSIST(mobile);
// Spawn new mobile
mobile.setLoc(mobile.getLoc());
return true;
}
if (NPC.ISGuardCaptain(contract.getContractID())) {
mob = Mob.createMob(contract.getMobbaseID(), Vector3fImmutable.ZERO, contractOwner.getGuild(), zone, building, contract, pirateName, rank);
mobile = Mob.createMob(contract.getMobbaseID(), Vector3fImmutable.ZERO, contractOwner.getGuild(), zone, building, contract, pirateName, rank, Enum.AIAgentType.GUARDCAPTAIN);
if (mob == null)
if (mobile == null)
return false;
mob.setLoc(mob.getLoc());
// Configure AI and write new mobile to disk
mobile.behaviourType = Enum.MobBehaviourType.GuardCaptain;
mobile = DbManager.MobQueries.PERSIST(mobile);
// Spawn new mobile
mobile.setLoc(mobile.getLoc());
return true;
}
if (contract.getContractID() == 910) {
//guard dog
mob = Mob.createMob(contract.getMobbaseID(), Vector3fImmutable.ZERO, contractOwner.getGuild(), zone, building, contract, pirateName, rank);
mobile = Mob.createMob(contract.getMobbaseID(), Vector3fImmutable.ZERO, contractOwner.getGuild(), zone, building, contract, pirateName, rank, Enum.AIAgentType.GUARDCAPTAIN);
if (mob == null)
if (mobile == null)
return false;
mob.setLoc(mob.getLoc());
// Configure AI and write new mobile to disk
mobile.behaviourType = Enum.MobBehaviourType.GuardCaptain;
mobile = DbManager.MobQueries.PERSIST(mobile);
// Spawn new mobile
mobile.setLoc(mobile.getLoc());
return true;
}
+1 -1
View File
@@ -788,7 +788,7 @@ public enum ChatManager {
it.remove();
else {
PlayerCharacter pcc = (PlayerCharacter) awo;
if (pcc.getSeeInvis() < pc.getHidden())
if (pcc.getSeeInvis() < pc.hidden)
it.remove();
}
}
+113 -222
View File
@@ -30,8 +30,6 @@ import java.util.HashSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ThreadLocalRandom;
import static engine.math.FastMath.sqr;
public enum CombatManager {
COMBATMANAGER;
@@ -41,63 +39,6 @@ public enum CombatManager {
/**
* Message sent by player to attack something.
*/
public static void setAttackTarget(AttackCmdMsg msg, ClientConnection origin) throws MsgSendException {
PlayerCharacter player;
int targetType;
AbstractWorldObject target;
if (TargetedActionMsg.un2cnt == 60 || TargetedActionMsg.un2cnt == 70)
return;
player = SessionManager.getPlayerCharacter(origin);
if (player == null)
return;
//source must match player this account belongs to
if (player.getObjectUUID() != msg.getSourceID() || player.getObjectType().ordinal() != msg.getSourceType()) {
Logger.error("Msg Source ID " + msg.getSourceID() + " Does not Match Player ID " + player.getObjectUUID());
return;
}
targetType = msg.getTargetType();
if (targetType == GameObjectType.PlayerCharacter.ordinal()) {
target = PlayerCharacter.getFromCache(msg.getTargetID());
} else if (targetType == GameObjectType.Building.ordinal()) {
target = BuildingManager.getBuildingFromCache(msg.getTargetID());
} else if (targetType == GameObjectType.Mob.ordinal()) {
target = Mob.getFromCache(msg.getTargetID());
} else {
player.setCombatTarget(null);
return; //not valid type to attack
}
// quit of the combat target is already the current combat target
// or there is no combat target
if (target == null)
return;
//set sources target
player.setCombatTarget(target);
//put in combat if not already
if (!player.isCombat())
toggleCombat(true, origin);
//make character stand if sitting
if (player.isSit())
toggleSit(false, origin);
AttackTarget(player, target);
}
public static void AttackTarget(PlayerCharacter playerCharacter, AbstractWorldObject target) {
@@ -141,11 +82,6 @@ public enum CombatManager {
if (off == null)
CombatManager.createTimer(playerCharacter, MBServerStatics.SLOT_OFFHAND, 1, true); // attack in 0.1 of a second
}
City playerCity = ZoneManager.getCityAtLocation(playerCharacter.getLoc());
if (playerCity != null && playerCity.getGuild().getNation().equals(playerCharacter.getGuild().getNation()) == false && playerCity.cityOutlaws.contains(playerCharacter.getObjectUUID()) == false)
playerCity.cityOutlaws.add(playerCharacter.getObjectUUID());
}
public static void setAttackTarget(PetAttackMsg msg, ClientConnection origin) throws MsgSendException {
@@ -523,28 +459,28 @@ public enum CombatManager {
/**
* Attempt to attack target
*/
private static void attack(AbstractCharacter ac, AbstractWorldObject target, Item weapon, ItemBase wb, boolean mainHand) {
private static void attack(AbstractCharacter attacker, AbstractWorldObject target, Item weapon, ItemBase wb, boolean mainHand) {
float atr;
int minDamage, maxDamage;
int errorTrack = 0;
int subTrack = 0;
try {
if (ac == null)
if (attacker == null)
return;
if (target == null)
return;
if (mainHand) {
atr = ac.getAtrHandOne();
minDamage = ac.getMinDamageHandOne();
maxDamage = ac.getMaxDamageHandOne();
atr = attacker.getAtrHandOne();
minDamage = attacker.getMinDamageHandOne();
maxDamage = attacker.getMaxDamageHandOne();
} else {
atr = ac.getAtrHandTwo();
minDamage = ac.getMinDamageHandTwo();
maxDamage = ac.getMaxDamageHandTwo();
atr = attacker.getAtrHandTwo();
minDamage = attacker.getMinDamageHandTwo();
maxDamage = attacker.getMaxDamageHandTwo();
}
boolean tarIsRat = false;
@@ -563,9 +499,9 @@ public enum CombatManager {
//Dont think we need to do this anymore.
if (tarIsRat)
if (ac.getBonuses().getFloatPercentAll(ModType.Slay, SourceType.Rat) != 0) { //strip away current % dmg buffs then add with rat %
if (attacker.getBonuses().getFloatPercentAll(ModType.Slay, SourceType.Rat) != 0) { //strip away current % dmg buffs then add with rat %
float percent = 1 + ac.getBonuses().getFloatPercentAll(ModType.Slay, SourceType.Rat);
float percent = 1 + attacker.getBonuses().getFloatPercentAll(ModType.Slay, SourceType.Rat);
minDamage *= percent;
maxDamage *= percent;
@@ -576,24 +512,24 @@ public enum CombatManager {
//subtract stamina
if (wb == null)
ac.modifyStamina(-0.5f, ac, true);
attacker.modifyStamina(-0.5f, attacker, true);
else {
float stam = wb.getWeight() / 3;
stam = (stam < 1) ? 1 : stam;
ac.modifyStamina(-(stam), ac, true);
attacker.modifyStamina(-(stam), attacker, true);
}
ac.cancelOnAttackSwing();
attacker.cancelOnAttackSwing();
errorTrack = 2;
//set last time this player has attacked something.
if (target.getObjectType().equals(GameObjectType.PlayerCharacter) && target.getObjectUUID() != ac.getObjectUUID() && ac.getObjectType() == GameObjectType.PlayerCharacter) {
ac.setTimeStamp("LastCombatPlayer", System.currentTimeMillis());
if (target.getObjectType().equals(GameObjectType.PlayerCharacter) && target.getObjectUUID() != attacker.getObjectUUID() && attacker.getObjectType() == GameObjectType.PlayerCharacter) {
attacker.setTimeStamp("LastCombatPlayer", System.currentTimeMillis());
((PlayerCharacter) target).setTimeStamp("LastCombatPlayer", System.currentTimeMillis());
} else
ac.setTimeStamp("LastCombatMob", System.currentTimeMillis());
attacker.setTimeStamp("LastCombatMob", System.currentTimeMillis());
errorTrack = 3;
@@ -604,74 +540,46 @@ public enum CombatManager {
if (target.getObjectType().equals(GameObjectType.Building)) {
if (BuildingManager.getBuildingFromCache(target.getObjectUUID()) == null) {
ac.setCombatTarget(null);
attacker.setCombatTarget(null);
return;
}
defense = 0;
Building building = (Building) target;
if (building.getParentZone() != null && building.getParentZone().isPlayerCity()) {
if (System.currentTimeMillis() > building.getTimeStamp("CallForHelp")) {
building.getTimestamps().put("CallForHelp", System.currentTimeMillis() + 15000);
for (Mob mob : building.getParentZone().zoneMobSet) {
if (!mob.isPlayerGuard())
continue;
if (mob.getCombatTarget() != null)
continue;
if (mob.getGuild() != null && building.getGuild() != null)
if (!Guild.sameGuild(mob.getGuild().getNation(), building.getGuild().getNation()))
continue;
if (mob.getLoc().distanceSquared2D(building.getLoc()) > sqr(300))
continue;
mob.setCombatTarget(ac);
}
}
}
} else {
AbstractCharacter tar = (AbstractCharacter) target;
defense = tar.getDefenseRating();
handleRetaliate(tar, ac); //Handle target attacking back if in combat and has no other target
handleRetaliate(tar, attacker); //Handle target attacking back if in combat and has no other target
}
errorTrack = 4;
//Get hit chance
float constant = (atr+defense)*0.315f;
float atrChance = atr - constant;
float defChance = defense - constant + atrChance;
float smallChance = atrChance/defChance;
int chance = (int)(smallChance * 100);
int chance;
float dif = atr - defense;
if (dif > 100)
chance = 94;
else if (dif < -100)
chance = 4;
else
chance = (int) ((0.45 * dif) + 49);
errorTrack = 5;
if(chance < 5){
chance = 5;
}
if(chance > 95){
chance = 95;
}
//calculate hit/miss
int roll = ThreadLocalRandom.current().nextInt(1,101);
int roll = ThreadLocalRandom.current().nextInt(100);
DeferredPowerJob dpj = null;
if (roll < chance) {
if (ac.getObjectType().equals(GameObjectType.PlayerCharacter))
updateAttackTimers((PlayerCharacter) ac, target, true);
if (attacker.getObjectType().equals(GameObjectType.PlayerCharacter))
updateAttackTimers((PlayerCharacter) attacker, target, true);
boolean skipPassives = false;
PlayerBonuses bonuses = ac.getBonuses();
PlayerBonuses bonuses = attacker.getBonuses();
if (bonuses != null && bonuses.getBool(ModType.IgnorePassiveDefense, SourceType.None))
skipPassives = true;
@@ -686,26 +594,26 @@ public enum CombatManager {
// Apply Weapon power effect if any. don't try to apply twice if
// dual wielding. Perform after passive test for sync purposes.
if (ac.getObjectType().equals(GameObjectType.PlayerCharacter) && (mainHand || wb.isTwoHanded())) {
if (attacker.getObjectType().equals(GameObjectType.PlayerCharacter) && (mainHand || wb.isTwoHanded())) {
dpj = ((PlayerCharacter) ac).getWeaponPower();
dpj = ((PlayerCharacter) attacker).getWeaponPower();
if (dpj != null) {
PlayerBonuses bonus = ac.getBonuses();
PlayerBonuses bonus = attacker.getBonuses();
float attackRange = getWeaponRange(wb, bonus);
dpj.attack(target, attackRange);
if (dpj.getPower() != null && (dpj.getPowerToken() == -1851459567 || dpj.getPowerToken() == -1851489518))
((PlayerCharacter) ac).setWeaponPower(dpj);
((PlayerCharacter) attacker).setWeaponPower(dpj);
}
}
//check to apply second backstab.
if (ac.getObjectType().equals(GameObjectType.PlayerCharacter) && !mainHand) {
if (attacker.getObjectType().equals(GameObjectType.PlayerCharacter) && !mainHand) {
dpj = ((PlayerCharacter) ac).getWeaponPower();
dpj = ((PlayerCharacter) attacker).getWeaponPower();
if (dpj != null && dpj.getPower() != null && (dpj.getPowerToken() == -1851459567 || dpj.getPowerToken() == -1851489518)) {
float attackRange = getWeaponRange(wb, bonuses);
@@ -725,24 +633,24 @@ public enum CombatManager {
//Handle Block passive
if (testPassive(ac, tarAc, "Block") && canTestBlock(ac, target)) {
if (testPassive(attacker, tarAc, "Block") && canTestBlock(attacker, target)) {
if (!target.isAlive())
return;
sendPassiveDefenseMessage(ac, wb, target, MBServerStatics.COMBAT_SEND_BLOCK, dpj, mainHand);
sendPassiveDefenseMessage(attacker, wb, target, MBServerStatics.COMBAT_SEND_BLOCK, dpj, mainHand);
passiveFired = true;
}
//Handle Parry passive
if (!passiveFired)
if (canTestParry(ac, target) && testPassive(ac, tarAc, "Parry")) {
if (canTestParry(attacker, target) && testPassive(attacker, tarAc, "Parry")) {
if (!target.isAlive())
return;
sendPassiveDefenseMessage(ac, wb, target, MBServerStatics.COMBAT_SEND_PARRY, dpj, mainHand);
sendPassiveDefenseMessage(attacker, wb, target, MBServerStatics.COMBAT_SEND_PARRY, dpj, mainHand);
passiveFired = true;
}
@@ -753,12 +661,12 @@ public enum CombatManager {
//Handle Dodge passive
if (!passiveFired)
if (testPassive(ac, tarAc, "Dodge")) {
if (testPassive(attacker, tarAc, "Dodge")) {
if (!target.isAlive())
return;
sendPassiveDefenseMessage(ac, wb, target, MBServerStatics.COMBAT_SEND_DODGE, dpj, mainHand);
sendPassiveDefenseMessage(attacker, wb, target, MBServerStatics.COMBAT_SEND_DODGE, dpj, mainHand);
passiveFired = true;
}
}
@@ -774,7 +682,7 @@ public enum CombatManager {
//if target is player, set last attack timestamp
if (target.getObjectType().equals(GameObjectType.PlayerCharacter))
updateAttackTimers((PlayerCharacter) target, ac, false);
updateAttackTimers((PlayerCharacter) target, attacker, false);
//Get damage Type
@@ -782,7 +690,7 @@ public enum CombatManager {
if (wb != null)
damageType = wb.getDamageType();
else if (ac.getObjectType().equals(GameObjectType.Mob) && ((Mob) ac).isSiege())
else if (attacker.getObjectType().equals(GameObjectType.Mob) && ((Mob) attacker).isSiege())
damageType = DamageType.Siege;
else
damageType = DamageType.Crush;
@@ -801,7 +709,7 @@ public enum CombatManager {
//make sure target is not immune to damage type;
if (resists != null && resists.immuneTo(damageType)) {
sendCombatMessage(ac, target, 0f, wb, dpj, mainHand);
sendCombatMessage(attacker, target, 0f, wb, dpj, mainHand);
return;
}
@@ -811,7 +719,11 @@ public enum CombatManager {
float damage;
damage = calculateDamage(ac, tarAc, minDamage, maxDamage, damageType, resists);
if (wb != null)
damage = calculateDamage(attacker, tarAc, minDamage, maxDamage, damageType, resists);
else
damage = calculateDamage(attacker, tarAc, minDamage, maxDamage, damageType, resists);
float d = 0f;
errorTrack = 12;
@@ -819,58 +731,39 @@ public enum CombatManager {
//Subtract Damage from target's health
if (tarAc != null) {
if (tarAc.isSit())
damage *= 2.5f; //increase damage if sitting
if (tarAc.isSit())
damage *= 2.5f; //increase damage if sitting
subTrack = 1;
if (tarAc.getHealth() > 0)
d = tarAc.modifyHealth(-damage, attacker, false);
if (tarAc.getObjectType() == GameObjectType.Mob) {
Mob mobTarget = (Mob) tarAc;
if (ac.getObjectType().equals(GameObjectType.PlayerCharacter)) {
subTrack = 2;
if (mobTarget.playerAgroMap.containsKey(ac.getObjectUUID())) {
subTrack = 3;
float hateValue = damage + mobTarget.playerAgroMap.get(ac.getObjectUUID());
mobTarget.playerAgroMap.put(ac.getObjectUUID(), hateValue);
} else {
mobTarget.playerAgroMap.put(ac.getObjectUUID(), damage);
}
subTrack = 4;
}
mobTarget.handleDirectAggro(ac);
}
if (tarAc.getHealth() > 0)
d = tarAc.modifyHealth(-damage, ac, false);
subTrack = 5;
} else if (target.getObjectType().equals(GameObjectType.Building)) {
subTrack = 6;
if (BuildingManager.getBuildingFromCache(target.getObjectUUID()) == null) {
ac.setCombatTarget(null);
subTrack = 7;
attacker.setCombatTarget(null);
return;
}
subTrack = 8;
if (target.getHealth() > 0)
d = ((Building) target).modifyHealth(-damage, ac);
subTrack = 9;
d = ((Building) target).modifyHealth(-damage, attacker);
}
errorTrack = 13;
//Test to see if any damage needs done to weapon or armor
testItemDamage(ac, target, weapon, wb);
testItemDamage(attacker, target, weapon, wb);
// if target is dead, we got the killing blow, remove attack timers on our weapons
if (tarAc != null && !tarAc.isAlive())
removeAttackTimers(ac);
removeAttackTimers(attacker);
//test double death fix
if (d != 0)
sendCombatMessage(ac, target, damage, wb, dpj, mainHand); //send damage message
sendCombatMessage(attacker, target, damage, wb, dpj, mainHand); //send damage message
errorTrack = 14;
@@ -897,7 +790,7 @@ public enum CombatManager {
int procChance = ThreadLocalRandom.current().nextInt(100);
if (procChance < MBServerStatics.PROC_CHANCE)
((WeaponProcEffectModifier) aem).applyProc(ac, target);
((WeaponProcEffectModifier) aem).applyProc(attacker, target);
}
}
@@ -909,53 +802,52 @@ public enum CombatManager {
//handle damage shields
if (ac.isAlive() && tarAc != null && tarAc.isAlive())
handleDamageShields(ac, tarAc, damage);
if (attacker.isAlive() && tarAc != null && tarAc.isAlive())
handleDamageShields(attacker, tarAc, damage);
} else {
// Apply Weapon power effect if any.
// don't try to apply twice if dual wielding.
if (ac.getObjectType().equals(GameObjectType.PlayerCharacter) && (mainHand || wb.isTwoHanded())) {
dpj = ((PlayerCharacter) ac).getWeaponPower();
if (attacker.getObjectType().equals(GameObjectType.PlayerCharacter) && (mainHand || wb.isTwoHanded())) {
dpj = ((PlayerCharacter) attacker).getWeaponPower();
if (dpj != null) {
PowersBase wp = dpj.getPower();
if (wp.requiresHitRoll() == false) {
PlayerBonuses bonus = ac.getBonuses();
PlayerBonuses bonus = attacker.getBonuses();
float attackRange = getWeaponRange(wb, bonus);
dpj.attack(target, attackRange);
} else
((PlayerCharacter) ac).setWeaponPower(null);
((PlayerCharacter) attacker).setWeaponPower(null);
}
}
if (target.getObjectType() == GameObjectType.Mob)
((Mob) target).handleDirectAggro(ac);
((Mob) target).handleDirectAggro(attacker);
errorTrack = 17;
//miss, Send miss message
sendCombatMessage(ac, target, 0f, wb, dpj, mainHand);
sendCombatMessage(attacker, target, 0f, wb, dpj, mainHand);
//if attacker is player, set last attack timestamp
if (ac.getObjectType().equals(GameObjectType.PlayerCharacter))
updateAttackTimers((PlayerCharacter) ac, target, true);
if (attacker.getObjectType().equals(GameObjectType.PlayerCharacter))
updateAttackTimers((PlayerCharacter) attacker, target, true);
}
errorTrack = 18;
//cancel effects that break on attack or attackSwing
ac.cancelOnAttack();
attacker.cancelOnAttack();
} catch (Exception e) {
Logger.error(ac.getName() + ' ' + "ErrorTrack: " + errorTrack + " ErrorSubTrack = " + subTrack + e);
Logger.error(e.getMessage());
Logger.error(attacker.getName() + ' ' + errorTrack + ' ' + e);
}
}
@@ -1034,9 +926,7 @@ public enum CombatManager {
damage += minDamage;
//calculate resists in if any
if(source.getObjectType().equals(GameObjectType.PlayerCharacter)){
damage *= ((PlayerCharacter)source).ZergMultiplier;
}
if (resists != null)
return resists.getResistedDamage(source, target, damageType, damage, 0);
else
@@ -1235,7 +1125,7 @@ public enum CombatManager {
toggleCombat(msg.getToggle(), origin);
}
private static void toggleCombat(boolean toggle, ClientConnection origin) {
public static void toggleCombat(boolean toggle, ClientConnection origin) {
PlayerCharacter pc = SessionManager.getPlayerCharacter(origin);
@@ -1252,7 +1142,7 @@ public enum CombatManager {
DispatchMessage.dispatchMsgToInterestArea(pc, rwss, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, false, false);
}
private static void toggleSit(boolean toggle, ClientConnection origin) {
public static void toggleSit(boolean toggle, ClientConnection origin) {
PlayerCharacter pc = SessionManager.getPlayerCharacter(origin);
@@ -1275,13 +1165,6 @@ public enum CombatManager {
range += (calcHitBox(ac) + calcHitBox(target));
if(ac.getObjectType().equals(GameObjectType.PlayerCharacter)){
range += ((PlayerCharacter)ac).getCharacterHeight() * 0.5f;
if(ac.isMoving()){
range += ((PlayerCharacter) ac).getCharacterHeight();
}
}
float magnitudeSquared = tl.distanceSquared(sl);
return magnitudeSquared > range * range;
@@ -1289,61 +1172,69 @@ public enum CombatManager {
}
//Called when character takes damage.
public static void handleRetaliate(AbstractCharacter tarAc, AbstractCharacter ac) {
public static void handleRetaliate(AbstractCharacter target, AbstractCharacter attacker) {
if (ac == null || tarAc == null)
if (attacker == null || target == null)
return;
if (ac.equals(tarAc))
if (attacker.equals(target))
return;
if (tarAc.isMoving() && tarAc.getObjectType().equals(GameObjectType.PlayerCharacter))
if (target.isMoving() && target.getObjectType().equals(GameObjectType.PlayerCharacter))
return;
if (!tarAc.isAlive() || !ac.isAlive())
if (!target.isAlive() || !attacker.isAlive())
return;
boolean isCombat = tarAc.isCombat();
boolean isCombat = target.isCombat();
//If target in combat and has no target, then attack back
AbstractWorldObject awoCombTar = tarAc.getCombatTarget();
AbstractWorldObject awoCombTar = target.getCombatTarget();
if ((tarAc.isCombat() && awoCombTar == null) || (isCombat && awoCombTar != null && (!awoCombTar.isAlive() || tarAc.isCombat() && NotInRange(tarAc, awoCombTar, tarAc.getRange()))) || (tarAc != null && tarAc.getObjectType() == GameObjectType.Mob && ((Mob) tarAc).isSiege()))
if (tarAc.getObjectType().equals(GameObjectType.PlayerCharacter)) { // we are in combat with no valid target
if ((target.isCombat() && awoCombTar == null) || (isCombat && awoCombTar != null && (!awoCombTar.isAlive() || target.isCombat() && NotInRange(target, awoCombTar, target.getRange()))) || (target != null && target.getObjectType() == GameObjectType.Mob && ((Mob) target).isSiege()))
if (target.getObjectType().equals(GameObjectType.PlayerCharacter)) { // we are in combat with no valid target
PlayerCharacter pc = (PlayerCharacter) tarAc;
tarAc.setCombatTarget(ac);
pc.setLastTarget(ac.getObjectType(), ac.getObjectUUID());
PlayerCharacter pc = (PlayerCharacter) target;
target.setCombatTarget(attacker);
pc.setLastTarget(attacker.getObjectType(), attacker.getObjectUUID());
if (tarAc.getTimers() != null)
if (!tarAc.getTimers().containsKey("Attack" + MBServerStatics.SLOT_MAINHAND))
CombatManager.AttackTarget((PlayerCharacter) tarAc, tarAc.getCombatTarget());
if (target.getTimers() != null)
if (!target.getTimers().containsKey("Attack" + MBServerStatics.SLOT_MAINHAND))
CombatManager.AttackTarget((PlayerCharacter) target, target.getCombatTarget());
}
//Handle pet retaliate if assist is on and pet doesn't have a target.
if (tarAc.getObjectType().equals(GameObjectType.PlayerCharacter)) {
if (target.getObjectType().equals(GameObjectType.PlayerCharacter)) {
Mob pet = ((PlayerCharacter) tarAc).getPet();
Mob pet = ((PlayerCharacter) target).getPet();
if (pet != null && pet.assist && pet.getCombatTarget() == null)
pet.setCombatTarget(ac);
pet.setCombatTarget(attacker);
}
//Handle Mob Retaliate.
if (tarAc.getObjectType() == GameObjectType.Mob) {
if (target.getObjectType() == GameObjectType.Mob) {
Mob retaliater = (Mob) tarAc;
Mob attackedMobile = (Mob) target;
if (retaliater.getCombatTarget() != null && !retaliater.isSiege())
//handle minion informing his captain of an attack
if (attackedMobile.agentType.equals(AIAgentType.GUARDMINION) && attackedMobile.guardCaptain != null && attackedMobile.guardCaptain.isAlive()) {
if (attackedMobile.guardCaptain.combatTarget == null)
attackedMobile.guardCaptain.setCombatTarget(attacker);
}
// Mobile already has a target; don't switch.
if (attackedMobile.getCombatTarget() != null && !attackedMobile.isSiege())
return;
if (ac.getObjectType() == GameObjectType.Mob && retaliater.isSiege())
return;
retaliater.setCombatTarget(ac);
attackedMobile.setCombatTarget(attacker);
}
}
+4 -20
View File
@@ -11,8 +11,6 @@ package engine.gameManager;
import engine.Enum;
import engine.devcmd.AbstractDevCmd;
import engine.devcmd.cmds.*;
import engine.net.DispatchMessage;
import engine.net.client.msg.chat.ChatSystemMsg;
import engine.objects.AbstractGameObject;
import engine.objects.Account;
import engine.objects.PlayerCharacter;
@@ -48,9 +46,11 @@ public enum DevCmdManager {
DevCmdManager.registerDevCmd(new GetZoneCmd());
DevCmdManager.registerDevCmd(new ZoneSetCmd());
DevCmdManager.registerDevCmd(new PrintBankCmd());
DevCmdManager.registerDevCmd(new PrintEffectsCmd());
DevCmdManager.registerDevCmd(new PrintEquipCmd());
DevCmdManager.registerDevCmd(new PrintInventoryCmd());
DevCmdManager.registerDevCmd(new PrintVaultCmd());
DevCmdManager.registerDevCmd(new PrintRunesCmd());
DevCmdManager.registerDevCmd(new PrintStatsCmd());
DevCmdManager.registerDevCmd(new PrintSkillsCmd());
DevCmdManager.registerDevCmd(new PrintPowersCmd());
@@ -121,7 +121,6 @@ public enum DevCmdManager {
DevCmdManager.registerDevCmd(new PurgeObjectsCmd());
DevCmdManager.registerDevCmd(new SplatMobCmd());
DevCmdManager.registerDevCmd(new SlotNpcCmd());
DevCmdManager.registerDevCmd(new setProfit());
DevCmdManager.registerDevCmd(new GateInfoCmd());
DevCmdManager.registerDevCmd(new ShowOffsetCmd());
DevCmdManager.registerDevCmd(new RealmInfoCmd());
@@ -131,7 +130,6 @@ public enum DevCmdManager {
DevCmdManager.registerDevCmd(new SetForceRenameCityCmd());
DevCmdManager.registerDevCmd(new GotoObj());
DevCmdManager.registerDevCmd(new convertLoc());
DevCmdManager.registerDevCmd(new AuditHeightMapCmd());
DevCmdManager.registerDevCmd(new UnloadFurnitureCmd());
DevCmdManager.registerDevCmd(new SetNpcEquipSetCmd());
DevCmdManager.registerDevCmd(new SetBuildingAltitudeCmd());
@@ -146,7 +144,7 @@ public enum DevCmdManager {
DevCmdManager.registerDevCmd(new ApplyBonusCmd());
DevCmdManager.registerDevCmd(new AuditFailedItemsCmd());
DevCmdManager.registerDevCmd(new SlotTestCmd());
DevCmdManager.registerDevCmd(new SeaAuditCmd());
}
private static void registerDevCmd(AbstractDevCmd cmd) {
@@ -182,17 +180,8 @@ public enum DevCmdManager {
//kill any commands not available to everyone on production server
//only admin level can run dev commands on production
if((cmd.toLowerCase().equals("printstats") || cmd.toLowerCase().equals("printresists")) && target.equals(pcSender)){
// execute command;
try {
adc.doCmd(pcSender, argString, target);
} catch (Exception e) {
}
return true;
}
if (a.status.equals(Enum.AccountStatus.ADMIN) == false && a.getUname().toLowerCase().equals("fatboy") == false) {
if (a.status.equals(Enum.AccountStatus.ADMIN) == false) {
Logger.info("Account " + a.getUname() + "attempted to use dev command " + cmd);
return false;
}
@@ -216,11 +205,6 @@ public enum DevCmdManager {
e.printStackTrace();
}
ChatSystemMsg chatMsg = new ChatSystemMsg(null, pcName + " from account: " + accName + " has used Dev Command: " + cmd);
chatMsg.setMessageType(10);
chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
DispatchMessage.dispatchMsgToAll(chatMsg);
return true;
}
+66 -321
View File
@@ -14,11 +14,9 @@ import engine.net.DispatchMessage;
import engine.net.client.msg.ErrorPopupMsg;
import engine.net.client.msg.chat.ChatSystemMsg;
import engine.objects.*;
import engine.server.MBServerStatics;
import org.pmw.tinylog.Logger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.concurrent.ThreadLocalRandom;
@@ -36,11 +34,6 @@ public enum LootManager {
public static HashMap<Integer, ArrayList<ModTableEntry>> _modTables = new HashMap<>();
public static HashMap<Integer, ArrayList<ModTypeTableEntry>> _modTypeTables = new HashMap<>();
public static ArrayList<Integer> vorg_ha_uuids = new ArrayList<>(Arrays.asList(new Integer[]{27580, 27590, 188500, 188510, 188520, 188530, 188540, 188550, 189510}));
public static ArrayList<Integer> vorg_ma_uuids = new ArrayList<>(Arrays.asList(new Integer[]{27570,188900,188910,188920,188930,188940,188950,189500}));
public static ArrayList<Integer> vorg_la_uuids = new ArrayList<>(Arrays.asList(new Integer[]{27550,27560,189100,189110,189120,189130,189140,189150}));
public static ArrayList<Integer> vorg_cloth_uuids = new ArrayList<>(Arrays.asList(new Integer[]{27600,188700,188720,189550,189560}));
// Drop Rates
public static float NORMAL_DROP_RATE;
@@ -75,13 +68,16 @@ public enum LootManager {
public static void GenerateMobLoot(Mob mob) {
//determine if mob is in hotzone
boolean inHotzone = ZoneManager.inHotZone(mob.getLoc());
//iterate the booty sets
if (mob.getMobBase().bootySet != 0 && _bootySetMap.containsKey(mob.getMobBase().bootySet) == true)
RunBootySet(_bootySetMap.get(mob.getMobBase().bootySet), mob);
RunBootySet(_bootySetMap.get(mob.getMobBase().bootySet), mob, inHotzone);
if (mob.bootySet != 0 && _bootySetMap.containsKey(mob.bootySet) == true)
RunBootySet(_bootySetMap.get(mob.bootySet), mob);
RunBootySet(_bootySetMap.get(mob.bootySet), mob, inHotzone);
//lastly, check mobs inventory for godly or disc runes to send a server announcement
for (Item it : mob.getInventory()) {
@@ -89,7 +85,7 @@ public enum LootManager {
ItemBase ib = it.getItemBase();
if(ib == null)
break;
if (ib.getName().toLowerCase().contains("of the gods")) {
if (ib.isDiscRune() || ib.getName().toLowerCase().contains("of the gods")) {
ChatSystemMsg chatMsg = new ChatSystemMsg(null, mob.getName() + " in " + mob.getParentZone().getName() + " has found the " + ib.getName() + ". Are you tough enough to take it?");
chatMsg.setMessageType(10);
chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
@@ -99,105 +95,54 @@ public enum LootManager {
}
private static void RunBootySet(ArrayList<BootySetEntry> entries, Mob mob) {
mob.runeCounter++;
mob.contractCounter++;
float dropRate = NORMAL_DROP_RATE;
//roll the geenric world drop table
if(mob.parentZone.getSafeZone() == 0) {
GenerateLootDrop(mob, 1300);
if(ThreadLocalRandom.current().nextInt(1, 10000) == 5000) {
MobLoot extraLoot = rollForGlass(mob);
if (extraLoot != null) {
mob.getCharItemManager().addItemToInventory(extraLoot);
}
}
}
private static void RunBootySet(ArrayList<BootySetEntry> entries, Mob mob, boolean inHotzone) {
boolean hotzoneWasRan = false;
float dropRate = 1.0f;
// Iterate all entries in this bootySet and process accordingly
for (BootySetEntry bse : entries) {
switch (bse.bootyType) {
case "GOLD":
GenerateGoldDrop(mob, bse);
GenerateGoldDrop(mob, bse, inHotzone);
break;
case "LOOT":
if (ThreadLocalRandom.current().nextInt(1, 100 + 1) < (bse.dropChance * dropRate))
GenerateLootDrop(mob, bse.genTable); //generate normal loot drop
if(ThreadLocalRandom.current().nextInt(1,100) == 50){
MobLoot extraLoot = rollForContract(bse.genTable, mob);
if (extraLoot != null) {
mob.getCharItemManager().addItemToInventory(extraLoot);
if (mob.getSafeZone() == false)
dropRate = LootManager.NORMAL_DROP_RATE;
if (inHotzone == true)
dropRate = LootManager.HOTZONE_DROP_RATE;
if (ThreadLocalRandom.current().nextInt(1, 100 + 1) < (bse.dropChance * dropRate))
GenerateLootDrop(mob, bse.genTable, false); //generate normal loot drop
// Generate hotzone loot if in hotzone
// Only one bite at the hotzone apple per bootyset.
if (inHotzone == true && hotzoneWasRan == false)
if (_genTables.containsKey(bse.genTable + 1) && ThreadLocalRandom.current().nextInt(1, 100 + 1) < (bse.dropChance * dropRate)) {
GenerateLootDrop(mob, bse.genTable + 1, true); //generate loot drop from hotzone table
hotzoneWasRan = true;
}
}
if(ThreadLocalRandom.current().nextInt(1,100) == 50){
MobLoot extraLoot = rollForRune(bse.genTable, mob);
if (extraLoot != null) {
mob.getCharItemManager().addItemToInventory(extraLoot);
}
}
break;
case "ITEM":
GenerateInventoryDrop(mob, bse);
break;
}
}
MobLoot specialDrop = null;
switch(mob.getObjectUUID()) {
case 22595://elf 1
specialDrop = new MobLoot(mob,ItemBase.getItemBase(252134),true);
mob.setFirstName("Melandrach The Blood-Mage");
break;
case 22432: //elf 2
specialDrop = new MobLoot(mob,ItemBase.getItemBase(252135),true);
mob.setFirstName("Kyrtaar The Blood-Mage");
break;
case 22537: //elf 3
specialDrop = new MobLoot(mob,ItemBase.getItemBase(252136),true);
mob.setFirstName("Vamir The Blood-Mage");
break;
case 16387: //human 4 DONE
specialDrop = new MobLoot(mob,ItemBase.getItemBase(252129),true);
mob.setFirstName("Alatar The Blood-Mage");
break;
case 32724:// human 5 GOOD
specialDrop = new MobLoot(mob,ItemBase.getItemBase(252130),true);
mob.setFirstName("Elphaba The Blood-Mage");
break;
case 23379: //human 1 GOOD
specialDrop = new MobLoot(mob,ItemBase.getItemBase(252131),true);
mob.setFirstName("Bavmorda The Blood-Mage");
break;
case 10826: //human 2 REDO
specialDrop = new MobLoot(mob,ItemBase.getItemBase(252132),true);
mob.setFirstName("Draco The Blood-Mage");
break;
case 15929: //human 3 GOOD
specialDrop = new MobLoot(mob,ItemBase.getItemBase(252133),true);
mob.setFirstName("Atlantes The Blood-Mage");
break;
}
if(specialDrop != null) {
mob.setLevel((short) 65);
mob.setSpawnTime(10800);
mob.healthMax = (7500);
mob.setHealth(7500);
ChatSystemMsg chatMsg = new ChatSystemMsg(null, mob.getName() + " in " + mob.getParentZone().getName() + " has found the " + specialDrop.getName() + ". Are you tough enough to take it?");
chatMsg.setMessageType(10);
chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
DispatchMessage.dispatchMsgToAll(chatMsg);
mob.getCharItemManager().addItemToInventory(specialDrop);
mob.setResists(new Resists("Dropper"));
}
}
public static MobLoot getGenTableItem(int genTableID, AbstractCharacter mob) {
public static MobLoot getGenTableItem(int genTableID, AbstractCharacter mob, Boolean inHotzone) {
if (mob == null || _genTables.containsKey(genTableID) == false)
return null;
MobLoot outItem;
int genRoll = ThreadLocalRandom.current().nextInt(1,94 + 1);
int genRoll = ThreadLocalRandom.current().nextInt(1,100 + 1);
GenTableEntry selectedRow = GenTableEntry.rollTable(genTableID, genRoll, 1.0f);
@@ -215,7 +160,7 @@ public enum LootManager {
if(mob.getObjectType().ordinal() == 52) { //52 = player character
itemTableRoll = ThreadLocalRandom.current().nextInt(1,320 + 1);
} else{
itemTableRoll = TableRoll(mob.level);
itemTableRoll = TableRoll(mob.level, inHotzone);
}
ItemTableEntry tableRow = ItemTableEntry.rollTable(itemTableId, itemTableRoll);
if (tableRow == null)
@@ -227,10 +172,7 @@ public enum LootManager {
return null;
if (ItemBase.getItemBase(itemUUID).getType().ordinal() == Enum.ItemType.RESOURCE.ordinal()) {
int chance = ThreadLocalRandom.current().nextInt(1,101);
if(chance > 10)
return null;
int amount = ThreadLocalRandom.current().nextInt((int)(tableRow.minSpawn * 0.5f), (int)((tableRow.maxSpawn + 1) * 0.5f));
int amount = ThreadLocalRandom.current().nextInt(tableRow.minSpawn, tableRow.maxSpawn + 1);
return new MobLoot(mob, ItemBase.getItemBase(itemUUID), amount, false);
}
@@ -240,7 +182,7 @@ public enum LootManager {
if(selectedRow.pModTable != 0){
try {
outItem = GeneratePrefix(mob, outItem, genTableID, genRoll);
outItem = GeneratePrefix(mob, outItem, genTableID, genRoll, inHotzone);
outItem.setIsID(false);
} catch (Exception e) {
Logger.error("Failed to GeneratePrefix for item: " + outItem.getName());
@@ -248,7 +190,7 @@ public enum LootManager {
}
if(selectedRow.sModTable != 0){
try {
outItem = GenerateSuffix(mob, outItem, genTableID, genRoll);
outItem = GenerateSuffix(mob, outItem, genTableID, genRoll, inHotzone);
outItem.setIsID(false);
} catch (Exception e) {
Logger.error("Failed to GenerateSuffix for item: " + outItem.getName());
@@ -257,7 +199,7 @@ public enum LootManager {
return outItem;
}
private static MobLoot GeneratePrefix(AbstractCharacter mob, MobLoot inItem, int genTableID, int genRoll) {
private static MobLoot GeneratePrefix(AbstractCharacter mob, MobLoot inItem, int genTableID, int genRoll, Boolean inHotzone) {
GenTableEntry selectedRow = GenTableEntry.rollTable(genTableID, genRoll, 1.0f);
@@ -274,7 +216,7 @@ public enum LootManager {
if(mob.getObjectType().ordinal() == 52) {
prefixTableRoll = ThreadLocalRandom.current().nextInt(1,320 + 1);
} else{
prefixTableRoll = TableRoll(mob.level);
prefixTableRoll = TableRoll(mob.level, inHotzone);
}
ModTableEntry prefixMod = ModTableEntry.rollTable(prefixTable.modTableID, prefixTableRoll);
@@ -289,7 +231,7 @@ public enum LootManager {
return inItem;
}
private static MobLoot GenerateSuffix(AbstractCharacter mob, MobLoot inItem, int genTableID, int genRoll) {
private static MobLoot GenerateSuffix(AbstractCharacter mob, MobLoot inItem, int genTableID, int genRoll, Boolean inHotzone) {
GenTableEntry selectedRow = GenTableEntry.rollTable(genTableID, genRoll, 1.0f);
@@ -306,7 +248,7 @@ public enum LootManager {
if(mob.getObjectType().ordinal() == 52) {
suffixTableRoll = ThreadLocalRandom.current().nextInt(1,320 + 1);
} else{
suffixTableRoll = TableRoll(mob.level);
suffixTableRoll = TableRoll(mob.level, inHotzone);
}
ModTableEntry suffixMod = ModTableEntry.rollTable(suffixTable.modTableID, suffixTableRoll);
@@ -321,7 +263,7 @@ public enum LootManager {
return inItem;
}
public static int TableRoll(int mobLevel) {
public static int TableRoll(int mobLevel, Boolean inHotzone) {
if (mobLevel > 65)
mobLevel = 65;
@@ -336,12 +278,15 @@ public enum LootManager {
if (min < 70)
min = 70;
if (inHotzone)
min += mobLevel;
int roll = ThreadLocalRandom.current().nextInt(min, max + 1);
return roll;
}
public static void GenerateGoldDrop(Mob mob, BootySetEntry bse) {
public static void GenerateGoldDrop(Mob mob, BootySetEntry bse, Boolean inHotzone) {
int chanceRoll = ThreadLocalRandom.current().nextInt(1, 100 + 1);
@@ -352,9 +297,14 @@ public enum LootManager {
//determine and add gold to mob inventory
int high = (int)(bse.highGold * NORMAL_GOLD_RATE);
int low = (int)(bse.lowGold * NORMAL_GOLD_RATE);
int gold = ThreadLocalRandom.current().nextInt(low, high);
int high = bse.highGold;
int low = bse.lowGold;
int gold = ThreadLocalRandom.current().nextInt(low, high + 1);
if (inHotzone == true)
gold = (int) (gold * HOTZONE_GOLD_RATE);
else
gold = (int) (gold * NORMAL_GOLD_RATE);
if (gold > 0) {
MobLoot goldAmount = new MobLoot(mob, gold);
@@ -363,31 +313,25 @@ public enum LootManager {
}
public static void GenerateLootDrop(Mob mob, int tableID) {
public static void GenerateLootDrop(Mob mob, int tableID, Boolean inHotzone) {
try {
if(mob.parentZone.getSafeZone() == 1) {
return;
}
MobLoot toAdd = getGenTableItem(tableID, mob);
if(toAdd.getItemBase().getType().equals(Enum.ItemType.CONTRACT) || toAdd.getItemBase().getType().equals(Enum.ItemType.RUNE))
return;//block all contracts and runes that drop outside the confines of the new system
if (toAdd != null) {
toAdd.setIsID(true);
MobLoot toAdd = getGenTableItem(tableID, mob, inHotzone);
if (toAdd != null)
mob.getCharItemManager().addItemToInventory(toAdd);
}
} catch (Exception e) {
//TODO chase down loot generation error, affects roughly 2% of drops
int i = 0;
}
}
public static void GenerateEquipmentDrop(Mob mob) {
if(mob.parentZone.getSafeZone() == 1) {
return;
}
if(mob.behaviourType.equals(Enum.MobBehaviourType.HamletGuard))
return; // safehold guards don't drop their equipment
//do equipment here
int dropCount = 0;
if (mob.getEquip() != null)
@@ -398,64 +342,25 @@ public enum LootManager {
float equipmentRoll = ThreadLocalRandom.current().nextInt(1, 100 + 1);
float dropChance = me.getDropChance() * 100;
if (equipmentRoll > dropChance)
continue;
ItemBase genericIB = me.getItemBase();
if(genericIB.isVorg()){
if(genericIB.isClothArmor()){
//get random cloth piece
genericIB = getRandomVorgCloth();//ItemBase.getItemBase(vorg_cloth_uuids.get(ThreadLocalRandom.current().nextInt(0,vorg_cloth_uuids.size() - 1)));
} else if(genericIB.isHeavyArmor()){
//get random heavy armor piece
genericIB = getRandomVorgHA();//ItemBase.getItemBase(vorg_ha_uuids.get(ThreadLocalRandom.current().nextInt(0,vorg_ha_uuids.size() - 1)));
} else if(genericIB.isMediumArmor()){
//get random medium armor piece
genericIB = getRandomVorgMA();//ItemBase.getItemBase(vorg_ma_uuids.get(ThreadLocalRandom.current().nextInt(0,vorg_ma_uuids.size() - 1)));
} else if(genericIB.isLightArmor()){
//get random light armor piece
genericIB = getRandomVorgLA();//ItemBase.getItemBase(vorg_la_uuids.get(ThreadLocalRandom.current().nextInt(0,vorg_la_uuids.size() - 1)));
}
mob.spawnTime = ThreadLocalRandom.current().nextInt(300,2700);
}
MobLoot ml = new MobLoot(mob, genericIB, false);
if (ml != null && dropCount < 1 && genericIB.isVorg() == false) {
MobLoot ml = new MobLoot(mob, me.getItemBase(), false);
if (ml != null && dropCount < 1) {
ml.setIsID(true);
ml.setDurabilityCurrent((short) (ml.getDurabilityCurrent() - ThreadLocalRandom.current().nextInt(5) + 1));
mob.getCharItemManager().addItemToInventory(ml);
dropCount = 1;
//break; // Exit on first successful roll.
}
if(ml != null && genericIB.isVorg() && mob.getMobBaseID() != 14062){
ml.setIsID(true);
ml.setDurabilityCurrent(ml.getDurabilityMax());
mob.getCharItemManager().addItemToInventory(ml);
}
}
}
public static void GenerateInventoryDrop(Mob mob, BootySetEntry bse) {
if(ItemBase.getItemBase(bse.itemBase).isDiscRune()) {
if(!Mob.disciplineDroppers.contains(mob))
Mob.disciplineDroppers.add(mob);
mob.setResists(new Resists("Dropper"));
ChatSystemMsg chatMsg = new ChatSystemMsg(null, mob.getName() + " in " + mob.getParentZone().getName() + " has found the " + ItemBase.getItemBase(bse.itemBase).getName() + ". Are you tough enough to take it?");
chatMsg.setMessageType(10);
chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
DispatchMessage.dispatchMsgToAll(chatMsg);
}
//if((bse.itemBase == 3040 || bse.itemBase == 3021) && mob.level < 80){
// chance = 100;
//}
if(mob.parentZone.getSafeZone() == 1) {
return;
}
int chanceRoll = ThreadLocalRandom.current().nextInt(1, 99);
int chanceRoll = ThreadLocalRandom.current().nextInt(1, 100 + 1);
//early exit, failed to hit minimum chance roll
@@ -551,164 +456,4 @@ public enum LootManager {
itemMan.addItemToInventory(playerWinnings);
itemMan.updateInventory();
}
public static MobLoot rollForContract(int table, Mob mob){
int roll = 99;
if (table == 1900 || table == 1500)
roll = 73;
GenTableEntry selectedRow = GenTableEntry.rollTable(table, roll, 1.0f);
if (selectedRow == null)
return null;
int itemTableId = selectedRow.itemTableID;
if (_itemTables.containsKey(itemTableId) == false)
return null;
ItemTableEntry tableRow = ItemTableEntry.rollTable(itemTableId, ThreadLocalRandom.current().nextInt(75,321));
if (tableRow == null)
return null;
int itemUUID = tableRow.cacheID;
if (itemUUID == 0)
return null;
MobLoot outItem = new MobLoot(mob, ItemBase.getItemBase(itemUUID), false);
if(outItem != null) {
mob.contractCounter = ThreadLocalRandom.current().nextInt(200);
ChatSystemMsg chatMsg = new ChatSystemMsg(null, mob.getName() + " looks like he found something special");
chatMsg.setMessageType(10);
chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
DispatchMessage.dispatchMsgToInterestArea(mob,chatMsg, Enum.DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE,false,false);
return outItem;
}
return null;
}
public static MobLoot rollForRune(int table, Mob mob){
int roll = 97;
if(table == 1900 || table == 1500){
roll = 77;
}
GenTableEntry selectedRow = GenTableEntry.rollTable(table, roll, 1.0f);
if (selectedRow == null)
return null;
int itemTableId = selectedRow.itemTableID;
if (_itemTables.containsKey(itemTableId) == false)
return null;
ItemTableEntry tableRow = ItemTableEntry.rollTable(itemTableId, ThreadLocalRandom.current().nextInt(75,321));
if (tableRow == null)
return null;
int itemUUID = tableRow.cacheID;
if (itemUUID == 0)
return null;
MobLoot outItem = new MobLoot(mob, ItemBase.getItemBase(itemUUID), false);
if(outItem != null) {
mob.runeCounter = ThreadLocalRandom.current().nextInt(200);
ChatSystemMsg chatMsg = new ChatSystemMsg(null, mob.getName() + " looks like he found something special");
chatMsg.setMessageType(10);
chatMsg.setChannel(Enum.ChatChannelType.SYSTEM.getChannelID());
DispatchMessage.dispatchMsgToInterestArea(mob,chatMsg, Enum.DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE,false,false);
return outItem;
}
return null;
}
public static MobLoot rollForGlass( Mob mob){
ItemTableEntry tableRow = ItemTableEntry.rollTable(126, ThreadLocalRandom.current().nextInt(220,321));
if (tableRow == null)
return null;
int itemUUID = tableRow.cacheID;
if (itemUUID == 0)
return null;
MobLoot outItem = new MobLoot(mob, ItemBase.getItemBase(itemUUID), false);
if(outItem != null)
return outItem;
return null;
}
public static ItemBase getRandomVorgCloth(){
int random = ThreadLocalRandom.current().nextInt(100);
if(random < 20)
return ItemBase.getItemBase(27600);
if(random > 20 && random < 40)
return ItemBase.getItemBase(188700);
if(random > 40 && random < 60)
return ItemBase.getItemBase(188720);
if(random > 60 && random < 80)
return ItemBase.getItemBase(189550);
if(random > 80)
return ItemBase.getItemBase(189560);
return null;
}
public static ItemBase getRandomVorgLA(){
int random = ThreadLocalRandom.current().nextInt(160);
if(random < 20)
return ItemBase.getItemBase(27550);
if(random > 20 && random < 40)
return ItemBase.getItemBase(27560);
if(random > 40 && random < 60)
return ItemBase.getItemBase(189100);
if(random > 60 && random < 80)
return ItemBase.getItemBase(189110);
if(random > 80 && random < 100)
return ItemBase.getItemBase(189120);
if(random > 100 && random < 120)
return ItemBase.getItemBase(189130);
if(random > 120 && random < 140)
return ItemBase.getItemBase(189140);
if(random > 140)
return ItemBase.getItemBase(189150);
return null;
}
public static ItemBase getRandomVorgMA(){
int random = ThreadLocalRandom.current().nextInt(160);
if(random < 20)
return ItemBase.getItemBase(27570);
if(random > 20 && random < 40)
return ItemBase.getItemBase(188900);
if(random > 40 && random < 60)
return ItemBase.getItemBase(188910);
if(random > 60 && random < 80)
return ItemBase.getItemBase(188920);
if(random > 80 && random < 100)
return ItemBase.getItemBase(188930);
if(random > 100 && random < 120)
return ItemBase.getItemBase(188940);
if(random > 120 && random < 140)
return ItemBase.getItemBase(188950);
if(random > 140)
return ItemBase.getItemBase(189500);
return null;
}
public static ItemBase getRandomVorgHA(){
int random = ThreadLocalRandom.current().nextInt(180);
if(random < 20)
return ItemBase.getItemBase(27580);
if(random > 20 && random < 40)
return ItemBase.getItemBase(27590);
if(random > 40 && random < 60)
return ItemBase.getItemBase(188500);
if(random > 60 && random < 80)
return ItemBase.getItemBase(188510);
if(random > 80 && random < 100)
return ItemBase.getItemBase(188520);
if(random > 100 && random < 120)
return ItemBase.getItemBase(188530);
if(random > 120 && random < 140)
return ItemBase.getItemBase(188540);
if(random > 140 && random < 160)
return ItemBase.getItemBase(188550);
if(random > 160)
return ItemBase.getItemBase(189510);
return null;
}
}
+295 -181
View File
@@ -5,206 +5,320 @@
// · · ·
// Magicbane Emulator Project © 2013 - 2022
// www.magicbane.com
package engine.gameManager;
// Defines static methods which comprise the magicbane
// building maintenance system.
import engine.Enum;
import engine.objects.*;
import org.pmw.tinylog.Logger;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.concurrent.ConcurrentHashMap;
public enum MaintenanceManager {
MAINTENANCEMANAGER;
public static void setMaintDateTime(Building building, LocalDateTime maintDate) {
building.maintDateTime = maintDate;
DbManager.BuildingQueries.updateMaintDate(building);
}
public static void processBuildingMaintenance() {
ArrayList<AbstractGameObject> buildingList;
ArrayList<Building> maintList;
ArrayList<Building> derankList = new ArrayList<>();
Logger.info("Starting Maintenance on Player Buildings");
// Build list of buildings to apply maintenance on.
buildingList = new ArrayList(DbManager.getList(Enum.GameObjectType.Building));
maintList = buildMaintList(buildingList);
// Deduct upkeep and build list of buildings
// which did not have funds available
for (Building building : maintList) {
if (chargeUpkeep(building) == false)
derankList.add(building);
}
// Reset maintenance dates for these buildings
for (Building building : maintList) {
setMaintDateTime(building, LocalDateTime.now().plusDays(7));
}
// Derak or destroy buildings that did not
// have funds available.
for (Building building : derankList)
building.destroyOrDerank(null);
Logger.info("Structures: " + buildingList.size() + " Maint: " + maintList.size() + " Derank: " + derankList.size());
}
// Iterate over all buildings in game and apply exclusion rules
// returning a list of building for which maintenance is due.
private static ArrayList<Building> buildMaintList(ArrayList<AbstractGameObject> buildingList) {
ArrayList<Building> maintList = new ArrayList<>();
for (AbstractGameObject gameObject : buildingList) {
Building building = (Building) gameObject;
// No maintenance on NPC owned buildings (Cache loaded)
if (building.getProtectionState() == Enum.ProtectionState.NPC)
continue;
// No maintenance on constructing meshes
if (building.getRank() < 1)
continue;
// No Maintenance on furniture
if (building.parentBuildingID != 0)
continue;
// No Blueprint?
if (building.getBlueprint() == null) {
Logger.error("Blueprint missing for uuid: " + building.getObjectUUID());
continue;
}
// No maintenance on banestones omfg
if (building.getBlueprint().getBuildingGroup().equals(Enum.BuildingGroup.BANESTONE))
continue;
// no maintenance on Mines omfg
if (building.getBlueprint().getBuildingGroup().equals(Enum.BuildingGroup.MINE))
continue;
// Null Maintenance date?
if (building.maintDateTime == null) {
Logger.error("Null maint date for building UUID: " + building.getObjectUUID());
continue;
}
// Maintenance date is in the future
if (building.maintDateTime.isAfter(LocalDateTime.now()))
continue;
//no maintenance if day of week doesnt match
if (LocalDateTime.now().getDayOfWeek().ordinal() != building.maintDateTime.getDayOfWeek().ordinal()) {
continue;
}
// Add building to maintenance queue
maintList.add(building);
}
return maintList;
}
// Method removes the appropriate amount of gold/resources from
// a building according to it's maintenance schedule. True/False
// is returned indicating if the building had enough funds to cover.
public static boolean chargeUpkeep(Building building) {
City city = null;
Warehouse warehouse = null;
int maintCost = 0;
int overDraft = 0;
boolean hasFunds = false;
boolean hasResources = false;
int resourceValue = 0;
city = building.getCity();
if (city != null)
warehouse = city.getWarehouse();
// Cache maintenance cost value
maintCost = building.getMaintCost();
// Something went wrong. Missing buildinggroup from switch?
if (maintCost == 0) {
Logger.error("chargeUpkeep", "Error retrieving rankcost for " + building.getName() + " uuid:" + building.getObjectUUID() + "buildinggroup:" + building.getBlueprint().getBuildingGroup().name());
// check if there is enough gold on the building
return true;
}
if (building.getStrongboxValue() >= maintCost)
hasFunds = true;
// If we cannot cover with just the strongbox
// see if there is a warehouse that will cover
// the overdraft for us.
if (hasFunds == false && (building.assetIsProtected() || building.getBlueprint().getBuildingGroup() == Enum.BuildingGroup.WAREHOUSE)) {
overDraft = maintCost - building.getStrongboxValue();
}
if ((overDraft > 0))
if ((building.getBlueprint().getBuildingGroup().equals(Enum.BuildingGroup.SHRINE) == false) &&
(warehouse != null) && building.assetIsProtected() == true &&
(warehouse.getResources().get(ItemBase.GOLD_ITEM_BASE)) >= overDraft) {
hasFunds = true;
}
// If this is an R8 tree, validate that we can
// cover the resources required
if (building.getRank() == 8) {
hasResources = true;
if (warehouse == null)
hasResources = false;
else {
resourceValue = warehouse.getResources().get(Warehouse.stoneIB);
if (resourceValue < 1500)
hasResources = false;
resourceValue = warehouse.getResources().get(Warehouse.lumberIB);
if (resourceValue < 1500)
hasResources = false;
resourceValue = warehouse.getResources().get(Warehouse.galvorIB);
if (resourceValue < 5)
hasResources = false;
resourceValue = warehouse.getResources().get(Warehouse.wormwoodIB);
if (resourceValue < 5)
hasResources = false;
}
}
// Validation completed but has failed. We can derank
// the target building and early exit
if ((hasFunds == false) ||
((building.getRank() == 8) && !hasResources)) {
// Add cash back to strongbox for lost rank if the building isn't being destroyed
// and it's not an R8 deranking
if ((building.getRank() > 1) && (building.getRank() < 8)) {
building.setStrongboxValue(building.getStrongboxValue() + building.getBlueprint().getRankCost(Math.min(building.getRank(), 7)));
}
return false; // Early exit for having failed to meet maintenance
}
// Remove cash and resources
// withdraw what we can from the building
building.setStrongboxValue(building.getStrongboxValue() - (maintCost - overDraft));
// withdraw overdraft from the whorehouse
if (overDraft > 0) {
resourceValue = warehouse.getResources().get(Warehouse.goldIB);
if (DbManager.WarehouseQueries.updateGold(warehouse, resourceValue - overDraft) == true) {
warehouse.getResources().put(Warehouse.goldIB, resourceValue - overDraft);
warehouse.AddTransactionToWarehouse(Enum.GameObjectType.Building, building.getObjectUUID(), Enum.TransactionType.WITHDRAWL, Resource.GOLD, overDraft);
} else {
Logger.error("gold update failed for warehouse of UUID:" + warehouse.getObjectUUID());
return true;
}
}
// Early exit as we're done if we're not an R8 tree
if (building.getRank() < 8)
return true;
// Now for the resources if it's an R8 tree
// Withdraw Stone
resourceValue = warehouse.getResources().get(Warehouse.stoneIB);
if (DbManager.WarehouseQueries.updateStone(warehouse, resourceValue - 1500) == true) {
warehouse.getResources().put(Warehouse.stoneIB, resourceValue - 1500);
warehouse.AddTransactionToWarehouse(Enum.GameObjectType.Building, building.getObjectUUID(), Enum.TransactionType.WITHDRAWL, Resource.STONE, 1500);
} else {
Logger.error("stone update failed for warehouse of UUID:" + warehouse.getObjectUUID());
return true;
}
// Withdraw Lumber
resourceValue = warehouse.getResources().get(Warehouse.lumberIB);
if (DbManager.WarehouseQueries.updateLumber(warehouse, resourceValue - 1500) == true) {
warehouse.getResources().put(Warehouse.lumberIB, resourceValue - 1500);
warehouse.AddTransactionToWarehouse(Enum.GameObjectType.Building, building.getObjectUUID(), Enum.TransactionType.WITHDRAWL, Resource.LUMBER, 1500);
} else {
Logger.error("lumber update failed for warehouse of UUID:" + warehouse.getObjectUUID());
return true;
}
// Withdraw Galvor
resourceValue = warehouse.getResources().get(Warehouse.galvorIB);
if (DbManager.WarehouseQueries.updateGalvor(warehouse, resourceValue - 5) == true) {
warehouse.getResources().put(Warehouse.galvorIB, resourceValue - 5);
warehouse.AddTransactionToWarehouse(Enum.GameObjectType.Building, building.getObjectUUID(), Enum.TransactionType.WITHDRAWL, Resource.GALVOR, 5);
} else {
Logger.error("galvor update failed for warehouse of UUID:" + warehouse.getObjectUUID());
return true;
}
resourceValue = warehouse.getResources().get(Warehouse.wormwoodIB);
if (DbManager.WarehouseQueries.updateWormwood(warehouse, resourceValue - 5) == true) {
warehouse.getResources().put(Warehouse.wormwoodIB, resourceValue - 5);
warehouse.AddTransactionToWarehouse(Enum.GameObjectType.Building, building.getObjectUUID(), Enum.TransactionType.WITHDRAWL, Resource.WORMWOOD, 5);
} else {
Logger.error("wyrmwood update failed for warehouse of UUID:" + warehouse.getObjectUUID());
}
return true;
}
public static void dailyMaintenance() {
Logger.info("Maintenance has started");
// Run maintenance on player buildings
if (ConfigManager.MB_WORLD_MAINTENANCE.getValue().equalsIgnoreCase("true"))
processMaintenance();
processBuildingMaintenance();
else
Logger.info("Maintenance Costings: DISABLED");
Logger.info("Maintenance has completed!");
}
public static void processMaintenance() {
//create list of all cities
ConcurrentHashMap<Integer, AbstractGameObject> worldCities = DbManager.getMap(Enum.GameObjectType.City);
//loop all cities
for (AbstractGameObject ago : worldCities.values()) {
if (ago.getObjectType().equals(Enum.GameObjectType.City)) {
City city = (City) ago;
if(city == null || !city.getParent().isPlayerCity())
continue;
Building tol = city.getTOL();
if(tol == null)
continue;
LocalDateTime maintenanceDueDate = tol.maintDateTime.withHour(1).withMinute(0).withSecond(0);
LocalDateTime now = LocalDateTime.now();
if(now.isAfter(maintenanceDueDate))
processTolMaintenance(tol, city.getWarehouse());
}
}
}
public static void processTolMaintenance(Building tol, Warehouse warehouse){
if(tol == null)
return;
if(tol.getRank() == 8)
handleR8(tol,warehouse);
else
handleNormal(tol,warehouse);
}
public static void handleNormal(Building tol, Warehouse warehouse){
//handle r7 and lower ToL maintenance
int goldDue = 3000000;
//enough on strongbox alone to pay
if (tol.getStrongboxValue() >= goldDue) {
tol.maintDateTime = LocalDateTime.now().plusDays(7);
if(DbManager.BuildingQueries.updateMaintDate(tol)) {
tol.setStrongboxValue(tol.getStrongboxValue() - goldDue);
}
return;
}
int newStrongboxValue = tol.getStrongboxValue();
int newWarehouseGold = 0;
if(warehouse != null && warehouse.getResources().get(ItemBase.getItemBase(7)) != null) {
newWarehouseGold = warehouse.getResources().get(ItemBase.getItemBase(7));
} else{
//wasnt enough on strongbox and gold in warehouse is empty
tol.maintDateTime = LocalDateTime.now().plusDays(1);
if(DbManager.BuildingQueries.updateMaintDate(tol)) {
tol.destroyOrDerank(null);
}
return;
}
//some on strongbox to pay
if (tol.getStrongboxValue() > 0) {
newStrongboxValue = 0;
goldDue -= tol.getStrongboxValue();
}
if(newWarehouseGold < goldDue){
//not enough gold to pay, you miss maintenance
tol.maintDateTime = LocalDateTime.now().plusDays(1);
if(DbManager.BuildingQueries.updateMaintDate(tol)) {
tol.destroyOrDerank(null);
}
return;
}
newWarehouseGold -= goldDue;
tol.maintDateTime = LocalDateTime.now().plusDays(7);
if(DbManager.BuildingQueries.updateMaintDate(tol) && DbManager.WarehouseQueries.updateGold(warehouse,newWarehouseGold)) {
warehouse.getResources().put(ItemBase.getItemBase(7), newWarehouseGold);
tol.setStrongboxValue(newStrongboxValue);
}
}
public static void handleR8(Building tol, Warehouse warehouse){
//handle r8 ToL maintenance
//cannot pay r8 maintenance without a warehouse
if(warehouse == null && DbManager.BuildingQueries.updateMaintDate(tol)) {
tol.destroyOrDerank(null);
tol.maintDateTime = LocalDateTime.now().plusDays(1);
return;
}
//handle resource processing
int goldDue = 3000000;
int galvorDue = 5;
int wormwoodDue = 5;
int stoneDue = 5000;
int lumberDue = 5000;
int goldStrongBox = tol.getStrongboxValue();
int goldWarehouse = 0;
int galvorWarehouse;
int wormwoodWarehouse;
int stoneWarehouse;
int lumberWarehouse;
if(warehouse.getResources().get(Warehouse.galvorIB) != null) {
galvorWarehouse = warehouse.getResources().get(Warehouse.galvorIB);
}else {
tol.maintDateTime = LocalDateTime.now().plusDays(1);
if(DbManager.BuildingQueries.updateMaintDate(tol)) {
tol.destroyOrDerank(null);
}
return;
}
if(warehouse.getResources().get(Warehouse.stoneIB) != null) {
stoneWarehouse = warehouse.getResources().get(Warehouse.stoneIB);
}else {
tol.maintDateTime = LocalDateTime.now().plusDays(1);
if(DbManager.BuildingQueries.updateMaintDate(tol)) {
tol.destroyOrDerank(null);
}
return;
}
if(warehouse.getResources().get(Warehouse.wormwoodIB) != null) {
wormwoodWarehouse = warehouse.getResources().get(Warehouse.wormwoodIB);
}else {
tol.maintDateTime = LocalDateTime.now().plusDays(1);
if(DbManager.BuildingQueries.updateMaintDate(tol)) {
tol.destroyOrDerank(null);
}
return;
}
if(warehouse.getResources().get(Warehouse.lumberIB) != null) {
lumberWarehouse = warehouse.getResources().get(Warehouse.lumberIB);
}else {
tol.maintDateTime = LocalDateTime.now().plusDays(1);
if(DbManager.BuildingQueries.updateMaintDate(tol)) {
tol.destroyOrDerank(null);
}
return;
}
boolean canPay = true;
if(goldStrongBox >= goldDue){
goldStrongBox -= goldDue;
goldDue = 0;
}
if (tol.getStrongboxValue() > 0) {
goldStrongBox = 0;
goldDue -= tol.getStrongboxValue();
}
if(warehouse.getResources().get(Warehouse.goldIB) != null) {
goldWarehouse = warehouse.getResources().get(Warehouse.goldIB);
}else if(goldDue > 0){
tol.maintDateTime = LocalDateTime.now().plusDays(1);
if(DbManager.BuildingQueries.updateMaintDate(tol)) {
tol.destroyOrDerank(null);
}
return;
}
if(wormwoodDue > wormwoodWarehouse)
canPay = false;
if(galvorDue > galvorWarehouse)
canPay = false;
if(lumberDue > lumberWarehouse)
canPay = false;
if(stoneDue > stoneWarehouse)
canPay = false;
if(goldDue > goldWarehouse)
canPay = false;
if(!canPay){
tol.maintDateTime = LocalDateTime.now().plusDays(1);
if(DbManager.BuildingQueries.updateMaintDate(tol)) {
tol.destroyOrDerank(null);
}
return;
}
tol.setStrongboxValue(goldStrongBox);
if(DbManager.WarehouseQueries.updateGold(warehouse,goldWarehouse - goldDue)){
if(DbManager.WarehouseQueries.updateStone(warehouse,stoneWarehouse - stoneDue)){
if(DbManager.WarehouseQueries.updateLumber(warehouse,lumberWarehouse - lumberDue)){
if(DbManager.WarehouseQueries.updateGalvor(warehouse,galvorWarehouse - galvorDue)){
if(DbManager.WarehouseQueries.updateWormwood(warehouse,wormwoodWarehouse - wormwoodDue)){
tol.maintDateTime = LocalDateTime.now().plusDays(1);
if(DbManager.BuildingQueries.updateMaintDate(tol)) {
return;
}
}
}
}
}
}
}
}
}
+12 -14
View File
@@ -69,10 +69,9 @@ public enum MovementManager {
if (toMove.getObjectType().equals(GameObjectType.PlayerCharacter)) {
if (((PlayerCharacter) toMove).isCasting())
((PlayerCharacter) toMove).update();
if(((PlayerCharacter) toMove).isFlying() && toMove.getEffects().containsKey("MoveBuff"))
PlayerCharacter.GroundPlayer(((PlayerCharacter) toMove));
}
toMove.setIsCasting(false);
toMove.setItemCasting(false);
@@ -117,8 +116,8 @@ public enum MovementManager {
// if inside a building, convert both locations from the building local reference frame to the world reference frame
if (msg.getTargetID() > 0) {
Building building = BuildingManager.getBuildingFromCache(msg.getTargetID());
if (msg.getInBuildingUUID() > 0) {
Building building = BuildingManager.getBuildingFromCache(msg.getInBuildingUUID());
if (building != null) {
Vector3fImmutable convertLocEnd = new Vector3fImmutable(ZoneManager.convertLocalToWorld(building, endLocation));
@@ -129,8 +128,8 @@ public enum MovementManager {
// }
// else {
toMove.setInBuilding(msg.getInBuilding());
toMove.setInFloorID(msg.getUnknown01());
toMove.setInBuildingID(msg.getTargetID());
toMove.setInFloorID(msg.getInBuildingFloor());
toMove.setInBuildingID(msg.getInBuildingUUID());
msg.setStartCoord(ZoneManager.convertWorldToLocal(building, toMove.getLoc()));
if (toMove.getObjectType() == GameObjectType.PlayerCharacter) {
@@ -175,9 +174,9 @@ public enum MovementManager {
msg.setStartCoord(ZoneManager.convertWorldToLocal(Regions.GetBuildingForRegion(toMove.region), toMove.getLoc()));
msg.setEndCoord(ZoneManager.convertWorldToLocal(regionBuilding, endLocation));
msg.setInBuilding(toMove.region.level);
msg.setUnknown01(toMove.region.room);
msg.setTargetType(GameObjectType.Building.ordinal());
msg.setTargetID(regionBuilding.getObjectUUID());
msg.setInBuildingFloor(toMove.region.room);
msg.setStartLocType(GameObjectType.Building.ordinal());
msg.setInBuildingUUID(regionBuilding.getObjectUUID());
}
} else {
@@ -186,8 +185,8 @@ public enum MovementManager {
toMove.setInBuilding(-1);
msg.setStartCoord(toMove.getLoc());
msg.setEndCoord(endLocation);
msg.setTargetType(0);
msg.setTargetID(0);
msg.setStartLocType(0);
msg.setInBuildingUUID(0);
}
//checks sync between character and server, if out of sync, teleport player to original position and return.
@@ -234,7 +233,7 @@ public enum MovementManager {
toMove.cancelOnMove();
//cancel any attacks for manual move.
if ((toMove.getObjectType() == GameObjectType.PlayerCharacter) && msg.getUnknown02() == 0)
if ((toMove.getObjectType() == GameObjectType.PlayerCharacter) && msg.getInitiatedFromAttack() == 0)
toMove.setCombatTarget(null);
@@ -465,7 +464,7 @@ public enum MovementManager {
}
}
public static void translocate(AbstractCharacter teleporter, Vector3fImmutable targetLoc, Regions region) {
public static void translocate(AbstractCharacter teleporter, Vector3fImmutable targetLoc) {
if (targetLoc == null)
@@ -474,7 +473,6 @@ public enum MovementManager {
Vector3fImmutable oldLoc = new Vector3fImmutable(teleporter.getLoc());
teleporter.stopMovement(targetLoc);
teleporter.setRegion(region);
//mobs ignore region sets for now.
if (teleporter.getObjectType().equals(GameObjectType.Mob)) {
+231 -181
View File
@@ -5,13 +5,17 @@ import engine.InterestManagement.WorldGrid;
import engine.math.Quaternion;
import engine.math.Vector3f;
import engine.math.Vector3fImmutable;
import engine.mobileAI.MobAI;
import engine.net.Dispatch;
import engine.net.DispatchMessage;
import engine.net.client.msg.PetMsg;
import engine.objects.*;
import engine.powers.EffectsBase;
import engine.powers.PowersBase;
import engine.powers.RuneSkillAdjustEntry;
import org.pmw.tinylog.Logger;
import javax.smartcardio.ATR;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.concurrent.ThreadLocalRandom;
@@ -23,84 +27,6 @@ public enum NPCManager {
NPC_MANAGER;
public static HashMap<Integer, ArrayList<Integer>> _runeSetMap = new HashMap<>();
public static void applyRuneSetEffects(Mob mob) {
// Early exit
if (mob.runeSet == 0)
return;
//Apply all rune effects.
if (NPCManager._runeSetMap.get(mob.runeSet).contains(252623)) {
mob.isPlayerGuard = true;
}
// Only captains have contracts
if (mob.contract != null || mob.isPlayerGuard)
applyEffectsForRune(mob, 252621);
// Apply effects from RuneSet
if (mob.runeSet != 0)
for (int runeID : _runeSetMap.get(mob.runeSet))
applyEffectsForRune(mob, runeID);
// Not sure why but apply Warrior effects for some reason?
applyEffectsForRune(mob, 2518);
}
public static void applyEffectsForRune(AbstractCharacter character, int runeID) {
EffectsBase effectsBase;
RuneBase sourceRune = RuneBase.getRuneBase(runeID);
// Race runes are in the runeset but not in runebase for some reason
if (sourceRune == null)
return;
for (MobBaseEffects mbe : sourceRune.getEffectsList()) {
effectsBase = PowersManager.getEffectByToken(mbe.getToken());
if (effectsBase == null) {
Logger.info("Mob: " + character.getObjectUUID() + " EffectsBase Null for Token " + mbe.getToken());
continue;
}
//check to upgrade effects if needed.
if (character.effects.containsKey(Integer.toString(effectsBase.getUUID()))) {
if (mbe.getReqLvl() > (int) character.level)
continue;
Effect eff = character.effects.get(Integer.toString(effectsBase.getUUID()));
if (eff == null)
continue;
//Current effect is a higher rank, dont apply.
if (eff.getTrains() > mbe.getRank())
continue;
//new effect is of a higher rank. remove old effect and apply new one.
eff.cancelJob();
character.addEffectNoTimer(Integer.toString(effectsBase.getUUID()), effectsBase, mbe.getRank(), true);
} else {
if (mbe.getReqLvl() > (int) character.level)
continue;
character.addEffectNoTimer(Integer.toString(effectsBase.getUUID()), effectsBase, mbe.getRank(), true);
}
}
}
public static void dismissNecroPet(Mob necroPet, boolean updateOwner) {
necroPet.setCombatTarget(null);
@@ -196,80 +122,6 @@ public enum NPCManager {
playerCharacter.necroPets.clear();
}
public static void removeSiegeMinions(Mob mobile) {
for (Mob toRemove : mobile.siegeMinionMap.keySet()) {
if (mobile.isMoving()) {
mobile.stopMovement(mobile.getLoc());
if (toRemove.parentZone != null)
toRemove.parentZone.zoneMobSet.remove(toRemove);
}
try {
toRemove.clearEffects();
} catch (Exception e) {
Logger.error(e.getMessage());
}
if (toRemove.parentZone != null)
toRemove.parentZone.zoneMobSet.remove(toRemove);
WorldGrid.RemoveWorldObject(toRemove);
WorldGrid.removeObject(toRemove);
DbManager.removeFromCache(toRemove);
PlayerCharacter petOwner = (PlayerCharacter) toRemove.guardCaptain;
if (petOwner != null) {
petOwner.setPet(null);
toRemove.guardCaptain = null;
PetMsg petMsg = new PetMsg(5, null);
Dispatch dispatch = Dispatch.borrow(petOwner, petMsg);
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.PRIMARY);
}
}
}
public static boolean removeMobileFromBuilding(Mob mobile, Building building) {
// Remove npc from it's building
try {
mobile.clearEffects();
} catch (Exception e) {
Logger.error(e.getMessage());
}
if (mobile.parentZone != null)
mobile.parentZone.zoneMobSet.remove(mobile);
if (building != null) {
building.getHirelings().remove(mobile);
removeSiegeMinions(mobile);
}
// Delete npc from database
if (DbManager.MobQueries.DELETE_MOB(mobile) == 0)
return false;
// Remove npc from the simulation
mobile.removeFromCache();
DbManager.removeFromCache(mobile);
WorldGrid.RemoveWorldObject(mobile);
WorldGrid.removeObject(mobile);
return true;
}
public static void loadAllPirateNames() {
DbManager.NPCQueries.LOAD_PIRATE_NAMES();
@@ -340,7 +192,7 @@ public enum NPCManager {
if (abstractCharacter.getObjectType().equals(Enum.GameObjectType.Mob) && ((Mob) abstractCharacter).behaviourType.equals(Enum.MobBehaviourType.SiegeEngine)) {
Mob siegeMobile = (Mob) abstractCharacter;
buildingSlot = siegeMobile.guardCaptain.siegeMinionMap.size() + 2;
buildingSlot = siegeMobile.guardCaptain.minions.size() + 2;
}
if (buildingSlot == -1)
@@ -376,33 +228,6 @@ public enum NPCManager {
return buildingSlot;
}
public static int getMaxMinions(Mob guardCaptain) {
int maxSlots;
switch (guardCaptain.getRank()) {
case 3:
maxSlots = 2;
break;
case 4:
case 5:
maxSlots = 3;
break;
case 6:
maxSlots = 4;
break;
case 7:
maxSlots = 5;
break;
case 1:
case 2:
default:
maxSlots = 1;
}
return maxSlots;
}
public static void AssignPatrolPoints(Mob mob) {
mob.patrolPoints = new ArrayList<>();
@@ -419,9 +244,234 @@ public enum NPCManager {
mob.patrolPoints.add(newPatrolPoint);
if (i == 1) {
mob.loc = newPatrolPoint;
mob.setLoc(newPatrolPoint);
mob.endLoc = newPatrolPoint;
}
}
}
public static void applyGuardStanceModifiers(Mob guard){
float damageModifier = 1;
float attackRatingModifier = 1;
float defenseModifier = 1;
float attackSpeedModifier = 1;
float powerDamageModifier = 1;
//handle stance modifiers for guard mob
if(guard.agentType.equals(Enum.AIAgentType.GUARDWALLARCHER)){
//apply rogue bonuses
attackRatingModifier += 0.5f;
defenseModifier += 0.5f;
damageModifier += 0.5f;
attackSpeedModifier -= 0.36f;
}else {
Integer contractID;
if (guard.agentType.equals(Enum.AIAgentType.GUARDMINION)) {
contractID = guard.guardCaptain.contract.getContractID();
} else{
contractID = guard.contract.getContractID();
}
if (Enum.MinionType.ContractToMinionMap.get(contractID) != null && Enum.MinionType.ContractToMinionMap.get(contractID).isMage()){
//apply mage offensive Stance
powerDamageModifier += 0.5f;
} else{
//apply fighter offensive stance
damageModifier += 0.5f;
attackSpeedModifier -= 0.36f;
}
}
guard.minDamageHandOne *= damageModifier;
guard.minDamageHandTwo *= damageModifier;
guard.maxDamageHandOne *= damageModifier;
guard.maxDamageHandTwo *= damageModifier;
guard.atrHandOne *= attackRatingModifier;
guard.atrHandTwo *= attackRatingModifier;
guard.defenseRating *= defenseModifier;
guard.speedHandOne *= attackSpeedModifier;
guard.speedHandTwo *= attackSpeedModifier;
//TODO figure out how to apply +50% powerdamage to mage guards
}
public static void setDamageAndSpeedForGuard(Mob guard){
float rankModifier = 1 + (guard.getRank() * 0.1f);
int primaryStat = 0;
if(guard.equip == null) {
guard.minDamageHandOne = (int)((guard.mobBase.getDamageMin()) * rankModifier);
guard.maxDamageHandOne = (int)((guard.mobBase.getDamageMax()) * rankModifier);
guard.speedHandOne = 30.0f;
}else{
if(guard.equip.containsKey(1)){
//has main hand weapon
ItemBase weapon = guard.equip.get(1).getItemBase();
if(weapon.isStrBased())
primaryStat = guard.getStatStrCurrent();
else
primaryStat = guard.getStatDexCurrent();
guard.minDamageHandOne = (int)((guard.mobBase.getDamageMin() + weapon.getMinDamage()) * rankModifier) + primaryStat;
guard.maxDamageHandOne = (int)((guard.mobBase.getDamageMax() + weapon.getMaxDamage()) * rankModifier) + primaryStat;
guard.speedHandOne = weapon.getSpeed();
guard.rangeHandOne = weapon.getRange();
} else if(guard.equip.containsKey(2) && !guard.equip.get(2).getItemBase().isShield()){
//has off hand weapon
ItemBase weapon = guard.equip.get(2).getItemBase();
if(weapon.isStrBased())
primaryStat = guard.getStatStrCurrent();
else
primaryStat = guard.getStatDexCurrent();
guard.minDamageHandTwo = (int)((guard.mobBase.getDamageMin() + weapon.getMinDamage()) * rankModifier) + primaryStat;
guard.maxDamageHandTwo = (int)((guard.mobBase.getDamageMax() + weapon.getMaxDamage()) * rankModifier) + primaryStat;
guard.speedHandTwo = weapon.getSpeed();
guard.rangeHandTwo = weapon.getRange();
} else {
primaryStat = guard.getStatStrCurrent();
guard.minDamageHandOne = (int)((guard.mobBase.getDamageMin()) * rankModifier) + primaryStat;
guard.maxDamageHandOne = (int)((guard.mobBase.getDamageMax()) * rankModifier) + primaryStat;
guard.speedHandOne = 30.0f;
guard.rangeHandOne = 3;
}
}
}
public static void setDefenseForGuard(Mob guard){
int dexterity = guard.getStatDexCurrent();
if(dexterity < 1)
dexterity = 1;
int baseDef = guard.mobBase.getDefenseRating();
int armorDefense = 0;
for(MobEquipment equipped : guard.equip.values())
if(equipped.getItemBase().isArmor() || equipped.getItemBase().isShield())
armorDefense += equipped.getItemBase().getDefense();
guard.defenseRating = dexterity + baseDef + armorDefense;
}
public static void setAttackRatingForGuard(Mob guard) {
int strength = guard.getStatStrCurrent();
int baseAtr = guard.mobBase.getAttackRating();
if (guard.equip.get(1) != null)
guard.atrHandOne = baseAtr + (int) ((strength * 0.5f) + (guard.equip.get(1).getItemBase().getPercentRequired() * 4) + (guard.equip.get(1).getItemBase().getPercentRequired() * 3));
else if (guard.equip.get(2) != null && !guard.equip.get(2).getItemBase().isShield())
guard.atrHandTwo = baseAtr + (int) ((strength * 0.5f) + (guard.equip.get(2).getItemBase().getPercentRequired() * 4) + (guard.equip.get(2).getItemBase().getPercentRequired() * 3));
else
guard.atrHandOne = baseAtr;
}
public static void setMaxHealthForGuard(Mob guard){
//values derived fom reading memory address for health on client when selecting player guards
switch(guard.getRank()){
default:
guard.healthMax = 750; //rank 1
break;
case 2:
guard.healthMax = 2082;
break;
case 3:
guard.healthMax = 2740;
break;
case 4:
guard.healthMax = 3414;
break;
case 5:
guard.healthMax = 4080;
break;
case 6:
guard.healthMax = 4746;
break;
case 7:
guard.healthMax = 5412;
break;
}
}
public static void applyMobbaseEffects(Mob mob) {
EffectsBase effectsBase;
for (MobBaseEffects mbe : mob.mobBase.effectsList) {
effectsBase = PowersManager.getEffectByToken(mbe.getToken());
if (effectsBase == null) {
Logger.info("Mob: " + mob.getObjectUUID() + " EffectsBase Null for Token " + mbe.getToken());
continue;
}
//check to upgrade effects if needed.
if (mob.effects.containsKey(Integer.toString(effectsBase.getUUID()))) {
if (mbe.getReqLvl() > (int) mob.level)
continue;
Effect eff = mob.effects.get(Integer.toString(effectsBase.getUUID()));
if (eff == null)
continue;
//Current effect is a higher rank, dont apply.
if (eff.getTrains() > mbe.getRank())
continue;
//new effect is of a higher rank. remove old effect and apply new one.
eff.cancelJob();
mob.addEffectNoTimer(Integer.toString(effectsBase.getUUID()), effectsBase, mbe.getRank(), true);
} else {
if (mbe.getReqLvl() > (int) mob.level)
continue;
mob.addEffectNoTimer(Integer.toString(effectsBase.getUUID()), effectsBase, mbe.getRank(), true);
}
}
}
public static void applyEquipmentResists(Mob mob){
if(mob.equip != null){
for(MobEquipment equipped : mob.equip.values()){
ItemBase itemBase = equipped.getItemBase();
if(itemBase.isHeavyArmor() || itemBase.isLightArmor() || itemBase.isMediumArmor()){
mob.resists.setResist(Enum.DamageType.Crush, mob.resists.getResist(Enum.DamageType.Crush,0) + itemBase.getCrushResist());
mob.resists.setResist(Enum.DamageType.Slash, mob.resists.getResist(Enum.DamageType.Slash,0) + itemBase.getCrushResist());
mob.resists.setResist(Enum.DamageType.Pierce, mob.resists.getResist(Enum.DamageType.Pierce,0) + itemBase.getCrushResist());
}
}
}
}
public static void applyMobbaseSkill(Mob mob) {
SkillsBase baseSkill = DbManager.SkillsBaseQueries.GET_BASE_BY_TOKEN(mob.mobBase.getMobBaseStats().getBaseSkill());
if(baseSkill != null)
mob.getSkills().put(baseSkill.getName(),new CharacterSkill(baseSkill,mob,mob.mobBase.getMobBaseStats().getBaseSkillAmount()));
}
public static void applyRuneSkills(Mob mob, int runeID){
//load mob skill adjustments from mobbase rune
if(PowersManager._allRuneSkillAdjusts.containsKey(runeID))
for(RuneSkillAdjustEntry entry : PowersManager._allRuneSkillAdjusts.get(runeID)) {
if(SkillsBase.getFromCache(entry.skill_type) == null)
SkillsBase.putInCache(DbManager.SkillsBaseQueries.GET_BASE_BY_NAME(entry.skill_type));
SkillsBase skillBase = SkillsBase.getFromCache(entry.skill_type);
if(skillBase == null)
continue;
if (entry.level <= mob.level)
if (mob.skills.containsKey(entry.name) == false)
mob.skills.put(entry.skill_type, new CharacterSkill(skillBase, mob, entry.rank));
else
mob.skills.put(entry.skill_type, new CharacterSkill(skillBase, mob, entry.rank + mob.skills.get(entry.skill_type).getNumTrains()));
}
}
public static void applyRunesForNPC(NPC npc){
npc.runes = new ArrayList<>();
RuneBase shopkeeperBase = RuneBase.getRuneBase(252620);
CharacterRune shopkeeper = new CharacterRune(shopkeeperBase,npc.getObjectUUID());
npc.runes.add(shopkeeper);
if(NPCManager._runeSetMap.containsKey(npc.runeSetID)) {
for (int runeID : _runeSetMap.get(npc.runeSetID)) {
RuneBase rb = RuneBase.getRuneBase(runeID);
if(rb != null) {
CharacterRune toApply = new CharacterRune(rb, npc.getObjectUUID());
npc.runes.add(toApply);
}
}
}
}
}
+76 -218
View File
@@ -27,7 +27,6 @@ import engine.net.client.ClientConnection;
import engine.net.client.msg.*;
import engine.objects.*;
import engine.powers.*;
import engine.powers.effectmodifiers.SeeInvisibleEffectModifier;
import engine.powers.poweractions.AbstractPowerAction;
import engine.powers.poweractions.TrackPowerAction;
import engine.server.MBServerStatics;
@@ -54,29 +53,10 @@ public enum PowersManager {
public static HashMap<Integer, AbstractPowerAction> powerActionsByID = new HashMap<>();
public static HashMap<String, Integer> ActionTokenByIDString = new HashMap<>();
public static HashMap<String, Integer> AnimationOverrides = new HashMap<>();
public static HashMap<Integer, ArrayList<MobPowerEntry>> AllMobPowers;
public static HashMap<Integer, ArrayList<RunePowerEntry>> _allRunePowers;
public static HashMap<Integer, ArrayList<RuneSkillAdjustEntry>> _allRuneSkillAdjusts;
private static JobScheduler js;
public static String[] siegeBuffs = new String[]{"ART-004A","ARM-112A"};
public static String[] siegeDeBuffs = new String[]{"ACM-003A","WRT-003A"};
public static ArrayList<PowerQueObject> static_power_que = new ArrayList<>();
public static class PowerQueObject{
public PowerQueObject(PerformActionMsg inmsg,ClientConnection inorigin,boolean insendCastToSelf){
this.msg = inmsg;
this.origin = inorigin;
this.sendCastToSelf = insendCastToSelf;
}
public PerformActionMsg msg;
public ClientConnection origin;
public boolean sendCastToSelf;
}
private PowersManager() {
}
public static void initPowersManager(boolean fullPowersLoad) {
if (fullPowersLoad)
@@ -120,6 +100,16 @@ public enum PowersManager {
}
}
public static ArrayList<RunePowerEntry> getPowersForRune(int rune_id) {
ArrayList<RunePowerEntry> powerEntries = PowersManager._allRunePowers.get(rune_id);
if (powerEntries == null)
powerEntries = new ArrayList<>();
return powerEntries;
}
// This pre-loads all powers and effects
public static void InitializePowers() {
@@ -182,9 +172,11 @@ public enum PowersManager {
if (usePowerA(msg, origin, sendCastToSelf)) {
// Cast failed for some reason, reset timer
RecyclePowerMsg recyclePowerMsg = new RecyclePowerMsg(msg.getPowerUsedID());
Dispatch dispatch = Dispatch.borrow(origin.getPlayerCharacter(), recyclePowerMsg);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
// Send Fail to cast message
PlayerCharacter pc = SessionManager
.getPlayerCharacter(origin);
@@ -218,8 +210,6 @@ public enum PowersManager {
if (playerCharacter == null)
return false;
boolean skipCheck = false;
boolean CSRCast = false;
@@ -232,67 +222,10 @@ public enum PowersManager {
+ Integer.toHexString(msg.getPowerUsedID()) + " ("
+ msg.getPowerUsedID() + ')');
}
Boolean earlyExit = false;
//Sending recycle message to player if died while casting.
if (!playerCharacter.isAlive() && msg.getPowerUsedID() != 428589216) { //succor
earlyExit = true;
}
if(msg.getPowerUsedID() == 430628895){ // group teleport
Boolean activeBane = false;
if(ZoneManager.getCityAtLocation(playerCharacter.loc) != null && ZoneManager.getCityAtLocation(playerCharacter.loc).getBane() != null)
activeBane = ZoneManager.getCityAtLocation(playerCharacter.loc).getBane().getSiegePhase().equals(SiegePhase.WAR);
Zone currentZone = ZoneManager.findSmallestZone(playerCharacter.loc);
if(currentZone == null)
earlyExit = true;
if(currentZone.isPlayerCity() && !activeBane)
earlyExit = true;
if(currentZone.getName().contains("Mine") == true && currentZone.isPlayerCity() == false) {
for (Building building : currentZone.zoneBuildingSet) {
if (Mine.getMineFromTower(building.getObjectUUID()) != null) {
Mine currentMine = Mine.getMineFromTower(building.getObjectUUID());
if (currentMine.isActive == false) {
earlyExit = true;
}
}
}
}
Vector3fImmutable endLoc = new Vector3fImmutable(msg.getTargetX(),msg.getTargetY(),msg.getTargetZ());
currentZone = ZoneManager.findSmallestZone(endLoc);
if(currentZone == null)
earlyExit = true;
if(currentZone.isPlayerCity() && !activeBane)
earlyExit = true;
if(currentZone.getName().contains("Mine") == true && currentZone.isPlayerCity() == false) {
for (Building building : currentZone.zoneBuildingSet) {
if (Mine.getMineFromTower(building.getObjectUUID()) != null) {
Mine currentMine = Mine.getMineFromTower(building.getObjectUUID());
if (currentMine.isActive == false) {
earlyExit = true;
}
}
}
}
}
// get power
PowersBase pb = PowersManager.powersBaseByToken.get(msg.getPowerUsedID());
if(pb.description.equals("Personal Movement Buff") && playerCharacter.isFlying()) {
ChatManager.chatSystemInfo(playerCharacter, "You cannot use movement speed buffs while flying");
earlyExit = true;
}
if (earlyExit) {
RecyclePowerMsg recyclePowerMsg = new RecyclePowerMsg(msg.getPowerUsedID());
Dispatch dispatch = Dispatch.borrow(playerCharacter, recyclePowerMsg);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
@@ -300,6 +233,7 @@ public enum PowersManager {
return false;
}
// if (!pc.getPowers().contains(msg.getPowerUsedID())) {
// sendPowerMsg(pc, 10, msg);
// return false;
@@ -312,6 +246,8 @@ public enum PowersManager {
return false;
}
// get power
PowersBase pb = PowersManager.powersBaseByToken.get(msg.getPowerUsedID());
if (pb == null) {
ChatManager.chatSayInfo(playerCharacter,
"This power is not implemented yet.");
@@ -322,18 +258,15 @@ public enum PowersManager {
return true;
// return false;
}
if (playerCharacter.getLastPower() != null)
return true;
//Check if Power Target is allowed to cast.
// Check powers for normal users
if(msg.getPowerUsedID() == 429399948)
for(CharacterRune cr : playerCharacter.getRunes())
if(cr.getRuneBaseID() == 3029)
skipCheck = true;
if (!skipCheck && (playerCharacter.getPowers() == null || !playerCharacter.getPowers().containsKey(msg.getPowerUsedID())))
if (playerCharacter.getPowers() == null || !playerCharacter.getPowers().containsKey(msg.getPowerUsedID()))
if (!playerCharacter.isCSR()) {
if (!MBServerStatics.POWERS_DEBUG) {
// ChatManager.chatSayInfo(pc, "You may not cast that spell!");
@@ -346,31 +279,18 @@ public enum PowersManager {
// get numTrains for power
int trains = msg.getNumTrains();
int token = pb.token;
int overrideTrains = 0;
int overrideRecycle = 0;
if(token == 429420458){
overrideTrains = 40;
overrideRecycle = 300000;
}
// can't go over the max trains for the power, unless CSR
if (trains > pb.getMaxTrains() && !playerCharacter.isCSR()) {
trains = pb.getMaxTrains();
msg.setNumTrains(trains);
}
// can't go over total trains by player
if (playerCharacter.getPowers() != null && playerCharacter.getPowers().containsKey(msg.getPowerUsedID())) {
CharacterPower cp = playerCharacter.getPowers().get(msg.getPowerUsedID());
if (cp != null) {
int tot = cp.getTotalTrains();
switch(token){
case 430596127:
if(playerCharacter.getPromotionClass().getName().equals("Wizard"))
tot = 40; //single teleport granted at 40 for wizard
break;
}
if (tot == 0 && !playerCharacter.isCSR())
return false;
if (trains != tot && !playerCharacter.isCSR()) {
@@ -379,19 +299,27 @@ public enum PowersManager {
}
}
}
if(overrideTrains > 0)
msg.setNumTrains(overrideTrains);
// get recycle time in ms
int time = pb.getRecycleTime(trains);
if(overrideRecycle > 0)
time = overrideRecycle;
// verify player is in correct mode (combat/nonCombat)
if (playerCharacter.isCombat()) {
if (!pb.allowedInCombat())
// ChatManager.chatPowerError(pc,
// "This power is not allowed in combat mode.");
return true;
} else if (!pb.allowedOutOfCombat())
// ChatManager.chatPowerError(pc,
// "You must be in combat mode to use this power.");
return true;
// verify player is not stunned or prohibited from casting
PlayerBonuses bonus = playerCharacter.getBonuses();
SourceType sourceType = SourceType.GetSourceType(pb.getCategory());
if (bonus != null && (bonus.getBool(ModType.Stunned, SourceType.None) || bonus.getBool(ModType.CannotCast, SourceType.None) || bonus.getBool(ModType.BlockedPowerType, sourceType)))
return true;
// if moving make sure spell valid for movement
Vector3fImmutable endLoc = playerCharacter.getEndLoc();
@@ -417,43 +345,35 @@ public enum PowersManager {
if (pb.targetFromLastTarget() || pb.targetPet()) // use msg's target
if (pb.isAOE()) {
if (!pb.usePointBlank()) {
AbstractWorldObject target;
if(msg.getTargetType() == 37 && Mob.dynamic_pets.get(msg.getTargetID()) != null){
Mob pet = Mob.dynamic_pets.get(msg.getTargetID());
target = pet;
}else{
target = getTarget(msg);
}
AbstractWorldObject target = getTarget(msg);
if (target != null && target.getObjectType() == GameObjectType.Building && !pb.targetBuilding()) {
PowersManager.sendPowerMsg(playerCharacter, 9, new PerformActionMsg(msg));
return true;
}
if (target == null) {
if (playerCharacter.getLoc().distanceSquared2D(msg.getTargetLoc()) > sqr(pb
.getRange()))
return true;
} else if (verifyInvalidRange(playerCharacter, target, pb.getRange())) {
} else if (verifyInvalidRange(playerCharacter, target, pb.getRange()))
// pc.getLoc().distance(target.getLoc()) >
// pb.getRange())
return true;
}
}
} else {
// get target
AbstractWorldObject target;
if(msg.getTargetType() == 37 && Mob.dynamic_pets.get(msg.getTargetID()) != null){
Mob pet = Mob.dynamic_pets.get(msg.getTargetID());
target = pet;
}else{
target = getTarget(msg);
}
if (target == null) {
AbstractWorldObject target = getTarget(msg);
if (target == null)
return true;
}
if (!target.isAlive() && target.getObjectType().equals(GameObjectType.Building) == false && msg.getPowerUsedID() != 428589216)
return true;
float range = pb.getRange();
// verify target is in range
@@ -462,13 +382,16 @@ public enum PowersManager {
// (pc.getLoc().distance(target.getLoc()) > pb.getRange()) {
// TODO send message that target is out of range
return true;
// verify target is valid type
if (!validateTarget(target, playerCharacter, pb))
return true;
if (AbstractWorldObject.IsAbstractCharacter(target))
targetLiveCounter = ((AbstractCharacter) target).getLiveCounter();
}
// verify regular player can cast spell, otherwise authenticate
if (!pb.regularPlayerCanCast()) {
Account a = SessionManager.getAccount(playerCharacter);
@@ -478,6 +401,7 @@ public enum PowersManager {
return true;
}
}
// verify player has proper effects applied to use power
if (pb.getEffectPrereqs().size() > 0 && playerCharacter.getEffects() != null) {
@@ -491,9 +415,11 @@ public enum PowersManager {
break;
}
}
if (!passed)
return true;
}
//verify player has proper equipment to use power
if (pb.getEquipPrereqs().size() > 0) {
@@ -612,13 +538,6 @@ public enum PowersManager {
// get cast time in ms.
time = pb.getCastTime(trains);
if(pb.token == 430596127)
time = 5000;
if(pb.name.equals("Summon") && playerCharacter.getRace().getName().contains("Vampire"))
time = 60000;
// set player is casting for regens
@@ -630,10 +549,6 @@ public enum PowersManager {
playerCharacter.setLastMovementState(playerCharacter.getMovementState());
if(msg.getPowerUsedID() == 429495514 && playerCharacter.getRace().getName().contains("Shade")){
copyMsg.setPowerUsedID(429397210);//intercept shade using hide and cast sneak instead
}
// run timer job to end cast
if (time < 1) // run immediately
finishUsePower(copyMsg, playerCharacter, casterLiveCounter, targetLiveCounter);
@@ -699,13 +614,7 @@ public enum PowersManager {
if (pb.targetFromLastTarget() || pb.targetPet()) // use msg's target
if (pb.isAOE()) {
if (!pb.usePointBlank()) {
AbstractWorldObject target;
if(msg.getTargetType() == 37 && Mob.dynamic_pets.get(msg.getTargetID()) != null){
Mob pet = Mob.dynamic_pets.get(msg.getTargetID());
target = pet;
}else{
target = getTarget(msg);
}
AbstractWorldObject target = getTarget(msg);
if (target == null) {
@@ -720,13 +629,7 @@ public enum PowersManager {
}
} else {
// get target
AbstractWorldObject target;
if(msg.getTargetType() == 37 && Mob.dynamic_pets.get(msg.getTargetID()) != null){
Mob pet = Mob.dynamic_pets.get(msg.getTargetID());
target = pet;
}else{
target = getTarget(msg);
}
AbstractWorldObject target = getTarget(msg);
if (target == null)
return true;
@@ -1331,8 +1234,9 @@ public enum PowersManager {
if (pc == null)
return;
PlayerCharacter target = SessionManager.getPlayerCharacterByLowerCaseName(msg.getTargetName());
if (target == null || target.equals(pc) || target.isCombat() || target.getGuild().getNation().equals(pc.getGuild().getNation()) == false) {
PlayerCharacter target = SessionManager
.getPlayerCharacterByLowerCaseName(msg.getTargetName());
if (target == null || target.equals(pc) || target.isCombat()) {
if (target == null) // Player not found. Send not found message
ChatManager.chatInfoError(pc,
@@ -1341,10 +1245,7 @@ public enum PowersManager {
ChatManager.chatInfoError(pc,
"Cannot summon player in combat.");
// else trying to summon self, just fail
if(target != null && target.getGuild().getNation().equals(pc.getGuild().getNation()) == false){
ChatManager.chatInfoError(pc,
"Cannot summon outside of nation.");
}
// recycle summon
sendRecyclePower(msg.getPowerToken(), origin);
@@ -1376,7 +1277,7 @@ public enum PowersManager {
if (source == null)
return;
long tooLate = pc.getSummoner(source.getObjectUUID()) + 45000;
long tooLate = pc.getSummoner(source.getObjectUUID());
if (tooLate < System.currentTimeMillis()) {
ChatManager.chatInfoError(pc, "You waited too long to " + (msg.accepted() ? "accept" : "decline") + " the summons.");
pc.removeSummoner(source.getObjectUUID());
@@ -1438,15 +1339,7 @@ public enum PowersManager {
duration = 15000; // Healer Summons, 15 seconds
else
duration = 45000; // Belgosh Summons, 45 seconds
if(pc.inSafeZone() == false) {
for (AbstractWorldObject absChar : WorldGrid.getObjectsInRangePartial(pc.loc, MBServerStatics.CHARACTER_LOAD_RANGE, MBServerStatics.MASK_PLAYER)) {
PlayerCharacter player = (PlayerCharacter) absChar;
if (player.guild.getNation().equals(pc.guild.getNation()) == false) {
duration += 60000;
break;
}
}
}
// Teleport to summoners location
FinishSummonsJob fsj = new FinishSummonsJob(source, pc);
@@ -1575,41 +1468,6 @@ public enum PowersManager {
HashSet<AbstractCharacter> trackChars = RangeBasedAwo.getTrackList(
allTargets, playerCharacter, maxTargets);
trackChars = new HashSet<>();
HashSet<AbstractWorldObject> allInRange = WorldGrid.getObjectsInRangePartial(playerCharacter.loc,MBServerStatics.CHARACTER_LOAD_RANGE,MBServerStatics.MASK_PLAYER);
//ArrayList<Guild> nationsInRange = new ArrayList<>();
ArrayList<AbstractWorldObject> purgeList = new ArrayList<>();
for(AbstractWorldObject trackChar : allInRange) {
if(trackChar.equals(playerCharacter) || !trackChar.isAlive() || !((PlayerCharacter)trackChar).isActive())
purgeList.add(trackChar);
}
allInRange.removeAll(purgeList);
//first round to add players in range
for(AbstractWorldObject trackChar : allInRange){
if(trackChar.equals(playerCharacter) || !trackChar.isAlive() || !((PlayerCharacter)trackChar).isActive())
continue;
if(allInRange.contains(trackChar)) {
trackChars.add((AbstractCharacter)trackChar);
}
}
//track full range for chaining nation members
ArrayList<Guild> nationsInRange = new ArrayList<>();
for(AbstractCharacter pc : trackChars){
if(nationsInRange.contains(pc.guild.getNation()) == false)
nationsInRange.add(pc.guild.getNation());
}
HashSet<AbstractWorldObject> fullRange = WorldGrid.getObjectsInRangePartial(playerCharacter.loc,1024,MBServerStatics.MASK_PLAYER);
for(AbstractWorldObject trackChar : fullRange) {
if(trackChar.equals(playerCharacter) || !trackChar.isAlive() || !((PlayerCharacter)trackChar).isActive())
continue;
if(nationsInRange.contains(((PlayerCharacter) trackChar).guild.getNation()) && trackChars.contains(trackChar) == false)
trackChars.add((AbstractCharacter)trackChar);
}
TrackWindowMsg trackWindowMsg = new TrackWindowMsg(msg);
// send track window
@@ -1785,8 +1643,7 @@ public enum PowersManager {
ac.setItemCasting(false);
if (ac == null || target == null || pb == null)
return;
if(pb.targetSelf)
target = ac;
ac.clearTimer(Integer.toString(pb.getToken()));
if (liveCounter == ac.getLiveCounter())
finishApplyPowerA(ac, target, targetLoc, pb, trains, false);
@@ -2367,9 +2224,9 @@ public enum PowersManager {
int type = msg.getTargetType();
int UUID = msg.getTargetID();
if (type == -1 || type == 0 || UUID == -1 || UUID == 0) {
if (type == -1 || type == 0 || UUID == -1 || UUID == 0)
return null;
}
return (AbstractWorldObject) DbManager.getObject(GameObjectType.values()[type], UUID);
}
@@ -2392,11 +2249,17 @@ public enum PowersManager {
ChatManager.chatSystemInfo(pc, smsg);
}
float constant = (atr+defense)*0.315f;
float atrChance = atr - constant;
float defChance = defense - constant + atrChance;
float smallChance = atrChance/defChance;
int chance = (int)(smallChance * 100);
int chance;
if (atr > defense || defense == 0)
chance = 94;
else {
float dif = atr / defense;
if (dif <= 0.8f)
chance = 4;
else
chance = ((int) (450 * (dif - 0.8f)) + 4);
}
// calculate hit/miss
int roll = ThreadLocalRandom.current().nextInt(100);
@@ -2604,11 +2467,11 @@ public enum PowersManager {
ChatManager.chatSystemInfo(pc, outmsg);
return false; // can't target player, stop here
} // target is mob
else if ((target.getObjectTypeMask() & MBServerStatics.MASK_MOB) != 0 && ((Mob)target).isPet() == false)
else if ((target.getObjectTypeMask() & MBServerStatics.MASK_MOB) != 0)
return pb.targetMob();
// target is pet
else if ((target.getObjectTypeMask() & MBServerStatics.MASK_MOB) != 0 && ((Mob)target).isPet() == true)
else if ((target.getObjectTypeMask() & MBServerStatics.MASK_PET) != 0)
return pb.targetPet();
// target is Building
@@ -2687,7 +2550,7 @@ public enum PowersManager {
PowersBase power = getLastPower(ac);
if (power != null && power.cancelOnTakeDamage() && power.getName().equals("Translocate") == false)
if (power != null && power.cancelOnTakeDamage())
cancelPower(ac, true);
cancelItems(ac, false, true);
ac.cancelTimer("Stuck");
@@ -2847,12 +2710,7 @@ public enum PowersManager {
}
}
}
public static void applyZergBuff(AbstractGameObject obj){
}
public static void removeZergBuff(HashSet<Integer> playersIDs){
}
}
+6 -21
View File
@@ -10,12 +10,10 @@ package engine.gameManager;
import engine.Enum;
import engine.Enum.GameObjectType;
import engine.InterestManagement.WorldGrid;
import engine.db.archive.DataWarehouse;
import engine.db.archive.MineRecord;
import engine.net.DispatchMessage;
import engine.net.client.msg.chat.ChatSystemMsg;
import engine.objects.*;
import engine.objects.AbstractGameObject;
import engine.objects.City;
import engine.objects.PlayerCharacter;
import engine.objects.Runegate;
import org.pmw.tinylog.Logger;
import java.sql.Connection;
@@ -24,7 +22,6 @@ import java.sql.ResultSet;
import java.sql.SQLException;
import java.time.Duration;
import java.time.Instant;
import java.time.LocalDateTime;
import java.util.Collection;
/*
@@ -36,14 +33,13 @@ public enum SimulationManager {
SERVERHEARTBEAT;
private static final long CITY_PULSE = 2000;
private static final long RUNEGATE_PULSE = 500;
private static final long RUNEGATE_PULSE = 3000;
private static final long UPDATE_PULSE = 1000;
private static final long FlIGHT_PULSE = 100;
public static Duration executionTime = Duration.ofNanos(1);
public static Duration executionMax = Duration.ofNanos(1);
private static SimulationManager instance = null;
private long _cityPulseTime = System.currentTimeMillis() + CITY_PULSE;
private long _minePulseTime = System.currentTimeMillis() + CITY_PULSE;
private long _runegatePulseTime = System.currentTimeMillis()
+ RUNEGATE_PULSE;
private long _updatePulseTime = System.currentTimeMillis() + UPDATE_PULSE;
@@ -73,8 +69,6 @@ public enum SimulationManager {
return popString;
}
/*
* Update the simulation. *** Important: Whatever you do in here, do it damn
* quick!
@@ -132,17 +126,7 @@ public enum SimulationManager {
e.printStackTrace();
}
//try {
// if ((_minePulseTime != 0)
// && (System.currentTimeMillis() > _minePulseTime))
// pulseMines();
//} catch (Exception e) {
// Logger.error(
// "Fatal error in Mine Pulse: DISABLED. Error Message : "
// + e.getMessage());
// e.printStackTrace();
//}
SimulationManager.executionTime = Duration.between(startTime, Instant.now());
if (executionTime.compareTo(executionMax) > 0)
@@ -219,6 +203,7 @@ public enum SimulationManager {
city = (City) cityObject;
city.onEnter();
}
_cityPulseTime = System.currentTimeMillis() + CITY_PULSE;
}
-58
View File
@@ -1,58 +0,0 @@
package engine.gameManager;
import engine.objects.Guild;
public class ZergManager {
public static int getBaneCap(Guild guild) {
if(guild.getOwnedCity() == null || guild.getOwnedCity().getTOL() == null)
return 0;
int cityRank = guild.getOwnedCity().getTOL().getRank();
return (cityRank == 8) ? 20 : ((guild.getNation().getSubGuildList().size() + 1 <= 4) ? 10 : 20);
}
public static float getCurrentMultiplier(int count, int maxCount){
switch(maxCount) {
case 3:
return getMultiplier3Man(count);
case 5:
return getMultiplier5Man(count);
case 10:
return getMultiplier10Man(count);
case 20:
return getMultiplier20Man(count);
default:
return getMultiplier40Man(count);
}
}
public static float getMultiplier(int count, int maxCount, float[] thresholds) {
if (count <= maxCount) return 1.0f;
if (count > thresholds.length) return 0.0f;
return 1.0f - thresholds[count - maxCount - 1];
}
public static float getMultiplier3Man(int count) {
float[] thresholds = {0.37f, 0.60f, 0.75f};
return getMultiplier(count, 3, thresholds);
}
public static float getMultiplier5Man(int count) {
float[] thresholds = {0.25f, 0.43f, 0.56f, 0.67f, 0.75f};
return getMultiplier(count, 5, thresholds);
}
public static float getMultiplier10Man(int count) {
float[] thresholds = {0.14f, 0.25f, 0.35f, 0.43f, 0.50f, 0.56f, 0.62f, 0.67f, 0.71f, 0.75f};
return getMultiplier(count, 10, thresholds);
}
public static float getMultiplier20Man(int count) {
return getMultiplier10Man(count * 2);
}
public static float getMultiplier40Man(int count) {
return getMultiplier10Man(count * 4);
}
}
+28
View File
@@ -9,6 +9,7 @@
package engine.gameManager;
import engine.Enum;
import engine.InterestManagement.HeightMap;
import engine.db.archive.CityRecord;
import engine.db.archive.DataWarehouse;
import engine.math.Bounds;
@@ -453,4 +454,31 @@ public enum ZoneManager {
}
}
}
public static float caclulateWorldAltitude(Zone zone) {
float worldAlttitude = MBServerStatics.SEA_FLOOR_ALTITUDE;
// Seafloor
if (zone.getParent() == null)
return worldAlttitude;
Zone parentZone = zone.getParent();
// Children of seafloor
if (parentZone.getParent() == null)
return worldAlttitude + zone.getYCoord();
// return height from heightmap engine at zone location
worldAlttitude = HeightMap.getWorldHeight(parentZone, zone.getLoc());
// Add zone offset to value
worldAlttitude += zone.getYCoord();
return worldAlttitude;
}
}
-8
View File
@@ -15,13 +15,9 @@ import engine.gameManager.DbManager;
import engine.job.AbstractScheduleJob;
import engine.net.DispatchMessage;
import engine.net.client.msg.chat.ChatSystemMsg;
import engine.objects.Bane;
import engine.objects.City;
import engine.workthreads.ZergMechanicThread;
import org.pmw.tinylog.Logger;
import static engine.workthreads.ZergMechanicThread.startZergThreadBane;
public class ActivateBaneJob extends AbstractScheduleJob {
private final int cityUUID;
@@ -71,10 +67,6 @@ public class ActivateBaneJob extends AbstractScheduleJob {
msg.setChannel(ChatChannelType.SYSTEM.getChannelID());
DispatchMessage.dispatchMsgToAll(msg);
if(city.getBane() != null) {
startZergThreadBane(city.getBane());
}
}
@Override
-5
View File
@@ -9,11 +9,9 @@
package engine.jobs;
import engine.Enum;
import engine.gameManager.CombatManager;
import engine.job.AbstractJob;
import engine.objects.AbstractCharacter;
import engine.objects.PlayerCharacter;
public class AttackJob extends AbstractJob {
@@ -31,9 +29,6 @@ public class AttackJob extends AbstractJob {
@Override
protected void doJob() {
CombatManager.doCombat(this.source, slot);
if(this.source.getObjectType().equals(Enum.GameObjectType.PlayerCharacter))
if(((PlayerCharacter)this.source).getHidden() > 0)
this.source.removeEffectBySource(Enum.EffectSourceType.Invisibility,41,true);
}
public boolean success() {
-2
View File
@@ -61,8 +61,6 @@ public class FinishSummonsJob extends AbstractScheduleJob {
return;
}
if (this.source.region != null)
this.target.setRegion(this.source.region);
//teleport target to source
target.teleport(source.getLoc());
}
+2 -7
View File
@@ -34,15 +34,10 @@ public class ModTableEntry {
itemTableEntryList = LootManager._modTables.get(modTablwe);
if(itemTableEntryList == null)
return null;
for (ModTableEntry iteration : itemTableEntryList) {
if (iteration == null)
continue;
for (ModTableEntry iteration : itemTableEntryList)
if (roll >= iteration.minRoll && roll <= iteration.maxRoll)
modTableEntry = iteration;
}
return modTableEntry;
}
}
+1 -1
View File
@@ -220,7 +220,7 @@ public class Bounds {
//player is inside building region, skip collision check. we only do collision from the outside.
if (player.region != null && player.region.parentBuildingID == building.getObjectUUID())
continue;
if (building.getBounds() == null || building.getBounds().colliders == null)
if (building.getBounds().colliders == null)
continue;
for (Colliders collider : building.getBounds().colliders) {
File diff suppressed because it is too large Load Diff
+1 -1
View File
@@ -13,7 +13,7 @@ public class MobAIThread implements Runnable{
public static int AI_DROP_AGGRO_RANGE = 60;
public static int AI_PULSE_MOB_THRESHOLD = 200;
public static int AI_PATROL_DIVISOR = 15;
public static float AI_CAST_FREQUENCY = 1.0f;
public static float AI_CAST_FREQUENCY;
// Thread constructor
public MobAIThread() {
@@ -12,20 +12,13 @@ package engine.mobileAI.utilities;
import engine.Enum.*;
import engine.gameManager.ChatManager;
import engine.gameManager.CombatManager;
import engine.gameManager.PowersManager;
import engine.math.Vector3fImmutable;
import engine.mobileAI.MobAI;
import engine.mobileAI.Threads.MobAIThread;
import engine.net.DispatchMessage;
import engine.net.client.msg.PerformActionMsg;
import engine.net.client.msg.TargetedActionMsg;
import engine.objects.*;
import engine.powers.ActionsBase;
import engine.powers.PowersBase;
import engine.server.MBServerStatics;
import org.pmw.tinylog.Logger;
import java.util.ArrayList;
import java.util.concurrent.ThreadLocalRandom;
import static engine.math.FastMath.sqr;
@@ -271,19 +264,9 @@ public class CombatUtilities {
swingIsBlock(agent, target, passiveAnim);
return;
}
if (agent.getEquip().get(1) != null && agent.getEquip().get(2) != null && agent.getEquip().get(2).getItemBase().isShield() == false) {
//mob is duel wielding and should conduct an attack for each hand
ItemBase weapon1 = agent.getEquip().get(1).getItemBase();
double range1 = getMaxDmg(weapon1.getMinDamage(), agent, weapon1) - getMinDmg(weapon1.getMinDamage(), agent, weapon1);
double damage1 = getMinDmg(weapon1.getMinDamage(), agent, weapon1) + ((ThreadLocalRandom.current().nextFloat() * range1) + (ThreadLocalRandom.current().nextFloat() * range1)) / 2;
swingIsDamage(agent, target, (float) damage1, CombatManager.getSwingAnimation(weapon1, null, true));
ItemBase weapon2 = agent.getEquip().get(2).getItemBase();
double range2 = getMaxDmg(weapon2.getMinDamage(), agent, weapon2) - getMinDmg(weapon2.getMinDamage(), agent, weapon2);
double damage2 = getMinDmg(weapon2.getMinDamage(), agent, weapon2) + ((ThreadLocalRandom.current().nextFloat() * range2) + (ThreadLocalRandom.current().nextFloat() * range2)) / 2;
swingIsDamage(agent, target, (float) damage2, CombatManager.getSwingAnimation(weapon1, null, false));
} else {
swingIsDamage(agent, target, determineDamage(agent), anim);
}
swingIsDamage(agent, target, determineDamage(agent), anim);
if (agent.getWeaponPower() != null)
agent.getWeaponPower().attack(target, MBServerStatics.ONE_MINUTE);
@@ -311,6 +294,7 @@ public class CombatUtilities {
if (targetMob.isSiege())
return;
}
}
public static float determineDamage(Mob agent) {
@@ -325,19 +309,10 @@ public class CombatUtilities {
if (target == null)
return 0;
float damage = 0;
int damage = 0;
DamageType dt = getDamageType(agent);
if ((agent.agentType.equals(AIAgentType.PET)) == true || agent.isPet() == true || agent.isNecroPet() == true) {
damage = calculatePetDamage(agent);
} else if (agent.isPlayerGuard() == true) {
//damage = calculateGuardDamage(agent);
damage = calculateMobDamage(agent);
} else if (agent.getLevel() > 80) {
damage = calculateEpicDamage(agent);
} else {
damage = calculateMobDamage(agent);
}
damage = ThreadLocalRandom.current().nextInt((int)getMinDmg(agent), (int)getMaxDmg(agent) + 1);
if (AbstractWorldObject.IsAbstractCharacter(target)) {
if (((AbstractCharacter) target).isSit()) {
damage *= 2.5f; //increase damage if sitting
@@ -363,365 +338,16 @@ public class CombatUtilities {
return dt;
}
public static int calculatePetDamage(Mob agent) {
//damage calc for pet
float range;
float damage;
float min = 40;
float max = 60;
float dmgMultiplier = 1 + agent.getBonuses().getFloatPercentAll(ModType.MeleeDamageModifier, SourceType.None);
double minDmg = getMinDmg(min, agent, null);
double maxDmg = getMaxDmg(max, agent, null);
dmgMultiplier += agent.getLevel() * 0.1f;
range = (float) (maxDmg - minDmg);
damage = min + ((ThreadLocalRandom.current().nextFloat() * range) + (ThreadLocalRandom.current().nextFloat() * range)) / 2;
return (int) (damage * dmgMultiplier);
public static double getMinDmg(Mob agent) {
if(agent.equip.get(2) != null && !agent.equip.get(2).getItemBase().isShield())
return agent.minDamageHandTwo;
else return agent.minDamageHandOne;
}
public static int calculateGuardDamage(Mob agent) {
//damage calc for guard
ItemBase weapon = agent.getEquip().get(1).getItemBase();
AbstractWorldObject target = agent.getCombatTarget();
float dmgMultiplier = 1 + agent.getBonuses().getFloatPercentAll(ModType.MeleeDamageModifier, SourceType.None);
double minDmg = weapon.getMinDamage();
double maxDmg = weapon.getMaxDamage();
double min = getMinDmg(minDmg, agent, weapon);
double max = getMaxDmg(maxDmg, agent, weapon);
DamageType dt = weapon.getDamageType();
double range = max - min;
double damage = min + ((ThreadLocalRandom.current().nextFloat() * range) + (ThreadLocalRandom.current().nextFloat() * range)) / 2;
if (AbstractWorldObject.IsAbstractCharacter(target))
if (((AbstractCharacter) target).isSit())
damage *= 2.5f; //increase damage if sitting
if (AbstractWorldObject.IsAbstractCharacter(target))
return (int) (((AbstractCharacter) target).getResists().getResistedDamage(agent, (AbstractCharacter) target, dt, (float) damage, 0) * dmgMultiplier);
return 0;
public static double getMaxDmg(Mob agent) {
if(agent.equip.get(2) != null && !agent.equip.get(2).getItemBase().isShield())
return agent.maxDamageHandTwo;
else return agent.maxDamageHandOne;
}
public static int calculateEpicDamage(Mob agent) {
//handle r8 mob damage
DamageType dt = DamageType.Crush;
AbstractWorldObject target = agent.getCombatTarget();
float dmgMultiplier = 1 + agent.getBonuses().getFloatPercentAll(ModType.MeleeDamageModifier, SourceType.None);
double min = agent.getMinDamageHandOne();
double max = agent.getMaxDamageHandOne();
if (agent.getEquip().get(1) != null) {
if (agent.getEquip().get(1).getItemBase() != null) {
dt = agent.getEquip().get(1).getItemBase().getDamageType();
min = agent.getMinDamageHandOne();
max = agent.getMaxDamageHandOne();
} else if (agent.getEquip().get(2).getItemBase() != null && agent.getEquip().get(2).getItemBase().isShield() == false) {
dt = agent.getEquip().get(2).getItemBase().getDamageType();
min = agent.getMinDamageHandTwo();
max = agent.getMaxDamageHandTwo();
}
}
double range = max - min;
double damage = min + ((ThreadLocalRandom.current().nextFloat() * range) + (ThreadLocalRandom.current().nextFloat() * range)) / 2;
return (int) (((AbstractCharacter) target).getResists().getResistedDamage(agent, (AbstractCharacter) target, dt, (float) damage, 0) * dmgMultiplier);
}
public static int calculateMobDamage(Mob agent) {
ItemBase weapon = null;
double minDmg;
double maxDmg;
DamageType dt;
//main hand or offhand damage
if (agent.getEquip().get(1) != null)
weapon = agent.getEquip().get(1).getItemBase();
else if (agent.getEquip().get(2) != null)
weapon = agent.getEquip().get(2).getItemBase();
if (weapon != null) {
minDmg = getMinDmg(weapon.getMinDamage(), agent, weapon);
maxDmg = getMaxDmg(weapon.getMaxDamage(), agent, weapon);
dt = weapon.getDamageType();
} else {
minDmg = agent.getMobBase().getDamageMin();
maxDmg = agent.getMobBase().getDamageMax();
dt = DamageType.Crush;
}
AbstractWorldObject target = agent.getCombatTarget();
float dmgMultiplier = 1 + agent.getBonuses().getFloatPercentAll(ModType.MeleeDamageModifier, SourceType.None);
double range = maxDmg - minDmg;
double damage = minDmg + ((ThreadLocalRandom.current().nextFloat() * range) + (ThreadLocalRandom.current().nextFloat() * range)) / 2;
if (AbstractWorldObject.IsAbstractCharacter(target))
if (((AbstractCharacter) target).isSit())
damage *= 2.5f; //increase damage if sitting
if (AbstractWorldObject.IsAbstractCharacter(target))
return (int) (((AbstractCharacter) target).getResists().getResistedDamage(agent, (AbstractCharacter) target, dt, (float) damage, 0) * dmgMultiplier);
return 0;
}
public static double getMinDmg(double min, Mob agent, ItemBase weapon) {
int primary = agent.getStatStrCurrent();
int secondary = agent.getStatDexCurrent();
int focusLevel = 0;
int masteryLevel = 0;
if (weapon != null) {
if (weapon.isStrBased() == true) {
primary = agent.getStatStrCurrent();
secondary = agent.getStatDexCurrent();
} else {
primary = agent.getStatDexCurrent();
secondary = agent.getStatStrCurrent();
if (agent.getSkills().containsKey(weapon.getSkillRequired())) {
focusLevel = (int) agent.getSkills().get(weapon.getSkillRequired()).getModifiedAmount();
}
if (agent.getSkills().containsKey(weapon.getMastery())) {
masteryLevel = (int) agent.getSkills().get(weapon.getMastery()).getModifiedAmount();
}
}
return min * (pow(0.0048 * primary + .049 * (primary - 0.75), 0.5) + pow(0.0066 * secondary + 0.064 * (secondary - 0.75), 0.5) + +0.01 * (focusLevel + masteryLevel));
}
return agent.getMinDamageHandOne();
}
public static double getMaxDmg(double max, Mob agent, ItemBase weapon) {
int primary = agent.getStatStrCurrent();
int secondary = agent.getStatDexCurrent();
int focusLevel = 0;
int masteryLevel = 0;
if (weapon != null) {
if (weapon.isStrBased() == true) {
primary = agent.getStatStrCurrent();
secondary = agent.getStatDexCurrent();
} else {
primary = agent.getStatDexCurrent();
secondary = agent.getStatStrCurrent();
}
if (agent.getSkills().containsKey(weapon.getSkillRequired()))
focusLevel = (int) agent.getSkills().get(weapon.getSkillRequired()).getModifiedAmount();
if (agent.getSkills().containsKey(weapon.getSkillRequired()))
masteryLevel = (int) agent.getSkills().get(weapon.getMastery()).getModifiedAmount();
return max * (pow(0.0124 * primary + 0.118 * (primary - 0.75), 0.5) + pow(0.0022 * secondary + 0.028 * (secondary - 0.75), 0.5) + 0.0075 * (focusLevel + masteryLevel));
}
return agent.getMaxDamageHandOne();
}
public static boolean MobCast(Mob mob) {
try {
// Method picks a random spell from a mobile's list of powers
// and casts it on the current target (or itself). Validation
// (including empty lists) is done previously within canCast();
ArrayList<Integer> powerTokens;
ArrayList<Integer> purgeTokens;
AbstractCharacter target = (AbstractCharacter) mob.getCombatTarget();
if (mob.behaviourType.callsForHelp)
MobAI.MobCallForHelp(mob);
// Generate a list of tokens from the mob powers for this mobile.
powerTokens = new ArrayList<>(mob.mobPowers.keySet());
purgeTokens = new ArrayList<>();
// If player has this effect on them currently then remove
// this token from our list.
for (int powerToken : powerTokens) {
PowersBase powerBase = PowersManager.getPowerByToken(powerToken);
for (ActionsBase actionBase : powerBase.getActions()) {
String stackType = actionBase.stackType;
if (target.getEffects() != null && target.getEffects().containsKey(stackType))
purgeTokens.add(powerToken);
}
}
powerTokens.removeAll(purgeTokens);
// Sanity check
if (powerTokens.isEmpty())
return false;
// Pick random spell from our list of powers
int powerToken = powerTokens.get(ThreadLocalRandom.current().nextInt(powerTokens.size()));
int powerRank = mob.mobPowers.get(powerToken);
PowersBase mobPower = PowersManager.getPowerByToken(powerToken);
//check for hit-roll
if (mobPower.requiresHitRoll)
if (triggerDefense(mob, mob.getCombatTarget()))
return false;
// Cast the spell
if (inRange2D(mob, mob.getCombatTarget(), mobPower.getRange())) {
PerformActionMsg msg;
if (!mobPower.isHarmful() || mobPower.targetSelf) {
PowersManager.useMobPower(mob, mob, mobPower, powerRank);
msg = PowersManager.createPowerMsg(mobPower, powerRank, mob, mob);
} else {
PowersManager.useMobPower(mob, target, mobPower, powerRank);
msg = PowersManager.createPowerMsg(mobPower, powerRank, mob, target);
}
msg.setUnknown04(2);
PowersManager.finishUseMobPower(msg, mob, 0, 0);
long randomCooldown = (long)((ThreadLocalRandom.current().nextInt(10,15) * 1000L) * MobAIThread.AI_CAST_FREQUENCY);
mob.nextCastTime = System.currentTimeMillis() + randomCooldown;
return true;
}
} catch (Exception e) {
Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: MobCast" + " " + e.getMessage());
}
return false;
}
public static boolean GuardCast(Mob mob) {
try {
// Method picks a random spell from a mobile's list of powers
// and casts it on the current target (or itself). Validation
// (including empty lists) is done previously within canCast();
ArrayList<Integer> powerTokens;
ArrayList<Integer> purgeTokens;
AbstractCharacter target = (AbstractCharacter) mob.getCombatTarget();
if (mob.behaviourType.callsForHelp)
MobAI.MobCallForHelp(mob);
// Generate a list of tokens from the mob powers for this mobile.
powerTokens = new ArrayList<>(mob.mobPowers.keySet());
purgeTokens = new ArrayList<>();
// If player has this effect on them currently then remove
// this token from our list.
for (int powerToken : powerTokens) {
PowersBase powerBase = PowersManager.getPowerByToken(powerToken);
for (ActionsBase actionBase : powerBase.getActions()) {
String stackType = actionBase.stackType;
if (target.getEffects() != null && target.getEffects().containsKey(stackType))
purgeTokens.add(powerToken);
}
}
powerTokens.removeAll(purgeTokens);
// Sanity check
if (powerTokens.isEmpty())
return false;
int powerToken;
int nukeRoll = ThreadLocalRandom.current().nextInt(1,100);
if (nukeRoll < 55) {
//use direct damage spell
powerToken = powerTokens.get(powerTokens.size() - 1);
} else {
//use random spell
powerToken = powerTokens.get(ThreadLocalRandom.current().nextInt(powerTokens.size()));
}
int powerRank = 1;
switch(mob.getRank()){
case 1:
powerRank = 10;
break;
case 2:
powerRank = 15;
break;
case 3:
powerRank = 20;
break;
case 4:
powerRank = 25;
break;
case 5:
powerRank = 30;
break;
case 6:
powerRank = 35;
break;
case 7:
powerRank = 40;
break;
}
PowersBase mobPower = PowersManager.getPowerByToken(powerToken);
//check for hit-roll
if (mobPower.requiresHitRoll)
if (triggerDefense(mob, mob.getCombatTarget()))
return false;
// Cast the spell
if (inRange2D(mob, mob.getCombatTarget(), mobPower.getRange())) {
PerformActionMsg msg;
if (!mobPower.isHarmful() || mobPower.targetSelf) {
if (mobPower.category.equals("DISPEL")) {
PowersManager.useMobPower(mob, target, mobPower, powerRank);
msg = PowersManager.createPowerMsg(mobPower, powerRank, mob, target);
} else {
PowersManager.useMobPower(mob, mob, mobPower, powerRank);
msg = PowersManager.createPowerMsg(mobPower, powerRank, mob, mob);
}
} else {
PowersManager.useMobPower(mob, target, mobPower, powerRank);
msg = PowersManager.createPowerMsg(mobPower, powerRank, mob, target);
}
msg.setUnknown04(2);
PowersManager.finishUseMobPower(msg, mob, 0, 0);
long randomCooldown = (long)((ThreadLocalRandom.current().nextInt(10,15) * 1000L) * MobAIThread.AI_CAST_FREQUENCY);
mob.nextCastTime = System.currentTimeMillis() + randomCooldown;
return true;
}
} catch (Exception e) {
Logger.info(mob.getObjectUUID() + " " + mob.getName() + " Failed At: MobCast" + " " + e.getMessage());
}
return false;
}
}
@@ -115,8 +115,39 @@ public class MovementUtilities {
}
public static void moveToLocation(Mob agent, Vector3fImmutable newLocation, float offset) {
agent.resetLastSetLocUpdate();
public static Vector3fImmutable GetMoveLocation(Mob aiAgent, AbstractCharacter aggroTarget) {
// Player isnt moving and neither is mob. Just return
// the mobile's current location. Ain't goin nowhere!
// *** Refactor: Check to ensure methods calling us
// all don't sent move messages when not moving.
if ((aggroTarget.isMoving() == false))
return aggroTarget.getLoc();
if (aggroTarget.getEndLoc().x != 0) {
float aggroTargetDistanceSquared = aggroTarget.getLoc().distanceSquared2D(aggroTarget.getEndLoc());
float aiAgentDistanceSquared = aiAgent.getLoc().distanceSquared2D(aggroTarget.getEndLoc());
if (aiAgentDistanceSquared >= aggroTargetDistanceSquared)
return aggroTarget.getEndLoc();
else {
float distanceToMove = sqrt(aggroTargetDistanceSquared + aiAgentDistanceSquared) * .5f;
return aggroTarget.getFaceDir().scaleAdd(distanceToMove, aggroTarget.getLoc());
}
}
// One of us is moving so let's calculate our destination loc for this
// simulation frame. We will simply project our position onto the
// character's movement vector and return the closest point.
return aiAgent.getLoc().ClosestPointOnLine(aggroTarget.getLoc(), aggroTarget.getEndLoc());
}
public static void moveToLocation(Mob agent, Vector3fImmutable newLocation, float offset, boolean isWalking) {
try {
//don't move farther than 30 units from player.
@@ -127,7 +158,7 @@ public class MovementUtilities {
agent.setFaceDir(newLoc.subtract2D(agent.getLoc()).normalize());
aiMove(agent, newLoc, false);
aiMove(agent, newLoc, isWalking);
} catch (Exception e) {
Logger.error(e.toString());
}
@@ -141,8 +172,32 @@ public class MovementUtilities {
return (agent.isAlive() && !agent.getBonuses().getBool(ModType.Stunned, SourceType.None) && !agent.getBonuses().getBool(ModType.CannotMove, SourceType.None));
}
public static Vector3fImmutable randomPatrolLocation(Mob agent, Vector3fImmutable center, float radius) {
//Determing where I want to move.
return new Vector3fImmutable((center.x - radius) + ((ThreadLocalRandom.current().nextFloat() + .1f * 2) * radius),
center.y,
(center.z - radius) + ((ThreadLocalRandom.current().nextFloat() + .1f * 2) * radius));
}
public static Long estimateMovementTime(Mob agent) {
if (agent.getEndLoc().x == 0 && agent.getEndLoc().y == 0)
return 0L;
return (long) ((agent.getLoc().distance2D(agent.getEndLoc()) * 1000) / agent.getSpeed());
}
public static void aiMove(Mob agent, Vector3fImmutable vect, boolean isWalking) {
//update our walk/run state.
if (isWalking && !agent.isWalk()) {
agent.setWalkMode(true);
MovementManager.sendRWSSMsg(agent);
} else if (!isWalking && agent.isWalk()) {
agent.setWalkMode(false);
MovementManager.sendRWSSMsg(agent);
}
MoveToPointMsg msg = new MoveToPointMsg();
@@ -189,10 +244,10 @@ public class MovementUtilities {
msg.setSourceID(agent.getObjectUUID());
msg.setStartCoord(startLoc);
msg.setEndCoord(endLoc);
msg.setUnknown01(-1);
msg.setInBuildingFloor(-1);
msg.setInBuilding(-1);
msg.setTargetType(0);
msg.setTargetID(0);
msg.setStartLocType(0);
msg.setInBuildingUUID(0);
try {
@@ -218,4 +273,23 @@ public class MovementUtilities {
return character.getLoc();
}
public static boolean updateMovementToCharacter(Mob aiAgent, AbstractCharacter aggroTarget) {
if (aiAgent.destination.equals(Vector3fImmutable.ZERO))
return true;
if (!aiAgent.isMoving())
return true;
if (aggroTarget.isMoving()) {
return !aiAgent.destination.equals(aggroTarget.getEndLoc()) && !aiAgent.destination.equals(aggroTarget.getLoc());
} else {
if (aiAgent.destination.equals(aggroTarget.getLoc()))
return false;
}
return false;
}
}
+1 -1
View File
@@ -28,7 +28,7 @@ import static engine.net.MessageDispatcher.maxRecipients;
/*
* Dispatch Message is the main interface to Magicbane's threaded
* asynch message delivery system.
* async message delivery system.
*/
public class DispatchMessage {
+1 -1
View File
@@ -97,7 +97,7 @@ public class NetMsgFactory {
// if (MBServerStatics.worldServerName.equals("Grief"))
Logger.error("Invalid protocol msg for player " + player.getFirstName() + " : " + opcode + " lastopcode: " + origin.lastProtocol.name() + " Error Code : " + errorCode);
} else
Logger.error("PROTOCOL ERROR: Player: " + ((ClientConnection) origin).getPlayerCharacter().getName() + " Account: " + ((ClientConnection) origin).getPlayerCharacter().getAccount().getUname() + "Invalid protocol msg : " + opcode + " lastopcode: " + origin.lastProtocol.name() + " Error Code : " + errorCode);
Logger.error("Invalid protocol msg : " + opcode + " lastopcode: " + origin.lastProtocol.name() + " Error Code : " + errorCode);
}
+92 -115
View File
@@ -9,7 +9,6 @@
package engine.net.client;
import engine.Enum;
import engine.Enum.*;
import engine.InterestManagement.WorldGrid;
import engine.exception.MsgSendException;
@@ -123,7 +122,6 @@ public class ClientMessagePump implements NetMsgHandler {
if (pc.isSit()) {
pc.setCombat(false);
pc.cancelOnSit();
pc.stopMovement(pc.loc);
}
UpdateStateMsg rwss = new UpdateStateMsg();
@@ -224,11 +222,6 @@ public class ClientMessagePump implements NetMsgHandler {
return;
}
if(msg.getSlotNumber() == 11 && pc.getRaceID() == 1999){
forceTransferFromEquipToInventory(msg, origin, "Saetor cannot wear shoes.");
return;
}
int uuid = msg.getUUID();
int slot = msg.getSlotNumber();
//System.out.println("loading to slot: " + slot);
@@ -561,32 +554,18 @@ public class ClientMessagePump implements NetMsgHandler {
if (i == null)
return;
if(i.getItemBaseID() == 7)
return; //cant delete gold
if (!itemManager.doesCharOwnThisItem(i.getObjectUUID()))
return;
if (!itemManager.inventoryContains(i))
return;
if(i.getItemBaseID() == 980066)
return;
if (i.canDestroy) {
int value = i.getItemBase().value;
if(i.getItemBase().isRune())
value = 500000;
if(sourcePlayer.getCharItemManager().getGoldInventory().getNumOfItems() + value > 10000000){
return;
}
if (i.isCanDestroy())
if (itemManager.delete(i) == true) {
sourcePlayer.getCharItemManager().addGoldToInventory(value,false);
sourcePlayer.getCharItemManager().updateInventory();
Dispatch dispatch = Dispatch.borrow(sourcePlayer, msg);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
}
}
}
private static void ackBankWindowOpened(AckBankWindowOpenedMsg msg, ClientConnection origin) {
@@ -664,7 +643,7 @@ public class ClientMessagePump implements NetMsgHandler {
moveMsg.setStartCoord(sourcePlayer.getLoc());
moveMsg.setEndCoord(sourcePlayer.getLoc());
moveMsg.setInBuilding(-1);
moveMsg.setUnknown01(-1);
moveMsg.setInBuildingFloor(-1);
dispatch = Dispatch.borrow(sourcePlayer, moveMsg);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
@@ -1379,171 +1358,219 @@ public class ClientMessagePump implements NetMsgHandler {
}
private static void buyFromNPC(BuyFromNPCMsg msg, ClientConnection origin) {
PlayerCharacter sourcePlayer = SessionManager.getPlayerCharacter(origin);
if (sourcePlayer == null)
return;
if (origin.buyLock.tryLock()) {
try {
CharacterItemManager itemMan = sourcePlayer.getCharItemManager();
if (itemMan == null) {
if (itemMan == null)
return;
}
NPC npc = NPC.getFromCache(msg.getNPCID());
if (npc == null) {
if (npc == null)
return;
}
Item gold = itemMan.getGoldInventory();
if (gold == null) {
if (gold == null)
return;
}
Item buy = null;
if (msg.getItemType() == GameObjectType.MobEquipment.ordinal()) {
ArrayList<MobEquipment> sellInventory = npc.getContract().getSellInventory();
if (sellInventory == null) {
if (sellInventory == null)
return;
}
for (MobEquipment me : sellInventory) {
if (me.getObjectUUID() == msg.getItemID()) {
ItemBase ib = me.getItemBase();
if (ib == null) {
if (ib == null)
return;
}
//test room available for item
if (!itemMan.hasRoomInventory(ib.getWeight())) {
if (!itemMan.hasRoomInventory(ib.getWeight()))
return;
}
int cost = me.magicValue;
if(npc.getContractID() == 1201 && me.getItemBase().getName().equals("Prospector"))
cost = 50;
int cost = me.getMagicValue();
float bargain = sourcePlayer.getBargain();
float profit = npc.getSellPercent(sourcePlayer) - bargain;
if(me.getItemBase().getType().equals(ItemType.POTION))
profit -= 1.0f;
if (profit < 1)
profit = 1;
if(npc.getContractID() == 900){
cost = Warehouse.getCostForResource(ib.getUUID()) * Warehouse.getSellStackSize(ib.getUUID());
}
cost *= profit;
if (gold.getNumOfItems() - cost < 0) {
//dont' have enough goldItem exit!
// chatMan.chatSystemInfo(pc, "" + "You dont have enough gold.");
return;
}
Building b = (!npc.isStatic()) ? npc.getBuilding() : null;
if (b != null && b.getProtectionState().equals(ProtectionState.NPC))
b = null;
int buildingDeposit = cost - me.getMagicValue();
if (b != null && (b.getStrongboxValue() + buildingDeposit) > b.getMaxGold() && !b.isOwnerIsNPC()) {
if (b != null && (b.getStrongboxValue() + buildingDeposit) > b.getMaxGold()) {
ErrorPopupMsg.sendErrorPopup(sourcePlayer, 206);
return;
}
if (!itemMan.buyFromNPC(b, cost, buildingDeposit)) {
// chatMan.chatSystemInfo(pc, "" + "You Failed to buy the item.");
ChatManager.chatSystemError(sourcePlayer, "Failed To Buy Item");
return;
}
if(me.getItemBase().getType().equals(ItemType.RESOURCE) && npc.getContractID() == 900){
handleResourcePurchase(me,itemMan,npc,buy,sourcePlayer,ib);
}else {
buy = Item.createItemForPlayer(sourcePlayer, ib);
if (buy != null) {
me.transferEnchants(buy);
itemMan.addItemToInventory(buy);
if(npc.contractUUID == 900 && buy.getItemBaseID() == 1705032){
buy.setNumOfItems(10);
DbManager.ItemQueries.UPDATE_NUM_ITEMS(buy,buy.getNumOfItems());
}
//itemMan.updateInventory();
}
buy = Item.createItemForPlayer(sourcePlayer, ib);
if (buy != null) {
me.transferEnchants(buy);
itemMan.addItemToInventory(buy);
//itemMan.updateInventory();
}
}
}
} else if (msg.getItemType() == GameObjectType.Item.ordinal()) {
CharacterItemManager npcCim = npc.getCharItemManager();
if (npcCim == null)
return;
buy = Item.getFromCache(msg.getItemID());
if (buy == null)
return;
ItemBase ib = buy.getItemBase();
if (ib == null)
return;
if (!npcCim.inventoryContains(buy))
return;
//test room available for item
if (!itemMan.hasRoomInventory(ib.getWeight()))
return;
//TODO test cost and subtract goldItem
//TODO CHnage this if we ever put NPc city npcs in buildings.
int cost = buy.getBaseValue();
if (buy.isID() || buy.isCustomValue())
cost = buy.getMagicValue();
float bargain = sourcePlayer.getBargain();
float profit = npc.getSellPercent(sourcePlayer) - bargain;
if (profit < 1)
profit = 1;
if (!buy.isCustomValue())
cost *= profit;
else
cost = buy.getValue();
if (gold.getNumOfItems() - cost < 0) {
ErrorPopupMsg.sendErrorPopup(sourcePlayer, 128); // Insufficient Gold
return;
}
Building b = (!npc.isStatic()) ? npc.getBuilding() : null;
if (b != null)
if (b.getProtectionState().equals(ProtectionState.NPC))
b = null;
int buildingDeposit = cost;
if (b != null && (b.getStrongboxValue() + buildingDeposit) > b.getMaxGold() && !b.isOwnerIsNPC()) {
if (b != null && (b.getStrongboxValue() + buildingDeposit) > b.getMaxGold()) {
ErrorPopupMsg.sendErrorPopup(sourcePlayer, 206);
return;
}
if (!itemMan.buyFromNPC(b, cost, buildingDeposit)) {
ErrorPopupMsg.sendErrorPopup(sourcePlayer, 110);
return;
}
if (buy != null)
itemMan.buyFromNPC(buy, npc);
} else if (msg.getItemType() == GameObjectType.MobLoot.ordinal()) {
CharacterItemManager npcCim = npc.getCharItemManager();
if (npcCim == null)
return;
buy = MobLoot.getFromCache(msg.getItemID());
if (buy == null)
return;
ItemBase ib = buy.getItemBase();
if (ib == null)
return;
if (!npcCim.inventoryContains(buy))
return;
//test room available for item
if (!itemMan.hasRoomInventory(ib.getWeight()))
return;
//TODO test cost and subtract goldItem
//TODO CHnage this if we ever put NPc city npcs in buildings.
int cost = buy.getMagicValue();
cost *= npc.getSellPercent(sourcePlayer);
if (gold.getNumOfItems() - cost < 0) {
ErrorPopupMsg.sendErrorPopup(sourcePlayer, 128); // Insufficient Gold
return;
}
Building b = (!npc.isStatic()) ? npc.getBuilding() : null;
if (b != null && b.getProtectionState().equals(ProtectionState.NPC))
b = null;
int buildingDeposit = cost;
if (b != null && (b.getStrongboxValue() + buildingDeposit) > b.getMaxGold() && !b.isOwnerIsNPC()) {
if (b != null && (b.getStrongboxValue() + buildingDeposit) > b.getMaxGold()) {
ErrorPopupMsg.sendErrorPopup(sourcePlayer, 206);
return;
}
if (!itemMan.buyFromNPC(b, cost, buildingDeposit))
return;
if (buy != null)
itemMan.buyFromNPC(buy, npc);
} else
return;
if (buy != null) {
msg.setItem(buy);
//send the buy message back to update player
// msg.setItemType(buy.getObjectType().ordinal());
@@ -1552,44 +1579,16 @@ public class ClientMessagePump implements NetMsgHandler {
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
itemMan.updateInventory();
}
} finally {
origin.buyLock.unlock();
}
} else {
ErrorPopupMsg.sendErrorPopup(origin.getPlayerCharacter(), 12); // All production slots taken
}
}
public static void handleResourcePurchase(MobEquipment me, CharacterItemManager itemMan, NPC npc, Item buy, PlayerCharacter sourcePlayer, ItemBase ib){
boolean stacked = false;
int buystack = Warehouse.getSellStackSize(me.getItemBase().getUUID());
for(Item item : itemMan.getInventory()){
int itemID = item.getItemBaseID();
int meID = me.getItemBase().getUUID();
if(itemID == meID){
if(Warehouse.maxResources.isEmpty())
Warehouse.getMaxResources();
int maxStack = Warehouse.maxResources.get(itemID);
if(maxStack > item.getNumOfItems() + buystack){
item.setNumOfItems(item.getNumOfItems() + buystack);
stacked = true;
itemMan.updateInventory();
DbManager.ItemQueries.UPDATE_NUM_ITEMS(item,item.getNumOfItems());
break;
}
}
}
if(!stacked){
buy = Item.createItemForPlayer(sourcePlayer, ib);
if (buy != null) {
me.transferEnchants(buy);
itemMan.addItemToInventory(buy);
buy.setNumOfItems(buystack);
DbManager.ItemQueries.UPDATE_NUM_ITEMS(buy,buy.getNumOfItems());
}
}
itemMan.updateInventory();
}
private static void Repair(RepairMsg msg, ClientConnection origin) {
PlayerCharacter player = SessionManager.getPlayerCharacter(origin);
@@ -1632,8 +1631,8 @@ public class ClientMessagePump implements NetMsgHandler {
if (toRepair == null)
return;
//if (toRepair.getItemBase().isGlass())
// return;
if (toRepair.getItemBase().isGlass())
return;
//make sure item is in player's inventory or equipment
if (!itemMan.inventoryContains(toRepair) && !itemMan.equippedContains(toRepair))
@@ -1655,12 +1654,6 @@ public class ClientMessagePump implements NetMsgHandler {
}
//TODO get cost to repair
int cost = (int) ((max - dur) * 80.1);
//glass costs 3x as much to repair
if (toRepair.getItemBase().isGlass()){
cost *= 3;
}
Building b = (!npc.isStatic()) ? npc.getBuilding() : null;
if (b != null)
@@ -1895,25 +1888,9 @@ public class ClientMessagePump implements NetMsgHandler {
break;
case LEAVEREQUEST:
origin.disconnect();
ArrayList<PlayerCharacter> sameMachine = new ArrayList<>();
for (PlayerCharacter pc : SessionManager.getAllActivePlayers()) {
if(origin.machineID.equals(pc.getClientConnection().machineID))
sameMachine.add(pc);
}
if(sameMachine.isEmpty() == false){
if(sameMachine.get(0) != null) {
sameMachine.get(0).isBoxed = false;
sameMachine.get(0).removeEffectBySource(EffectSourceType.DeathShroud,41,true);
ChatManager.chatSystemInfo(sameMachine.get(0), "You Are No Longer Flagged 'Boxed'");
}
}
break;
case POWER:
PowersManager.usePower((PerformActionMsg) msg, origin, false);
//PowersManager.static_power_que.add(new PowersManager.PowerQueObject((PerformActionMsg) msg, origin, false));
break;
case REQUESTMELEEATTACK:
CombatManager.setAttackTarget((AttackCmdMsg) msg, origin);
break;
case READYTOENTER:
break;
+1 -1
View File
@@ -173,7 +173,7 @@ public enum Protocol {
REPAIROBJECT(0x782219CE, RepairMsg.class, null), //Repair Window Req/Ack, RepairObject item Req/Ack
REQUESTCONTENTS(0xA786B0A2, LootWindowRequestMsg.class, null), // MoveObjectToContainer Window Request
REQUESTGUILDLIST(0x85DCC6D7, ReqGuildListMsg.class, RequestGuildListHandler.class),
REQUESTMELEEATTACK(0x98C71545, AttackCmdMsg.class, null), // Attack
REQUESTMELEEATTACK(0x98C71545, AttackCmdMsg.class, AttackCmdMsgHandler.class), // Attack
REQUESTMEMBERLIST(0x3235E5EA, GuildControlMsg.class, GuildControlHandler.class), // Part of Promote/Demote, Also Player History
REQUESTTOOPENBANK(0xF26E453F, null, null), // RequestToOpenBankMsg
REQUESTTOTRADE(0x4D84259B, TradeRequestMsg.class, null), // Trade Request
@@ -57,21 +57,6 @@ public class ActivateNPCMsgHandler extends AbstractClientMsgHandler {
if (contract.canSlotinBuilding(building))
ItemLists.add(hirelings);
if(building.getBlueprint().getBuildingGroup().equals(Enum.BuildingGroup.TOL)){
if(contract.getContractID() == 899)//alchemist
ItemLists.add(hirelings);
if(contract.getContractID() == 866)//banker
ItemLists.add(hirelings);
if(contract.getContractID() == 865)//siege engineer
ItemLists.add(hirelings);
}
if(building.getBlueprint().getBuildingGroup().equals(Enum.BuildingGroup.SIEGETENT)){
if(contract.getContractID() == 865)//siege engineer
ItemLists.add(hirelings);
}
}
}
@@ -93,20 +78,13 @@ public class ActivateNPCMsgHandler extends AbstractClientMsgHandler {
return false;
}
if (building.getBlueprint().getSlotsForRank(building.getRank()) == building.getHirelings().size())
if (building.getBlueprint().getMaxSlots() == building.getHirelings().size())
return false;
Item contractItem = Item.getFromCache(msg.getContractItem());
if (contractItem == null)
return false;
if (msg.getContractItem() == 850) {//runemaster
for (AbstractCharacter abs : building.getHirelings().keySet()) {
NPC npc = (NPC) abs;
if (npc.contract.getContractID() == 850)
return false; //can only have 1 runemaster
}
}
if (!player.getCharItemManager().doesCharOwnThisItem(contractItem.getObjectUUID())) {
Logger.error(player.getName() + "has attempted to place Hireling : " + contractItem.getName() + "without a valid contract!");
@@ -126,33 +104,10 @@ public class ActivateNPCMsgHandler extends AbstractClientMsgHandler {
return false;
// Check if contract can be slotted in this building
//Logger.error("inserting contract: " + contract.getContractID());
if (contract.canSlotinBuilding(building) == false) {
boolean override = false;
if (building.getBlueprint().getBuildingGroup().equals(Enum.BuildingGroup.TOL)) {
if (contract.getContractID() == 899)//alchemist
override = true;
if (contract.getContractID() == 866)//banker
override = true;
if (contract.canSlotinBuilding(building) == false)
return false;
if (contract.getContractID() == 865)//siege engineer
override = true;
}
if (building.getBlueprint().getBuildingGroup().equals(Enum.BuildingGroup.SIEGETENT)) {
if (contract.getContractID() == 865)//siege engineer
override = true;
}
if(building.getBlueprint().getBuildingGroup().equals(Enum.BuildingGroup.SIEGETENT)){
if(contract.getContractID() == 865)//siege engineer
override = true;
}
if(override == false) {
Logger.error("failed at override with contract: " + contract.getContractID());
return false;
}
}
//Logger.error("override successful: " + contract.getContractID());
if (!BuildingManager.addHireling(building, player, zone, contract, contractItem))
return false;
@@ -53,7 +53,7 @@ public class ArcLoginNotifyMsgHandler extends AbstractClientMsgHandler {
GroupManager.RefreshOthersGroupList(player);
}
player.enteredWorld = true;
player.setEnteredWorld(true);
// Set player active
player.resetRegenUpdateTime();
player.setActive(true);
@@ -66,9 +66,6 @@ public class ArcLoginNotifyMsgHandler extends AbstractClientMsgHandler {
// Send Guild, Nation and IC MOTD
GuildManager.enterWorldMOTD(player);
ChatManager.sendSystemMessage(player, ConfigManager.MB_WORLD_GREETING.getValue());
ChatManager.sendSystemMessage(player, "Gold Drop Rate: " + ConfigManager.MB_NORMAL_GOLD_RATE.getValue());
ChatManager.sendSystemMessage(player, "Loot Drop Rate: " + ConfigManager.MB_NORMAL_DROP_RATE.getValue());
ChatManager.sendSystemMessage(player, "Experience Rate: " + ConfigManager.MB_NORMAL_EXP_RATE.getValue());
// Send branch string if available from ConfigManager.
@@ -0,0 +1,86 @@
package engine.net.client.handlers;
import engine.Enum;
import engine.exception.MsgSendException;
import engine.gameManager.BuildingManager;
import engine.gameManager.CombatManager;
import engine.net.client.ClientConnection;
import engine.net.client.msg.AttackCmdMsg;
import engine.net.client.msg.ClientNetMsg;
import engine.net.client.msg.TargetedActionMsg;
import engine.objects.*;
/*
* @Author:
* @Summary: Processes application protocol message which keeps
* client's tcp connection open.
*/
public class AttackCmdMsgHandler extends AbstractClientMsgHandler {
public AttackCmdMsgHandler() {
super(AttackCmdMsg.class);
}
@Override
protected boolean _handleNetMsg(ClientNetMsg baseMsg, ClientConnection origin) throws MsgSendException {
PlayerCharacter playerCharacter = origin.getPlayerCharacter();
// Member variable declaration
AttackCmdMsg msg;
// Member variable assignment
msg = (AttackCmdMsg) baseMsg;
if (TargetedActionMsg.un2cnt == 60 || TargetedActionMsg.un2cnt == 70)
return true;
if (playerCharacter == null)
return true;
AbstractWorldObject target = null;
Enum.GameObjectType targetType;
targetType = Enum.GameObjectType.values()[msg.getTargetType()];
switch(targetType){
case Mob:
target = Mob.getMob(msg.getTargetID());
break;
case PlayerCharacter:
target = PlayerCharacter.getPlayerCharacter(msg.getTargetID());
break;
case Building:
target = BuildingManager.getBuilding(msg.getTargetID());
break;
case NPC:
target = NPC.getNPC(msg.getTargetID());
break;
}
if(target == null) {
playerCharacter.setCombatTarget(null);
return true; // cannot attack a null target
}
//set sources target
playerCharacter.setCombatTarget(target);
//put in combat if not already
if (!playerCharacter.isCombat())
CombatManager.toggleCombat(true, origin);
//make character stand if sitting
if (playerCharacter.isSit())
CombatManager.toggleSit(false, origin);
CombatManager.AttackTarget(playerCharacter, target);
return true;
}
}
@@ -14,17 +14,18 @@ import engine.Enum.GuildHistoryType;
import engine.exception.MsgSendException;
import engine.gameManager.ChatManager;
import engine.gameManager.DbManager;
import engine.gameManager.GroupManager;
import engine.gameManager.SessionManager;
import engine.net.Dispatch;
import engine.net.DispatchMessage;
import engine.net.client.ClientConnection;
import engine.net.client.msg.ClientNetMsg;
import engine.net.client.msg.ErrorPopupMsg;
import engine.net.client.msg.group.GroupUpdateMsg;
import engine.net.client.msg.guild.BanishUnbanishMsg;
import engine.net.client.msg.guild.GuildListMsg;
import engine.objects.*;
import engine.objects.Guild;
import engine.objects.GuildHistory;
import engine.objects.GuildStatusController;
import engine.objects.PlayerCharacter;
import org.joda.time.DateTime;
public class BanishUnbanishHandler extends AbstractClientMsgHandler {
@@ -115,20 +116,6 @@ public class BanishUnbanishHandler extends AbstractClientMsgHandler {
GuildListMsg guildListMsg = new GuildListMsg(guild);
dispatch = Dispatch.borrow(source, guildListMsg);
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
if(GroupManager.getGroup(target) != null) {
Group group = GroupManager.getGroup(target);
group.removeGroupMember(PlayerCharacter.getPlayerCharacter(target));
GroupManager.removeFromGroups(PlayerCharacter.getPlayerCharacter(target));
GroupUpdateMsg gim;
gim = new GroupUpdateMsg();
gim.setGroup(group);
gim.setMessageType(3);
gim.setPlayer(PlayerCharacter.getPlayerCharacter(target));
group.sendUpdate(gim);
String text = PlayerCharacter.getPlayerCharacter(target).getFirstName() + " has left your group.";
ChatManager.chatGroupInfo(source, text);
}
} else {
ErrorPopupMsg.sendErrorPopup(source, 103); // You may not banish this char
}
@@ -61,6 +61,15 @@ public class CityDataHandler extends AbstractClientMsgHandler {
dispatch = Dispatch.borrow(playerCharacter, cityDataMsg);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
// If the hotZone has changed then update the client's map accordingly.
if (playerCharacter.getTimeStamp("hotzoneupdate") <= ZoneManager.hotZoneLastUpdate.toEpochMilli() && ZoneManager.hotZone != null) {
HotzoneChangeMsg hotzoneChangeMsg = new HotzoneChangeMsg(Enum.GameObjectType.Zone.ordinal(), ZoneManager.hotZone.getObjectUUID());
dispatch = Dispatch.borrow(playerCharacter, hotzoneChangeMsg);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
playerCharacter.setTimeStamp("hotzoneupdate", System.currentTimeMillis() - 100);
}
// Serialize the realms for this map
WorldRealmMsg worldRealmMsg = new WorldRealmMsg();
@@ -62,7 +62,7 @@ public class DestroyBuildingHandler extends AbstractClientMsgHandler {
if (city != null)
bane = city.getBane();
if (bane != null) {
if (bane != null && bane.getSiegePhase() == Enum.SiegePhase.WAR) {
ErrorPopupMsg.sendErrorPopup(pc, 171);
return true;
}
@@ -71,12 +71,9 @@ public class DestroyBuildingHandler extends AbstractClientMsgHandler {
if (blueprint.getBuildingGroup() == BuildingGroup.TOL)
return true;
// destorying a shrine will yield a rubble pile for looting
if (blueprint.getBuildingGroup() == BuildingGroup.SHRINE) {
building.modifyHealth(-building.getHealth(), origin.getPlayerCharacter());
building.destroyOrDerank(origin.getPlayerCharacter());
// Can't destroy a shrine
if (blueprint.getBuildingGroup() == BuildingGroup.SHRINE)
return true;
}
// Cannot destroy mines outside of normal mine mechanics
@@ -21,7 +21,6 @@ import engine.net.client.msg.ClientNetMsg;
import engine.net.client.msg.group.GroupInviteMsg;
import engine.net.client.msg.group.GroupUpdateMsg;
import engine.objects.Group;
import engine.objects.Guild;
import engine.objects.PlayerCharacter;
public class GroupInviteHandler extends AbstractClientMsgHandler {
@@ -104,12 +103,6 @@ public class GroupInviteHandler extends AbstractClientMsgHandler {
if (target.isIgnoringPlayer(source))
return false;
if(source.getGuild().getNation().equals(target.getGuild().getNation()) == false)
return false; // cannot group outside of nation
if(source.getGuild().getNation().equals(target.getGuild().getNation()) && source.getGuild().getNation().equals(Guild.getErrantGuild()))
if(source.getGuild().equals(target.getGuild()) == false)
return false; // cannot group as an errant guild with other errant guilds
// dont block invites to people already in a group and
// dont check for pending invites, the client does it
@@ -25,8 +25,6 @@ import engine.objects.Guild;
import engine.objects.GuildStatusController;
import engine.objects.PlayerCharacter;
import static engine.objects.Bane.getBaneByAttackerGuild;
public class InviteToSubHandler extends AbstractClientMsgHandler {
public InviteToSubHandler() {
@@ -97,25 +95,6 @@ public class InviteToSubHandler extends AbstractClientMsgHandler {
if (sourceGuild.equals(targetGuild))
return true;
if(sourceGuild.getNation().getOwnedCity().getBane() != null)
return true; // cannot invite guilds to sub if you are baned
if(sourceGuild.getNation().getSubGuildList() != null){
for(Guild subGuild : sourceGuild.getNation().getSubGuildList()){
if(subGuild.getOwnedCity() != null)
if(subGuild.getOwnedCity().getBane() != null)
return true;//cannot invite guilds to sub if any tree in your nation has a bane on it
}
}
if(targetGuild.getOwnedCity() != null)
if(targetGuild.getOwnedCity().getBane() != null)
return true; // cannot be subbed if you have a bane placed on you
if(getBaneByAttackerGuild(targetGuild) != null)
return true; // cannot sub to a nation if they have a bane placed
//target must be GL or IC
if (GuildStatusController.isInnerCouncil(target.getGuildStatus()) == false && GuildStatusController.isGuildLeader(target.getGuildStatus()) == false) {
@@ -12,15 +12,16 @@ package engine.net.client.handlers;
import engine.Enum.GuildHistoryType;
import engine.exception.MsgSendException;
import engine.gameManager.ChatManager;
import engine.gameManager.GroupManager;
import engine.gameManager.SessionManager;
import engine.net.Dispatch;
import engine.net.DispatchMessage;
import engine.net.client.ClientConnection;
import engine.net.client.msg.ClientNetMsg;
import engine.net.client.msg.group.GroupUpdateMsg;
import engine.net.client.msg.guild.LeaveGuildMsg;
import engine.objects.*;
import engine.objects.Guild;
import engine.objects.GuildStatusController;
import engine.objects.Mine;
import engine.objects.PlayerCharacter;
public class LeaveGuildHandler extends AbstractClientMsgHandler {
@@ -60,21 +61,6 @@ public class LeaveGuildHandler extends AbstractClientMsgHandler {
return true;
}
if(GroupManager.getGroup(playerCharacter) != null) {
Group group = GroupManager.getGroup(playerCharacter);
group.removeGroupMember(playerCharacter);
GroupManager.removeFromGroups(playerCharacter);
GroupUpdateMsg gim;
gim = new GroupUpdateMsg();
gim.setGroup(group);
gim.setMessageType(3);
gim.setPlayer(playerCharacter);
group.sendUpdate(gim);
String text = playerCharacter.getFirstName() + " has left your group.";
ChatManager.chatGroupInfo(playerCharacter, text);
}
// Send left guild message to rest of guild
ChatManager.chatGuildInfo(oldGuild, playerCharacter.getFirstName() + " has left the guild.");
@@ -5,7 +5,6 @@ import engine.Enum.DispatchChannel;
import engine.Enum.GameObjectType;
import engine.exception.MsgSendException;
import engine.gameManager.BuildingManager;
import engine.gameManager.DbManager;
import engine.gameManager.SessionManager;
import engine.gameManager.ZoneManager;
import engine.math.Bounds;
@@ -63,6 +62,7 @@ public class ManageCityAssetMsgHandler extends AbstractClientMsgHandler {
Building building;
msg = (ManageCityAssetsMsg) baseMsg;
player = SessionManager.getPlayerCharacter(origin);
if (player == null)
@@ -72,21 +72,34 @@ public class ManageCityAssetMsgHandler extends AbstractClientMsgHandler {
if (building == null) {
if (msg.actionType == 14) {
Zone zone = ZoneManager.findSmallestZone(player.getLoc());
if (!zone.isPlayerCity()) {
ErrorPopupMsg.sendErrorMsg(player, "Unable to find city to command.");
return true;
}
City city = City.GetCityFromCache(zone.getPlayerCityUUID());
if (city == null || !city.getGuild().equals(player.getGuild()) ||
(!GuildStatusController.isInnerCouncil(player.getGuildStatus()) &&
!GuildStatusController.isGuildLeader(player.getGuildStatus()))) {
if (city == null) {
ErrorPopupMsg.sendErrorMsg(player, "Unable to find city to command.");
return true;
}
if (!city.getGuild().equals(player.getGuild())) {
ErrorPopupMsg.sendErrorMsg(player, "You are not in the correct guild to command this city.");
return true;
}
if (!GuildStatusController.isInnerCouncil(player.getGuildStatus()) && !GuildStatusController.isGuildLeader(player.getGuildStatus())) {
ErrorPopupMsg.sendErrorMsg(player, "You must be an Inner Council or Guild leader to access city commands.");
return true;
}
ManageCityAssetsMsg mca = new ManageCityAssetsMsg(player, building);
mca.actionType = 15;
DispatchMessage.dispatchMsgDispatch(Dispatch.borrow(player, mca), DispatchChannel.SECONDARY);
Dispatch dispatch = Dispatch.borrow(player, mca);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
}
return true;
}
@@ -98,126 +111,181 @@ public class ManageCityAssetMsgHandler extends AbstractClientMsgHandler {
outMsg.setTargetType(building.getObjectType().ordinal());
outMsg.setTargetID(building.getObjectUUID());
outMsg.setAssetName(building.getName());
DispatchMessage.dispatchMsgDispatch(Dispatch.borrow(player, outMsg), DispatchChannel.SECONDARY);
Dispatch dispatch = Dispatch.borrow(player, outMsg);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
return true;
}
switch (msg.actionType) {
case 2:
case 22:
if (building.getBlueprint() != null && building.getBlueprint().getBuildingGroup() == engine.Enum.BuildingGroup.BANESTONE) {
outMsg.actionType = 18;
outMsg.setTargetType(building.getObjectType().ordinal());
outMsg.setTargetID(building.getObjectUUID());
} else if (BuildingManager.playerCanManage(player, building)) {
configWindowState(player, building, outMsg);
outMsg.actionType = 3;
outMsg.setTargetType(building.getObjectType().ordinal());
outMsg.setTargetID(building.getObjectUUID());
outMsg.setTargetType3(building.getObjectType().ordinal());
outMsg.setTargetID3(building.getObjectUUID());
outMsg.setUnknown54(1);
} else {
// Handle other cases
if (building.getRank() == -1) {
if (!Bounds.collide(player.getLoc(), building)) {
ErrorPopupMsg.sendErrorPopup(player, 64);
return true;
}
switch (building.getBlueprint().getBuildingGroup()) {
case SHRINE:
Shrine shrine = Shrine.shrinesByBuildingUUID.get(building.getObjectUUID());
if (shrine == null || shrine.getFavors() == 0) {
ErrorPopupMsg.sendErrorPopup(player, 166); // There is no more favor in this shrine to loot
return true;
}
//loot elan stones
MobLoot elanStones = new MobLoot(player,ItemBase.getItemBase(1705032),1,false);
Item promotedItem = elanStones.promoteToItem(player);
promotedItem.setNumOfItems(shrine.getFavors());
player.getCharItemManager().addItemToInventory(promotedItem);
DbManager.ItemQueries.UPDATE_NUM_ITEMS(promotedItem,promotedItem.getNumOfItems());
player.getCharItemManager().updateInventory();
shrine.setFavors(0);
break;
case WAREHOUSE:
Warehouse warehouse = Warehouse.warehouseByBuildingUUID.get(building.getObjectUUID());
if (warehouse == null || warehouse.isEmpty()) {
ErrorPopupMsg.sendErrorPopup(player, 167); // no more resources.
return true;
}
break;
}
}
AbstractCharacter owner = building.getOwner();
if (owner == null) {
msg.actionType = 4;
DispatchMessage.dispatchMsgDispatch(Dispatch.borrow(player, msg), DispatchChannel.SECONDARY);
} else {
outMsg.actionType = 4;
outMsg.setTargetType(building.getObjectType().ordinal());
outMsg.setTargetID(building.getObjectUUID());
outMsg.setAssetName(building.getName());
}
}
DispatchMessage.dispatchMsgDispatch(Dispatch.borrow(player, outMsg), DispatchChannel.SECONDARY);
return true;
case 13:
outMsg.actionType = 13;
DispatchMessage.dispatchMsgDispatch(Dispatch.borrow(player, outMsg), DispatchChannel.SECONDARY);
return true;
case 5:
building.setName(msg.getAssetName());
if (msg.actionType == 2 || msg.actionType == 22) {
if (building.getBlueprint() != null && building.getBlueprint().getBuildingGroup() == engine.Enum.BuildingGroup.BANESTONE) {
outMsg.actionType = 18;
outMsg.setTargetType(building.getObjectType().ordinal());
outMsg.setTargetID(building.getObjectUUID());
} else if (BuildingManager.playerCanManage(player, building)) { //TODO allow Friends list.
configWindowState(player, building, outMsg);
outMsg.actionType = 3;
outMsg.setTargetType(building.getObjectType().ordinal());
outMsg.setTargetID(building.getObjectUUID());
outMsg.setTargetType3(GameObjectType.Building.ordinal());
outMsg.setTargetType3(building.getObjectType().ordinal());
outMsg.setTargetID3(building.getObjectUUID());
outMsg.setAssetName1(building.getName());
outMsg.setUnknown54(1);
DispatchMessage.dispatchMsgDispatch(Dispatch.borrow(player, outMsg), DispatchChannel.SECONDARY);
return true;
case 14:
ManageCityAssetsMsg mca = new ManageCityAssetsMsg(player, building);
mca.actionType = 15;
DispatchMessage.dispatchMsgDispatch(Dispatch.borrow(player, mca), DispatchChannel.SECONDARY);
return true;
case 20:
// Handle case 20
return handleCase20(player, outMsg, building, msg, origin);
default:
return true;
}
}
private boolean handleCase20(PlayerCharacter player, ManageCityAssetsMsg outMsg, Building building, ManageCityAssetsMsg msg, ClientConnection origin) throws MsgSendException {
Zone baneZone = building.getParentZone();
if (baneZone == null)
return true;
City banedCity = City.getCity(baneZone.getPlayerCityUUID());
if (banedCity == null)
return true;
Bane bane = banedCity.getBane();
if (bane == null || bane.getLiveDate() != null || player.getGuild() != banedCity.getGuild() || !GuildStatusController.isInnerCouncil(player.getGuildStatus()))
return true;
int baneHour = msg.getBaneHour();
if (baneHour < 16 || baneHour > 24) {
PlaceAssetMsg.sendPlaceAssetError(origin, 1, "A Serious error has occurred. Please post details for to ensure transaction integrity");
} else {
if (building.getBlueprintUUID() != 0)
switch (building.getBlueprint().getBuildingGroup()) {
case SHRINE:
if (building.getRank() == -1) {
if (!Bounds.collide(player.getLoc(), building)) {
ErrorPopupMsg.sendErrorPopup(player, 64);
return true;
}
Shrine shrine = Shrine.shrinesByBuildingUUID.get(building.getObjectUUID());
if (shrine == null)
return true;
if (shrine.getFavors() == 0) {
ErrorPopupMsg.sendErrorPopup(player, 166); // There is no more favor in this shrine to loot
return true;
}
BuildingManager.lootBuilding(player, building);
return true;
}
break;
case WAREHOUSE:
//TODO check
if (building.getRank() == -1) {
if (!Bounds.collide(player.getLoc(), building)) {
ErrorPopupMsg.sendErrorPopup(player, 64);
return true;
}
Warehouse warehouse = Warehouse.warehouseByBuildingUUID.get(building.getObjectUUID());
if (warehouse == null)
return true;
if (warehouse.isEmpty()) {
ErrorPopupMsg.sendErrorPopup(player, 167); // no more resources.
return true;
}
BuildingManager.lootBuilding(player, building);
return true;
}
}
if (building.getRank() == -1)
return true;
AbstractCharacter owner = building.getOwner();
//no owner, send building info
if (owner == null) {
msg.actionType = 4;
Dispatch dispatch = Dispatch.borrow(player, msg);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
return true;
}
outMsg.actionType = 4;
outMsg.setTargetType(building.getObjectType().ordinal());
outMsg.setTargetID(building.getObjectUUID());
outMsg.setAssetName(building.getName());
}
Dispatch dispatch = Dispatch.borrow(player, outMsg);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
return true;
}
if (msg.actionType == 13) {
outMsg.actionType = 13;
Dispatch dispatch = Dispatch.borrow(player, outMsg);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
return true;
}
//Rename Building.
if (msg.actionType == 5) {
//TODO we need to check names before allowing
building.setName(msg.getAssetName());
configWindowState(player, building, outMsg);
outMsg.actionType = 3;
outMsg.setTargetType(building.getObjectType().ordinal());
outMsg.setTargetID(building.getObjectUUID());
outMsg.setTargetType3(GameObjectType.Building.ordinal());
outMsg.setTargetID3(building.getObjectUUID());
outMsg.setAssetName1(building.getName());
outMsg.setUnknown54(1);
Dispatch dispatch = Dispatch.borrow(player, outMsg);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
return true;
//TOL, update city name also
//TODO update city and zone in database
//TODO update city map data in game server
}
if (msg.actionType == 14) {
ManageCityAssetsMsg mca = new ManageCityAssetsMsg(player, building);
mca.actionType = 15;
Dispatch dispatch = Dispatch.borrow(player, mca);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
return true;
}
if (msg.actionType == 20) {
Zone baneZone = building.getParentZone();
if (baneZone == null)
return true;
City banedCity = City.getCity(baneZone.getPlayerCityUUID());
if (banedCity == null)
return true;
Bane bane = banedCity.getBane();
if (bane == null || bane.getLiveDate() != null || player.getGuild() != banedCity.getGuild() || GuildStatusController.isInnerCouncil(player.getGuildStatus()) == false)
return true;
int baneHour = msg.getBaneHour();
if (baneHour < 16 || baneHour > 24) {
PlaceAssetMsg.sendPlaceAssetError(origin, 1, "A Serious error has occurred. Please post details for to ensure transaction integrity");
return true;
}
DateTime baneLive = new DateTime(bane.getPlacementDate());
baneLive = baneHour == 24 ? baneLive.plusDays(3) : baneLive.plusDays(2);
baneLive = baneHour == 24 ? baneLive.hourOfDay().setCopy(0) : baneLive.hourOfDay().setCopy(baneHour);
baneLive = baneLive.minuteOfHour().setCopy(0);
baneLive = baneLive.secondOfMinute().setCopy(1);
bane.setLiveDate(baneLive);
outMsg.actionType = 18;
Dispatch dispatch = Dispatch.borrow(player, outMsg);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
return true;
}
DateTime baneLive = new DateTime(bane.getPlacementDate());
baneLive = baneHour == 24 ? baneLive.plusDays(3) : baneLive.plusDays(2);
baneLive = baneHour == 24 ? baneLive.hourOfDay().setCopy(0) : baneLive.hourOfDay().setCopy(baneHour);
baneLive = baneLive.minuteOfHour().setCopy(0);
baneLive = baneLive.secondOfMinute().setCopy(1);
bane.setLiveDate(baneLive);
outMsg.actionType = 18;
DispatchMessage.dispatchMsgDispatch(Dispatch.borrow(player, outMsg), DispatchChannel.SECONDARY);
return true;
}
public void configWindowState(PlayerCharacter player, Building building, ManageCityAssetsMsg manageCityAssetsMsg) {
// Tests to turn on upgrade button if a building is not
@@ -226,7 +294,7 @@ public class ManageCityAssetMsgHandler extends AbstractClientMsgHandler {
// Owner is obviously allowed to upgrade his own buildings
if (building.getOwner() != null && building.getOwner().equals(player)) {
if (building.getOwner().equals(player)) {
// Players cannot destroy or transfer a TOL.
@@ -147,7 +147,7 @@ public class MerchantMsgHandler extends AbstractClientMsgHandler {
Building shrineBuilding;
Shrine shrine;
if (npc.getGuild().getNation() != player.getGuild().getNation())
if (npc.getGuild() != player.getGuild())
return;
shrineBuilding = npc.getBuilding();
@@ -173,10 +173,10 @@ public class MerchantMsgHandler extends AbstractClientMsgHandler {
//already haz boon.
//if (player.containsEffect(shrine.getShrineType().getPowerToken())) {
// ErrorPopupMsg.sendErrorPopup(player, 199);
// return;
//}
if (player.containsEffect(shrine.getShrineType().getPowerToken())) {
ErrorPopupMsg.sendErrorPopup(player, 199);
return;
}
if (!Shrine.canTakeFavor(player, shrine))
return;
@@ -191,10 +191,12 @@ public class MerchantMsgHandler extends AbstractClientMsgHandler {
return;
}
if(shrinePower.getName().equals("Boon: Nephilim"))
shrinePower.name = "Boon: Chaos";
int trains = 5 * npc.getRank() + 5;//40 - (rank * 10);
int rank = shrine.getRank();
//R8 trees always get atleast rank 2 boons. rank uses index, where 0 is first place, 1 is second, etc...
if (shrineBuilding.getCity() != null && shrineBuilding.getCity().getTOL() != null && shrineBuilding.getCity().getTOL().getRank() == 8)
if (rank != 0)
rank = 1;
int trains = 40 - (rank * 10);
if (trains < 0)
trains = 0;
@@ -15,9 +15,6 @@ import engine.net.client.msg.*;
import engine.objects.*;
import org.pmw.tinylog.Logger;
import java.util.ArrayList;
import java.util.HashMap;
/*
* @Author:
* @Summary: Processes application protocol message which
@@ -26,8 +23,6 @@ import java.util.HashMap;
public class MinionTrainingMsgHandler extends AbstractClientMsgHandler {
public static HashMap<Integer, ArrayList<Integer>> _minionsByCaptain = null;
public MinionTrainingMsgHandler() {
super(MinionTrainingMessage.class);
}
@@ -37,10 +32,11 @@ public class MinionTrainingMsgHandler extends AbstractClientMsgHandler {
MinionTrainingMessage minionMsg = (MinionTrainingMessage) baseMsg;
PlayerCharacter player = SessionManager.getPlayerCharacter(origin);
PlayerCharacter playerCharacter = SessionManager.getPlayerCharacter(origin);
if (player == null)
if (playerCharacter == null)
return true;
if (minionMsg.getNpcType() == Enum.GameObjectType.NPC.ordinal()) {
NPC npc = NPC.getFromCache(minionMsg.getNpcID());
@@ -48,23 +44,24 @@ public class MinionTrainingMsgHandler extends AbstractClientMsgHandler {
if (npc == null)
return true;
Building b = BuildingManager.getBuildingFromCache(minionMsg.getBuildingID());
Building building = BuildingManager.getBuildingFromCache(minionMsg.getBuildingID());
if (b == null)
if (building == null)
return true;
//clear minion
if (npc.minionLock.writeLock().tryLock()) {
try {
if (minionMsg.getType() == 2) {
Mob toRemove = Mob.getFromCache(minionMsg.getUUID());
if (!npc.siegeMinionMap.containsKey(toRemove))
if (!npc.minions.contains(toRemove.getObjectUUID()))
return true;
npc.siegeMinionMap.remove(toRemove);
npc.minions.remove(Integer.valueOf(toRemove.getObjectUUID()));
WorldGrid.RemoveWorldObject(toRemove);
@@ -86,23 +83,21 @@ public class MinionTrainingMsgHandler extends AbstractClientMsgHandler {
}
}
// we Found the move to remove, lets break the for loop so it doesnt look for more.
ManageCityAssetsMsg mca1 = new ManageCityAssetsMsg(player, b);
ManageCityAssetsMsg mca1 = new ManageCityAssetsMsg(playerCharacter, building);
mca1.actionType = 3;
mca1.setTargetType(b.getObjectType().ordinal());
mca1.setTargetID(b.getObjectUUID());
mca1.setTargetType(building.getObjectType().ordinal());
mca1.setTargetID(building.getObjectUUID());
mca1.setTargetType3(npc.getObjectType().ordinal());
mca1.setTargetID3(npc.getObjectUUID());
mca1.setAssetName1(b.getName());
mca1.setAssetName1(building.getName());
mca1.setUnknown54(1);
Dispatch dispatch = Dispatch.borrow(player, mca1);
Dispatch dispatch = Dispatch.borrow(playerCharacter, mca1);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
ManageNPCMsg mnm = new ManageNPCMsg(npc);
dispatch = Dispatch.borrow(player, mnm);
dispatch = Dispatch.borrow(playerCharacter, mnm);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
//Add Minion
@@ -117,7 +112,7 @@ public class MinionTrainingMsgHandler extends AbstractClientMsgHandler {
if (npc.getContractID() == 842)
maxSlots = 1;
if (npc.siegeMinionMap.size() == maxSlots)
if (npc.minions.size() == maxSlots)
return true;
int mobBase;
@@ -156,7 +151,7 @@ public class MinionTrainingMsgHandler extends AbstractClientMsgHandler {
ManageNPCMsg mnm = new ManageNPCMsg(npc);
mnm.setMessageType(1);
Dispatch dispatch = Dispatch.borrow(player, mnm);
Dispatch dispatch = Dispatch.borrow(playerCharacter, mnm);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
} finally {
@@ -184,13 +179,13 @@ public class MinionTrainingMsgHandler extends AbstractClientMsgHandler {
Mob toRemove = Mob.getFromCache(minionMsg.getUUID());
if (!npc.getSiegeMinionMap().containsKey(toRemove))
if (!npc.minions.contains(toRemove.getObjectUUID()))
return true;
if (!DbManager.MobQueries.REMOVE_FROM_GUARDS(npc.getObjectUUID(), toRemove.getMobBaseID(), npc.getSiegeMinionMap().get(toRemove)))
if (!DbManager.MobQueries.REMOVE_GUARD_MINION(npc.getObjectUUID(), toRemove.firstName))
return true;
npc.getSiegeMinionMap().remove(toRemove);
npc.minions.remove(Integer.valueOf(toRemove.getObjectUUID()));
WorldGrid.RemoveWorldObject(toRemove);
@@ -199,19 +194,21 @@ public class MinionTrainingMsgHandler extends AbstractClientMsgHandler {
DbManager.removeFromCache(toRemove);
if (toRemove.agentType.equals(Enum.AIAgentType.SIEGEENGINE)) {
PlayerCharacter petOwner = (PlayerCharacter) toRemove.guardCaptain;
PlayerCharacter trebOwner = (PlayerCharacter) toRemove.guardCaptain;
if (petOwner != null) {
petOwner.setPet(null);
if (trebOwner != null) {
trebOwner.setPet(null);
toRemove.guardCaptain = null;
PetMsg petMsg = new PetMsg(5, null);
Dispatch dispatch = Dispatch.borrow(petOwner, petMsg);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
toRemove.guardCaptain = null;
PetMsg petMsg = new PetMsg(5, null);
Dispatch dispatch = Dispatch.borrow(trebOwner, petMsg);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
}
}
ManageCityAssetsMsg mca1 = new ManageCityAssetsMsg(player, building);
ManageCityAssetsMsg mca1 = new ManageCityAssetsMsg(playerCharacter, building);
mca1.actionType = 3;
mca1.setTargetType(building.getObjectType().ordinal());
mca1.setTargetID(building.getObjectUUID());
@@ -221,11 +218,11 @@ public class MinionTrainingMsgHandler extends AbstractClientMsgHandler {
mca1.setAssetName1(building.getName());
mca1.setUnknown54(1);
Dispatch dispatch = Dispatch.borrow(player, mca1);
Dispatch dispatch = Dispatch.borrow(playerCharacter, mca1);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
ManageNPCMsg mnm = new ManageNPCMsg(npc);
dispatch = Dispatch.borrow(player, mnm);
dispatch = Dispatch.borrow(playerCharacter, mnm);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
//Add Minion
@@ -261,7 +258,7 @@ public class MinionTrainingMsgHandler extends AbstractClientMsgHandler {
break;
}
if (npc.getSiegeMinionMap().size() == maxSlots)
if (npc.minions.size() == maxSlots)
return true;
int mobBase = npc.getMobBaseID();
@@ -276,7 +273,7 @@ public class MinionTrainingMsgHandler extends AbstractClientMsgHandler {
if (toCreate == null)
return true;
if (!DbManager.MobQueries.ADD_TO_GUARDS(npc.getObjectUUID(), mobBase, pirateName, npc.getSiegeMinionMap().size() + 1))
if (!DbManager.MobQueries.ADD_GUARD_MINION(npc.getObjectUUID(), pirateName))
return true;
if (toCreate != null) {
@@ -287,7 +284,7 @@ public class MinionTrainingMsgHandler extends AbstractClientMsgHandler {
ManageNPCMsg mnm = new ManageNPCMsg(npc);
mnm.setMessageType(1);
Dispatch dispatch = Dispatch.borrow(player, mnm);
Dispatch dispatch = Dispatch.borrow(playerCharacter, mnm);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
} catch (Exception e) {
@@ -9,12 +9,14 @@
package engine.net.client.handlers;
import engine.Enum;
import engine.exception.MsgSendException;
import engine.gameManager.BuildingManager;
import engine.gameManager.MovementManager;
import engine.net.client.ClientConnection;
import engine.net.client.msg.ClientNetMsg;
import engine.net.client.msg.MoveToPointMsg;
import engine.objects.PlayerCharacter;
import engine.objects.*;
public class MoveToPointHandler extends AbstractClientMsgHandler {
@@ -26,13 +28,11 @@ public class MoveToPointHandler extends AbstractClientMsgHandler {
protected boolean _handleNetMsg(ClientNetMsg baseMsg,
ClientConnection origin) throws MsgSendException {
MoveToPointMsg msg = (MoveToPointMsg) baseMsg;
PlayerCharacter pc = (origin != null) ? (origin.getPlayerCharacter()) : null;
if (pc == null)
return false;
PlayerCharacter pc = origin.getPlayerCharacter();
if(pc == null)
return true;
MovementManager.movement(msg, pc);
return true;
}
}
@@ -195,9 +195,7 @@ public class ObjectActionMsgHandler extends AbstractClientMsgHandler {
}
hPMod = (building.getMaxHitPoints() * Realm.getRealmHealthMod(city));
float percentOfHealth = building.getCurrentHitpoints() / building.getHealthMax();
building.setMaxHitPoints(building.getMaxHitPoints() + hPMod);
building.setCurrentHitPoints(building.getMaxHitPoints() * percentOfHealth);
}
}
@@ -441,10 +439,8 @@ public class ObjectActionMsgHandler extends AbstractClientMsgHandler {
// }
// break;
//}
int i = 0;
if(i != 0) {
LootManager.peddleFate(player, item);
}
LootManager.peddleFate(player,item);
break;
case 30: //water bucket
@@ -542,11 +538,7 @@ public class ObjectActionMsgHandler extends AbstractClientMsgHandler {
PowersManager.applyPower(player, target, Vector3fImmutable.ZERO, ib.getUseID(), ib.getUseAmount(), true);
itemMan.consume(item);
} else if(ib.getUUID() > 252128 && ib.getUUID() < 252568){
if (ApplyRuneMsg.applyRune(uuid, origin, player)) {
itemMan.consume(item);
}
}else //just remove the item at this point
} else //just remove the item at this point
itemMan.consume(item);
dispatch = Dispatch.borrow(player, msg);
@@ -44,13 +44,6 @@ public class OpenFriendsCondemnListMsgHandler extends AbstractClientMsgHandler {
return true;
msg = (OpenFriendsCondemnListMsg) baseMsg;
sourceBuilding = BuildingManager.getBuildingFromCache(msg.getBuildingID());
if(sourceBuilding != null && sourceBuilding.getBlueprint().getBuildingGroup().equals(Enum.BuildingGroup.TOL)){
return true;
}
openFriendsCondemnListMsg = new OpenFriendsCondemnListMsg(msg);
friendListType = Enum.FriendListType.getListTypeByID(msg.getMessageType());
@@ -7,7 +7,6 @@ import engine.Enum.ProfitType;
import engine.exception.MsgSendException;
import engine.gameManager.BuildingManager;
import engine.gameManager.DbManager;
import engine.gameManager.NPCManager;
import engine.gameManager.SessionManager;
import engine.math.FastMath;
import engine.math.Vector3fImmutable;
@@ -37,7 +36,7 @@ public class OrderNPCMsgHandler extends AbstractClientMsgHandler {
super(OrderNPCMsg.class);
}
public static void processRedeedMob(Mob mob, Building building, ClientConnection origin) {
public static void processRedeedHireling(AbstractCharacter hireling, Building building, ClientConnection origin) {
PlayerCharacter player;
Contract contract;
@@ -48,33 +47,28 @@ public class OrderNPCMsgHandler extends AbstractClientMsgHandler {
player = SessionManager.getPlayerCharacter(origin);
itemMan = player.getCharItemManager();
contract = mob.getContract();
contract = hireling.contract;
if (!player.getCharItemManager().hasRoomInventory((short) 1)) {
ErrorPopupMsg.sendErrorPopup(player, 21);
return;
}
if (!building.getHirelings().containsKey(mob))
if (!building.getHirelings().containsKey(hireling))
return;
if (!NPCManager.removeMobileFromBuilding(mob, building)) {
PlaceAssetMsg.sendPlaceAssetError(player.getClientConnection(), 1, "A Serious error has occurred. Please post details for to ensure transaction integrity");
return;
}
building.getHirelings().remove(mob);
BuildingManager.removeHireling(building, hireling);
itemBase = ItemBase.getItemBase(contract.getContractID());
if (itemBase == null) {
Logger.error("Could not find Contract for npc: " + mob.getObjectUUID());
Logger.error("Could not find Contract for npc: " + hireling.getObjectUUID());
return;
}
boolean itemWorked = false;
item = new Item(itemBase, player.getObjectUUID(), Enum.OwnerType.PlayerCharacter, (byte) ((byte) mob.getRank() - 1), (byte) ((byte) mob.getRank() - 1), (short) 1, (short) 1, true, false, Enum.ItemContainerType.INVENTORY, (byte) 0, new ArrayList<>(), "");
item = new Item(itemBase, player.getObjectUUID(), Enum.OwnerType.PlayerCharacter, (byte) ((byte) hireling.getRank() - 1), (byte) ((byte) hireling.getRank() - 1), (short) 1, (short) 1, true, false, Enum.ItemContainerType.INVENTORY, (byte) 0, new ArrayList<>(), "");
item.setNumOfItems(1);
item.containerType = Enum.ItemContainerType.INVENTORY;
@@ -282,28 +276,6 @@ public class OrderNPCMsgHandler extends AbstractClientMsgHandler {
}
}
private static synchronized void processRedeedNPC(AbstractCharacter abstractCharacter, Building building, ClientConnection origin) {
// Member variable declaration
switch (abstractCharacter.getObjectType()) {
case NPC:
NPC npc = (NPC) abstractCharacter;
Building cityBuilding = npc.getBuilding();
if (cityBuilding == null)
return;
BuildingManager.processRedeedNPC(npc, npc.building, origin);
break;
case Mob:
Mob mob = (Mob) abstractCharacter;
processRedeedMob(mob, mob.building, origin);
break;
}
}
private static boolean AddPatrolPoints(int buildingID, ArrayList<Vector3fImmutable> patrolPoints) {
Building building = BuildingManager.getBuildingFromCache(buildingID);
@@ -494,7 +466,7 @@ public class OrderNPCMsgHandler extends AbstractClientMsgHandler {
if (BuildingManager.PlayerCanControlNotOwner(building, player) == false)
return true;
processRedeedNPC(npc, building, origin);
processRedeedHireling(npc, building, origin);
return true;
//MB TODO HANDLE all profits.
case 7:
@@ -562,10 +534,7 @@ public class OrderNPCMsgHandler extends AbstractClientMsgHandler {
if (building.getHirelings().containsKey(mob) == false)
return true;
if (NPCManager.removeMobileFromBuilding(mob, building) == false) {
PlaceAssetMsg.sendPlaceAssetError(player.getClientConnection(), 1, "A Serious error has occurred. Please post details for to ensure transaction integrity");
return true;
}
BuildingManager.removeHireling(building, mob);
ManageCityAssetsMsg manageCityAssetsMsg = new ManageCityAssetsMsg();
manageCityAssetsMsg.actionType = SVR_CLOSE_WINDOW;
@@ -600,7 +569,7 @@ public class OrderNPCMsgHandler extends AbstractClientMsgHandler {
if (BuildingManager.PlayerCanControlNotOwner(building, player) == false)
return true;
processRedeedNPC(mob, building, origin);
processRedeedHireling(mob, building, origin);
return true;
//MB TODO HANDLE all profits.
case 7:
@@ -412,9 +412,6 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
break;
if (!playerCharacter.getCharItemManager().doesCharOwnThisItem(contract.getObjectUUID()))
break;
if(contract.getItemBaseID() == 1035){//saetor shrine override
msg.getFirstPlacementInfo().setBlueprintUUID(1720000);
}
buildingCreated = placeShrine(playerCharacter, origin, msg);
break;
case BARRACK:
@@ -748,7 +745,7 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
}
Vector3fImmutable plantLoc = new Vector3fImmutable(treeInfo.getLoc().x,
HeightMap.getWorldHeight(treeInfo.getLoc()),
0,
treeInfo.getLoc().z);
cityObjects = DbManager.CityQueries.CREATE_CITY(playerCharacter.getObjectUUID(), serverZone.getObjectUUID(),
@@ -757,6 +754,7 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
plantLoc.z - serverZone.getAbsZ(), treeInfo.getRot().y, treeInfo.getW(), playerCharacter.getGuild().getName(), LocalDateTime.now());
// Uh oh!
if (cityObjects == null || cityObjects.isEmpty()) {
PlaceAssetMsg.sendPlaceAssetError(origin, 1, "A Serious error has occurred. Please post details for to ensure transaction integrity");
return false;
@@ -770,7 +768,7 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
treeObject = (Building) cityObjectMap.get(GameObjectType.Building);
treeObject.runAfterLoad();
;
cityObject = (City) cityObjectMap.get(GameObjectType.City);
zoneObject = (Zone) cityObjectMap.get(GameObjectType.Zone);
@@ -795,15 +793,16 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
ZoneManager.addPlayerCityZone(zoneObject);
serverZone.addNode(zoneObject);
zoneObject.generateWorldAltitude();
zoneObject.worldAltitude = ZoneManager.caclulateWorldAltitude(zoneObject);
cityObject.setParent(zoneObject);
cityObject.setObjectTypeMask(MBServerStatics.MASK_CITY); // *** Refactor : should have it already
//Link the tree of life with the new zone
treeObject.setObjectTypeMask(MBServerStatics.MASK_BUILDING);
treeObject.setParentZone(zoneObject);
MaintenanceManager.setMaintDateTime(treeObject, LocalDateTime.now().plusDays(14));
MaintenanceManager.setMaintDateTime(treeObject, LocalDateTime.now().plusDays(7));
// Update guild binds and tags
//load the new city on the clients
@@ -820,7 +819,6 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
City.lastCityUpdate = System.currentTimeMillis();
treeObject.setLoc(treeObject.getLoc());
InterestManager.setObjectDirty(treeObject);
// WorldGrid.addObject(treeObject, playerCharacter);
serverRealm.addCity(cityObject.getObjectUUID());
playerNation.setCityUUID(cityObject.getObjectUUID());
@@ -918,6 +916,7 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
// Early exit if something went horribly wrong
// with locating the current realm and/or zone
if (serverZone == null)
return false;
@@ -970,7 +969,7 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
}
// Create the shrine
return createShrine((PlayerCharacter) cityObject.getTOL().getOwner(), msg.getFirstPlacementInfo(), serverZone);
}
@@ -980,7 +979,8 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
City cityObject;
PlacementInfo buildingList;
// Setup working variables we'll need
// Setup working variables
buildingList = msg.getFirstPlacementInfo();
serverZone = ZoneManager.findSmallestZone(buildingList.getLoc());
@@ -1093,7 +1093,6 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
placementCost = 0; // reset placement cost for fix bug with wall pieces somethings not taking gold out if forced an error.
// Overlap check and wall deed verifications
for (PlacementInfo wall : walls) {
@@ -1112,7 +1111,6 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
for (Building building : serverZone.zoneBuildingSet) {
//TODO Clean up collision with placementInfo. don't need to create the same placementinfo bounds for collision checks on each building.
if ((building.getBlueprintUUID() != 0) && (Bounds.collide(wall, building) == true)) {
@@ -1132,12 +1130,14 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
return false;
}
}
placementCost = PlaceAssetMsg.getWallCost(wall.getBlueprintUUID());
if (!itemMan.modifyInventoryGold(-placementCost)) {
ChatManager.chatSystemInfo(player, player.getFirstName() + " can't has free moneys! no for real.. Thor.. seriously... I didnt fix it because you getting laid isnt important enough for me.");
return false;
}
// Attempt to place wall piece
wallPiece = createStructure(player, wall, serverZone);
@@ -1148,14 +1148,12 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
}
// walls are auto protected
wallPiece.setProtectionState(ProtectionState.PROTECTED);
PlaceAssetMsg.sendPlaceAssetConfirmWall(origin, serverZone);
}
// Deduct gold from character's inventory
return true;
}
@@ -1175,6 +1173,7 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
}
// All siege buildings build in 15 minutes
if ((blueprint.getBuildingGroup().equals(BuildingGroup.SIEGETENT))
|| (blueprint.getBuildingGroup().equals(BuildingGroup.BULWARK)))
completionDate = DateTime.now().plusMinutes(15);
@@ -1194,6 +1193,7 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
completionDate, blueprint.getMeshForRank(0), vendorRotation, buildingRotation);
// Make sure we have a valid mesh
if (newMesh == null) {
Logger.error("CreateStructure: DB returned null object.");
return null;
@@ -1213,7 +1213,7 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
private boolean createShrine(PlayerCharacter player, PlacementInfo buildingInfo, Zone currentZone) {
Blueprint blueprint;
Building newMesh = null;
Building newMesh;
Shrine newShrine;
City city;
ShrineType shrineType;
@@ -1274,10 +1274,7 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
break;
}
}
if(blueprint.getName().equals("Nephilim Shrine ") && newMesh != null){
newMesh.setName("Chaos Shrine");
}
return true;
}
@@ -1368,15 +1365,16 @@ public class PlaceAssetMsgHandler extends AbstractClientMsgHandler {
newMesh = (Building) ago;
newMesh.setObjectTypeMask(MBServerStatics.MASK_BUILDING);
MaintenanceManager.setMaintDateTime(newMesh, LocalDateTime.now().plusDays(7));
// WorldGrid.addObject(newMesh, player);
newMesh.setLoc(newMesh.getLoc());
InterestManager.setObjectDirty(newMesh);
newMesh.runAfterLoad();
} else if (ago.getObjectType() == GameObjectType.Warehouse) {
Warehouse warehouse = (Warehouse) ago;
City city = City.getCity(currentZone.getPlayerCityUUID());
if (city == null)
return true;
city.setWarehouseBuildingID(newMesh.getObjectUUID());
Warehouse.warehouseByBuildingUUID.put(newMesh.getObjectUUID(), warehouse);
}
@@ -57,7 +57,7 @@ public class RequestEnterWorldHandler extends AbstractClientMsgHandler {
return true;
}
player.enteredWorld = false;
player.setEnteredWorld(false);
Account acc = SessionManager.getAccount(origin);
@@ -110,7 +110,6 @@ public class RequestEnterWorldHandler extends AbstractClientMsgHandler {
player.stopMovement(player.getBindLoc());
player.setSafeMode();
player.updateLocation();
player.setRegion(AbstractWorldObject.GetRegionByWorldObject(player));
}
player.setTimeStamp("logout", 0);
@@ -4,7 +4,6 @@ import engine.Enum;
import engine.InterestManagement.RealmMap;
import engine.exception.MsgSendException;
import engine.gameManager.BuildingManager;
import engine.gameManager.ChatManager;
import engine.net.Dispatch;
import engine.net.DispatchMessage;
import engine.net.client.ClientConnection;
@@ -132,15 +131,14 @@ public class TaxCityMsgHandler extends AbstractClientMsgHandler {
TaxCityMsg msg;
player = origin.getPlayerCharacter();
ChatManager.chatSystemInfo(player,"Taxing has been disabled");
return false;
//msg = (TaxCityMsg) baseMsg;
//ViewTaxes(msg, player);
//return true;
msg = (TaxCityMsg) baseMsg;
ViewTaxes(msg, player);
return true;
}
@@ -66,8 +66,6 @@ public class UpgradeAssetMsgHandler extends AbstractClientMsgHandler {
Logger.error("Attempt to upgrade null building by " + player.getName());
return true;
}
if(buildingToRank.getBlueprint().getBuildingGroup().equals(Enum.BuildingGroup.WAREHOUSE))
return true;
// Early exit for building that is already ranking
+42 -124
View File
@@ -10,7 +10,6 @@
package engine.net.client.msg;
import engine.Enum;
import engine.gameManager.ChatManager;
import engine.gameManager.DbManager;
import engine.net.*;
import engine.net.client.ClientConnection;
@@ -78,98 +77,55 @@ public class ApplyRuneMsg extends ClientNetMsg {
if (playerCharacter == null || origin == null || rb == null) {
return false;
}
int raceID = playerCharacter.getRaceID();
//Check race is met
ConcurrentHashMap<Integer, Boolean> races = rb.getRace();
if(runeID != 3007 && runeID != 3014) {//bounty hunter and huntsman
if (races.size() > 0) {
boolean valid = false;
for (int validID : races.keySet()) {
if (validID == raceID) {
valid = true;
break;
}
}
if(runeID == 3040)
if (races.size() > 0) {
int raceID = playerCharacter.getRaceID();
boolean valid = false;
for (int validID : races.keySet()) {
if (validID == raceID) {
valid = true;
if(runeID == 2514 && raceID == 1999)
valid = true;
if(runeID == 3036 && raceID == 1999)
valid = true;
if(runeID == 3033 && raceID == 1999)
valid = true;
if (!valid) {
return false;
break;
}
}
//Check base class is met
ConcurrentHashMap<Integer, Boolean> baseClasses = rb.getBaseClass();
if (baseClasses.size() > 0) {
int baseClassID = playerCharacter.getBaseClassID();
boolean valid = false;
for (int validID : baseClasses.keySet()) {
if (validID == baseClassID) {
valid = true;
break;
}
}
if(runeID == 3040)
valid = true;
if(runeID == 3036 && raceID == 1999)
valid = true;
if(runeID == 3033 && raceID == 1999)
valid = true;
if(runeID == 3035 && baseClassID == 2501)
valid = true;
if (!valid) {
return false;
}
}
//Check promotion class is met
ConcurrentHashMap<Integer, Boolean> promotionClasses = rb.getPromotionClass();
if (promotionClasses.size() > 0) {
int promotionClassID = playerCharacter.getPromotionClassID();
boolean valid = false;
for (int validID : promotionClasses.keySet()) {
if (validID == promotionClassID) {
valid = true;
break;
}
}
if(runeID == 3040)
valid = true;
if(runeID == 3004 && (playerCharacter.getPromotionClassID() == 2505 || playerCharacter.getPromotionClassID() == 2510))
valid = true;
if(runeID == 3036 && raceID == 1999)
valid = true;
if(runeID == 3033 && raceID == 1999)
valid = true;
if (!valid) {
return false;
}
}
} else{
if(playerCharacter.getPromotionClassID() == 2519){//priest
if (!valid) {
return false;
}
}
//Check base class is met
ConcurrentHashMap<Integer, Boolean> baseClasses = rb.getBaseClass();
if (baseClasses.size() > 0) {
int baseClassID = playerCharacter.getBaseClassID();
boolean valid = false;
for (int validID : baseClasses.keySet()) {
if (validID == baseClassID) {
valid = true;
break;
}
}
if (!valid) {
return false;
}
}
//Check promotion class is met
ConcurrentHashMap<Integer, Boolean> promotionClasses = rb.getPromotionClass();
if (promotionClasses.size() > 0) {
int promotionClassID = playerCharacter.getPromotionClassID();
boolean valid = false;
for (int validID : promotionClasses.keySet()) {
if (validID == promotionClassID) {
valid = true;
break;
}
}
if (!valid) {
return false;
}
}
//Check disciplines are met
ArrayList<CharacterRune> runes = playerCharacter.getRunes();
ConcurrentHashMap<Integer, Boolean> disciplines = rb.getDiscipline();
@@ -218,16 +174,7 @@ public class ApplyRuneMsg extends ClientNetMsg {
int mod = rba.getModValue();
switch (attrID) {
case MBServerStatics.RUNE_COST_ATTRIBUTE_ID:
switch (rb.getName()) {
case "Born of the Ethyri":
case "Born of the Taripontor":
case "Born of the Gwendannen":
case "Born of the Invorri":
case "Born of the Irydnu":
mod = 0;
}
if (mod > playerCharacter.getUnusedStatPoints()) {
return false;
}
cost = mod;
@@ -285,29 +232,8 @@ public class ApplyRuneMsg extends ClientNetMsg {
return false;
}
switch (rb.getName()) {
case "Born of the Ethyri":
case "Born of the Taripontor":
case "Born of the Gwendannen":
case "Born of the Invorri":
case "Born of the Irydnu":
for (CharacterRune charRune : playerCharacter.getRunes()) {
RuneBase rb2 = charRune.getRuneBase();
switch (rb2.getName()) {
case "Born of the Ethyri":
case "Born of the Taripontor":
case "Born of the Gwendannen":
case "Born of the Invorri":
case "Born of the Irydnu":
ChatManager.chatSystemError(playerCharacter, "You Have Already Applied A Blood Rune");
return false;
}
}
}
//if discipline, check number applied
if (isDiscipline(runeID)) {
//if(playerCharacter.getLevel() == 80)
discCount -= 1; // level 80 characters get an extra disc rune
if (playerCharacter.getLevel() < 70) {
if (discCount > 2) {
return false;
@@ -378,15 +304,7 @@ public class ApplyRuneMsg extends ClientNetMsg {
playerCharacter.recalculate();
}
}
switch (rb.getName()) {
case "Born of the Ethyri":
case "Born of the Taripontor":
case "Born of the Gwendannen":
case "Born of the Invorri":
case "Born of the Irydnu":
cost = 0;
break;
}
if (cost > 0) {
ModifyStatMsg msm = new ModifyStatMsg((0 - cost), 0, 3);
dispatch = Dispatch.borrow(playerCharacter, msm);
+1 -5
View File
@@ -87,11 +87,7 @@ public class CityDataMsg extends ClientNetMsg {
temp.putInt(cityList.size());
for (City city : cityList)
try {
City.serializeForClientMsg(city, temp);
}catch(Exception e){
continue;
}
City.serializeForClientMsg(city, temp);
temp.put((byte) 0); // PAD
// Serialize runegates
+2 -3
View File
@@ -9,7 +9,6 @@
package engine.net.client.msg;
import engine.Enum;
import engine.Enum.GameObjectType;
import engine.net.AbstractConnection;
import engine.net.ByteBufferReader;
@@ -43,8 +42,8 @@ public class CityZoneMsg extends ClientNetMsg {
this.locY = locY;
this.locZ = locZ;
this.name = name;
this.radiusX = Enum.CityBoundsType.ZONE.extents;
this.radiusZ = Enum.CityBoundsType.ZONE.extents;
this.radiusX = radiusX;
this.radiusZ = radiusZ;
this.unknown01 = 0;
}
@@ -9,7 +9,6 @@
package engine.net.client.msg;
import engine.Enum;
import engine.Enum.*;
import engine.gameManager.BuildingManager;
import engine.gameManager.ZoneManager;
@@ -532,10 +531,7 @@ public class ManageCityAssetsMsg extends ClientNetMsg {
else if (building.getRank() == building.getBlueprint().getMaxRank())
this.upgradeCost = Integer.MAX_VALUE;
else
if(building.getBlueprint().getBuildingGroup().equals(Enum.BuildingGroup.WAREHOUSE))
this.upgradeCost = Integer.MAX_VALUE;
else
this.upgradeCost = building.getBlueprint().getRankCost(Math.min(building.getRank() + 1, 7));
this.upgradeCost = building.getBlueprint().getRankCost(Math.min(building.getRank() + 1, 7));
writer.putInt(this.upgradeCost);
} else
+15 -12
View File
@@ -27,7 +27,6 @@ import org.pmw.tinylog.Logger;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;
/**
@@ -96,7 +95,7 @@ public class ManageNPCMsg extends ClientNetMsg {
writer.putString("A weapon suited to laying siege");
}
private static void serializeGuardList(ByteBufferWriter writer, int minion) {
private static void serializeGuardList(ByteBufferWriter writer, int minion, Mob captain) {
writer.putInt(1);
@@ -106,7 +105,7 @@ public class ManageNPCMsg extends ClientNetMsg {
writer.putInt(minion);
writer.putInt(1);
writer.putInt(minion);
writer.putInt(1);
writer.putInt(captain.getRank());//minion rank
writer.put((byte) 0);
writer.putInt(600); //roll time
@@ -343,14 +342,17 @@ public class ManageNPCMsg extends ClientNetMsg {
writer.putInt(0); //runemaster list
//artillery captain list
ConcurrentHashMap<Mob, Integer> siegeMinions = npc.siegeMinionMap;
writer.putInt(1 + siegeMinions.size());
writer.putInt(1 + npc.minions.size());
serializeBulwarkList(writer, 1); //Trebuchet
//serializeBulwarkList(writer, 2); //Ballista
if (siegeMinions != null && siegeMinions.size() > 0)
if (npc.minions != null && npc.minions.size() > 0)
for (Integer minionUUID : npc.minions) {
Mob mob = Mob.getMob(minionUUID);
for (Mob mob : siegeMinions.keySet()) {
this.unknown83 = mob.getObjectUUID();
writer.putInt(2);
writer.putInt(mob.getObjectType().ordinal());
@@ -666,14 +668,15 @@ public class ManageNPCMsg extends ClientNetMsg {
writer.putInt(0); //runemaster list
//artillery captain list
ConcurrentHashMap<Mob, Integer> siegeMinions = mobA.getSiegeMinionMap();
writer.putInt(siegeMinions.size() + 1);
serializeGuardList(writer, mobA.getContract().getContractID()); //Guard
writer.putInt(mobA.minions.size() + 1);
if (siegeMinions != null && siegeMinions.size() > 0)
serializeGuardList(writer, mobA.getContract().getContractID(), mobA); //Guard
for (Mob mob : siegeMinions.keySet()) {
if (mobA.minions != null && mobA.minions.size() > 0)
for (Integer minionUUID : mobA.minions) {
Mob mob = Mob.getMob(minionUUID);
this.unknown83 = mob.getObjectUUID();
writer.putInt(2);
writer.putInt(mob.getObjectType().ordinal());
+56 -55
View File
@@ -10,6 +10,7 @@
package engine.net.client.msg;
import engine.Enum.GameObjectType;
import engine.gameManager.BuildingManager;
import engine.gameManager.ZoneManager;
import engine.math.Vector3fImmutable;
import engine.net.AbstractConnection;
@@ -21,19 +22,19 @@ import engine.objects.Building;
public class MoveToPointMsg extends ClientNetMsg {
private int sourceType;
private int sourceID;
private float startLat;
private float startLon;
private float startAlt;
private float endLat;
private float endLon;
private float endAlt;
private int targetType;
private int targetID;
private int inBuilding; // 0=true, -1=false 0/1/2 = floor you are on
private int unknown01;
private byte unknown02;
private int sourceType; //ordinal of the character type that sent this message 54=PlayerCharacter
private int sourceID; // uuid of the source character of this message
private float startLat; //start loc of move message (offset if inside a building not world loc)
private float startLon; //start loc of move message (offset if inside a building not world loc)
private float startAlt; //start loc of move message (offset if inside a building not world loc)
private float endLat; //end loc of move message (offset if inside a building not world loc)
private float endLon; //end loc of move message (offset if inside a building not world loc)
private float endAlt; //end loc of move message (offset if inside a building not world loc)
private int startLocType; // enum ordinal of the object player is inside 0=nothing 8=building
private int inBuildingUUID; // uuid of the building character is currently inside
private int inBuilding; // is inside a building 0=true -1=false
private int inBuildingFloor; // floor of building character is currently in -1=not inside building 0/1/2/3 = floor number
private byte initiatedByAttack; // move message sent as a result of move to target to attack 0=false 1=true
private byte unknown03;
/**
@@ -54,11 +55,11 @@ public class MoveToPointMsg extends ClientNetMsg {
this.endLat = msg.endLat;
this.endLon = msg.endLon;
this.endAlt = msg.endAlt;
this.targetType = msg.targetType;
this.targetID = msg.targetID;
this.startLocType = msg.startLocType;
this.inBuildingUUID = msg.inBuildingUUID;
this.inBuilding = msg.inBuilding;
this.unknown01 = msg.unknown01;
this.unknown02 = msg.unknown02;
this.inBuildingFloor = msg.inBuildingFloor;
this.initiatedByAttack = msg.initiatedByAttack;
this.unknown03 = msg.unknown03;
}
@@ -73,11 +74,11 @@ public class MoveToPointMsg extends ClientNetMsg {
this.endLat = building.getLoc().x;
this.endLon = building.getLoc().z;
this.endAlt = building.getLoc().y;
this.targetType = 0;
this.targetID = 0;
this.startLocType = 0;
this.inBuildingUUID = 0;
this.inBuilding = -1;
this.unknown01 = -1;
this.unknown02 = 0;
this.inBuildingFloor = -1;
this.initiatedByAttack = 0;
this.unknown03 = 0;
}
@@ -108,11 +109,11 @@ public class MoveToPointMsg extends ClientNetMsg {
writer.putFloat(this.endAlt);
writer.putFloat(this.endLon);
writer.putInt(this.targetType);
writer.putInt(this.targetID);
writer.putInt(this.startLocType);
writer.putInt(this.inBuildingUUID);
writer.putInt(this.inBuilding);
writer.putInt(this.unknown01);
writer.putInt(this.inBuildingFloor);
writer.put((byte) 0);
writer.put((byte) 0);
@@ -135,13 +136,13 @@ public class MoveToPointMsg extends ClientNetMsg {
this.endAlt = reader.getFloat();
this.endLon = reader.getFloat();
this.targetType = reader.getInt();
this.targetID = reader.getInt();
this.startLocType = reader.getInt();
this.inBuildingUUID = reader.getInt();
this.inBuilding = reader.getInt();
this.unknown01 = reader.getInt();
this.inBuildingFloor = reader.getInt();
this.unknown02 = reader.get();
this.initiatedByAttack = reader.get();
this.unknown03 = reader.get();
}
@@ -209,20 +210,20 @@ public class MoveToPointMsg extends ClientNetMsg {
this.endAlt = value;
}
public int getTargetType() {
return this.targetType;
public int getStartLocType() {
return this.startLocType;
}
public void setTargetType(int value) {
this.targetType = value;
public void setStartLocType(int value) {
this.startLocType = value;
}
public int getTargetID() {
return this.targetID;
public int getInBuildingUUID() {
return this.inBuildingUUID;
}
public void setTargetID(int value) {
this.targetID = value;
public void setInBuildingUUID(int value) {
this.inBuildingUUID = value;
}
public int getInBuilding() {
@@ -233,12 +234,8 @@ public class MoveToPointMsg extends ClientNetMsg {
this.inBuilding = value;
}
public int getUnknown01() {
return this.unknown01;
}
public void setUnknown01(int value) {
this.unknown01 = value;
public void setInBuildingFloor(int value) {
this.inBuildingFloor = value;
}
public void setStartCoord(Vector3fImmutable value) {
@@ -254,8 +251,8 @@ public class MoveToPointMsg extends ClientNetMsg {
}
public void clearTarget() {
this.targetType = 0;
this.targetID = 0;
this.startLocType = 0;
this.inBuildingUUID = 0;
}
public void setPlayer(AbstractCharacter ac) {
@@ -263,10 +260,10 @@ public class MoveToPointMsg extends ClientNetMsg {
this.sourceID = ac.getObjectUUID();
this.setStartCoord(ac.getLoc());
this.setEndCoord(ac.getEndLoc());
this.targetType = 0;
this.targetID = 0;
this.startLocType = 0;
this.inBuildingUUID = 0;
this.inBuilding = ac.getInBuilding();
this.unknown01 = ac.getInFloorID();
this.inBuildingFloor = ac.getInFloorID();
}
@@ -274,10 +271,10 @@ public class MoveToPointMsg extends ClientNetMsg {
if (target == null) {
this.setStartCoord(ac.getLoc());
this.setEndCoord(ac.getEndLoc());
this.targetType = 0;
this.targetID = 0;
this.startLocType = 0;
this.inBuildingUUID = 0;
this.inBuilding = -1;
this.unknown01 = -1;
this.inBuildingFloor = -1;
} else {
Vector3fImmutable convertLocStart = ZoneManager.convertWorldToLocal(target, ac.getLoc());
Vector3fImmutable convertLocEnd = convertLocStart;
@@ -286,10 +283,10 @@ public class MoveToPointMsg extends ClientNetMsg {
this.setStartCoord(convertLocStart);
this.setEndCoord(convertLocEnd);
this.targetType = GameObjectType.Building.ordinal();
this.targetID = target.getObjectUUID();
this.startLocType = GameObjectType.Building.ordinal();
this.inBuildingUUID = target.getObjectUUID();
this.inBuilding = ac.getInBuilding();
this.unknown01 = ac.getInFloorID();
this.inBuildingFloor = ac.getInFloorID();
}
}
@@ -298,7 +295,11 @@ public class MoveToPointMsg extends ClientNetMsg {
return unknown03;
}
public int getUnknown02() {
return unknown02;
public int getInitiatedFromAttack() {
return initiatedByAttack;
}
public int getInBuildingFloor() {
return this.inBuildingFloor;
}
}
@@ -601,9 +601,6 @@ public class PlaceAssetMsg extends ClientNetMsg {
public int getBlueprintUUID() {
return this.blueprintUUID;
}
public void setBlueprintUUID(int id) {
this.blueprintUUID = id;
}
public Vector3fImmutable getLoc() {
return this.loc;
@@ -95,7 +95,7 @@ public class RefinerScreenMsg extends ClientNetMsg {
return this.unknown02;
}
public void setUnknown02(float value) {
public void setUnknown02(int value) {
this.unknown02 = value;
}
+1
View File
@@ -94,6 +94,7 @@ public class TrainMsg extends ClientNetMsg {
if (sk == null)
return;
if (sk.getSkillsBase().getToken() == 40661438) {
int maxValue = 15;
+15 -51
View File
@@ -9,19 +9,19 @@
package engine.net.client.msg;
import engine.Enum;
import engine.Enum.DispatchChannel;
import engine.Enum.GuildHistoryType;
import engine.InterestManagement.InterestManager;
import engine.exception.MsgSendException;
import engine.gameManager.*;
import engine.gameManager.BuildingManager;
import engine.gameManager.DbManager;
import engine.gameManager.GuildManager;
import engine.gameManager.SessionManager;
import engine.math.Vector3fImmutable;
import engine.net.*;
import engine.net.client.ClientConnection;
import engine.net.client.Protocol;
import engine.objects.*;
import engine.server.MBServerStatics;
import engine.util.BoxTracker;
import java.util.ArrayList;
import java.util.concurrent.ThreadLocalRandom;
@@ -137,29 +137,6 @@ public class VendorDialogMsg extends ClientNetMsg {
msg.updateMessage(3, vd);
}
if(contract.getObjectUUID() == 1502040){
if(!playerCharacter.getTimestamps().containsKey("lastBoxChange"))
playerCharacter.getTimestamps().put("lastBoxChange",System.currentTimeMillis() - 1000);
if(playerCharacter.getTimeStamp("lastBoxChange") + 30000L > System.currentTimeMillis()) {
ChatManager.chatSystemInfo(playerCharacter, "You Must Wait To Promote Again.");
return;
}
if(playerCharacter.isBoxed == false) {
ChatManager.chatSystemInfo(playerCharacter, "You Are Already The Active Character.");
return;
}
playerCharacter.getTimestamps().put("lastBoxChange",System.currentTimeMillis());
for(PlayerCharacter newlyBoxed : BoxTracker.getPlayers(playerCharacter.getClientConnection().machineID)){
newlyBoxed.isBoxed = true;
}
playerCharacter.isBoxed = false;
InterestManager.setObjectDirty(playerCharacter);
playerCharacter.removeEffectBySource(Enum.EffectSourceType.DeathShroud,50,true);
}
Dispatch dispatch = Dispatch.borrow(playerCharacter, msg);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.SECONDARY);
@@ -571,36 +548,23 @@ public class VendorDialogMsg extends ClientNetMsg {
// verify race valid for profession
Race race = pc.getRace();
if(race.getRaceRuneID() == 1999 && (promoID == 2512 || promoID == 2511)) {
} else if(promo.getName().equals("Ranger")&& race.getName().equals("Saetor"))
{
}else {
if (race == null || !promo.isAllowedRune(race.getToken())) {
// TODO send client promotion error
return;
}
if (race == null || !promo.isAllowedRune(race.getToken())) {
// TODO send client promotion error
return;
}
// verify baseclass valid for profession
BaseClass bc = pc.getBaseClass();
if(promo.getName().equals("Druid") && (bc.getName().equals("Rogue") || bc.getName().equals("Mage"))) { //allow rogue and mage druids
}
else {
if (bc == null || !promo.isAllowedRune(bc.getToken())) {
// TODO send client promotion error
return;
}
if (bc == null || !promo.isAllowedRune(bc.getToken())) {
// TODO send client promotion error
return;
}
// verify gender
if(race.getName().equals("Saetor") == false) { //saetors can promote to huntress and fury
if (promoID == 2511 && pc.isMale()) // Fury
return;
if (promoID == 2512 && pc.isMale()) // Huntress
return;
}
if (promoID == 2511 && pc.isMale()) // Fury
return;
if (promoID == 2512 && pc.isMale()) // Huntress
return;
if (promoID == 2517 && !pc.isMale()) // Warlock
return;
@@ -15,7 +15,6 @@ import engine.net.ByteBufferReader;
import engine.net.ByteBufferWriter;
import engine.net.client.Protocol;
import engine.net.client.msg.ClientNetMsg;
import engine.objects.Race;
public class CommitNewCharacterMsg extends ClientNetMsg {
@@ -176,7 +175,7 @@ public class CommitNewCharacterMsg extends ClientNetMsg {
public int getRace() {
for (int i = 0; i < 23; i++)
if(Race.getRace(this.runes[i]) != null)
if (this.runes[i] > 1999 && this.runes[i] < 2030)
return this.runes[i];
return 0;
}

Some files were not shown because too many files have changed in this diff Show More