Compare commits

..

701 Commits

Author SHA1 Message Date
MagicBot dfa646d828 Update to player city filter 2024-08-25 17:31:28 -04:00
MagicBot 668b61b734 city.isDestroyed 2024-08-25 17:11:01 -04:00
MagicBot 20c032fa4d Hash value updated. 2024-08-25 17:03:48 -04:00
MagicBot 62235497ad Returns all not just active mines 2024-08-25 16:53:51 -04:00
MagicBot 983dd46870 Update to thread logic 2024-08-25 16:23:28 -04:00
MagicBot 4da089e9b8 Update to thread logic 2024-08-25 16:20:27 -04:00
MagicBot aaff28d720 Update to console output 2024-08-25 16:13:37 -04:00
MagicBot 93befc0887 Update to console output 2024-08-25 16:13:22 -04:00
MagicBot d304d0706c Owner set to null 2024-08-25 15:28:12 -04:00
MagicBot eff44c334d Error trapping and output 2024-08-25 15:26:14 -04:00
MagicBot e082a0b49c Bane logic tweaking 2024-08-25 15:18:40 -04:00
MagicBot 9ad5f239b0 No modtable defaults to workorder. 2024-07-22 16:54:11 -04:00
MagicBot 3db8ee7afd Forge validation for modtables updated. 2024-07-22 16:37:27 -04:00
FatBoy f07974f673 dual wield spam attack issue resolved 2024-07-21 19:46:06 -05:00
FatBoy 0d5cef1652 guilds that have sub guilds can no longer be invited to join nations 2024-07-21 19:36:17 -05:00
FatBoy 04203c092a Lowering stats below item requirement unequips and removes item from map correctly 2024-07-21 19:32:16 -05:00
FatBoy 78feee482b items can now be equipped when skill level exactly meets item requirement 2024-07-21 19:23:34 -05:00
FatBoy 8c35844e08 Huntress pet cannot attack players resolved 2024-07-21 19:16:57 -05:00
FatBoy 0fbb43e021 proc fix 2024-07-12 13:43:28 -04:00
MagicBot 145449f26d Bronzewood mine_production updated. 2024-06-29 14:33:19 -04:00
FatBoy feef6263b4 cleanup 2024-06-27 20:41:43 -05:00
FatBoy 6c622c377f blocked power type structuring 2024-06-27 20:19:11 -05:00
FatBoy 8943121336 blocked power type structuring 2024-06-27 19:54:29 -05:00
FatBoy 70cb469190 final cleanup 2024-06-26 20:44:46 -05:00
FatBoy a42f307a70 immunitiy check compiled to single location 2024-06-26 20:37:28 -05:00
FatBoy 2a3ae6eaec Immunities refresh 2024-06-26 20:24:05 -05:00
FatBoy 9e4b596aa1 enforce KOS for building works 2024-06-26 20:07:37 -05:00
FatBoy aa1fe792a3 Load enforceKOS for buildings 2024-06-26 19:57:50 -05:00
FatBoy 79919121a8 claiming an errant ToL gives ownership to the leader of the guild, not individual player 2024-06-26 19:44:23 -05:00
FatBoy 80ccfff635 Building Management compiled to a single method check 2024-06-26 19:27:32 -05:00
MagicBot 381139af35 Collection of resourceHash 2024-06-26 12:31:08 -04:00
MagicBot e79da63556 Method cleanup. 2024-06-24 03:18:59 -04:00
MagicBot 533565e37e UUID is in keyset 2024-06-24 03:09:38 -04:00
FatBoy da0510d2bc proccing system 2024-06-22 19:50:53 -05:00
FatBoy 1f732a8ca9 failed rune sno longer get consumed 2024-06-22 19:31:13 -05:00
FatBoy 0d24789a93 reverse KOS function completed 2024-06-22 19:22:13 -05:00
FatBoy 35427cfb4a reverse KOS function 2024-06-22 19:04:04 -05:00
MagicBot 695a78b1e2 Noob island filter at 20 2024-06-19 17:57:28 -04:00
MagicBot 9f6710ccb9 More logic work 2024-06-19 17:51:42 -04:00
MagicBot fff1e80f61 More logic work 2024-06-19 17:49:46 -04:00
MagicBot 141af19daa More logic work 2024-06-19 17:38:44 -04:00
MagicBot 630748541f More logic work 2024-06-19 17:36:09 -04:00
MagicBot d32818f351 Rearrange logic 2024-06-19 17:27:04 -04:00
MagicBot d6f94bd0e7 Merged methods 2024-06-19 17:10:49 -04:00
MagicBot db6a4e471d Lore rules added to method 2024-06-19 17:08:56 -04:00
MagicBot a24c611bac Lore rules added to method 2024-06-19 17:01:02 -04:00
MagicBot 3926160ab1 Unused method removed 2024-06-19 16:56:57 -04:00
MagicBot 4a7013de61 Signature update 2024-06-19 16:56:06 -04:00
MagicBot 56564f1c3b Cleanup of teleport list 2024-06-19 16:53:55 -04:00
MagicBot 8a3e39e97d Cleanup of cityChoice handler 2024-06-19 15:05:01 -04:00
MagicBot 5224c79441 Condemned uuid is key not value in map 2024-06-19 14:53:57 -04:00
MagicBot ede016a93d Never null 2024-06-19 14:43:31 -04:00
MagicBot cc1825dec9 Increase to handle larger banks. 2024-06-18 12:43:59 -04:00
MagicBot d257ce50cf Sanity check for null city. 2024-06-18 11:56:19 -04:00
MagicBot 5b246211e1 Warehouse record removed in destruction banes. 2024-06-18 11:51:11 -04:00
FatBoy 33c923b0de fixed immunities in powers manager 2024-06-13 20:47:28 -05:00
FatBoy 02d524663a fixed a lore issue in powers manager 2024-06-13 20:14:43 -05:00
MagicBot 5bd85addb7 Removed count when validating stack withdraw weight. 2024-06-13 15:42:54 -04:00
FatBoy 40bae67443 fixed mob damage defense and ATR 2024-06-12 19:35:20 -05:00
FatBoy 1cf1d731c4 added = to range checks and converted speed to float 2024-06-12 19:23:34 -05:00
MagicBot 24215e21c9 Sanity check for deleted vendors 2024-06-12 14:15:19 -04:00
MagicBot 3accd779b9 Sanity check for deleted vendors 2024-06-12 14:06:18 -04:00
MagicBot 1d673ca2e5 Sanity check for deleted vendors 2024-06-12 14:04:19 -04:00
MagicBot c935ea1986 Project reformat. 2024-06-11 13:40:42 -04:00
MagicBot 678ccafd3c Unused variable removed. 2024-06-11 13:23:49 -04:00
MagicBot 31292785a5 templateHash used in this context. 2024-06-11 13:09:40 -04:00
MagicBot cdc4717033 Update to resources message 2024-06-11 12:54:57 -04:00
MagicBot 35c8ac0289 Update to resources message 2024-06-11 12:53:07 -04:00
MagicBot f5cc4a3290 Update to resource type 2024-06-10 15:19:57 -04:00
FatBoy 74bd7ddb8b attack speed calculation handled correctly 2024-05-31 19:02:59 -05:00
FatBoy 4feb95131c early exit for pets attacking a null target 2024-05-31 18:34:27 -05:00
FatBoy d22ba7b89d early exit for pets attacking a null target 2024-05-31 18:32:53 -05:00
FatBoy 722fd14be5 character should now play swing animation everytime he tried to swing regardless of early exits 2024-05-31 18:29:59 -05:00
FatBoy 12e73d59c7 apply weapon powers before early exit for defense of passives 2024-05-31 18:26:36 -05:00
FatBoy 5c70f15064 check player agro map for key before tryign to assign to it 2024-05-31 18:23:34 -05:00
MagicBot 8ca641f353 Return 0 for null table entry. 2024-05-31 07:41:25 -04:00
FatBoy 0f9500a0d7 swing animation for miss 2024-05-29 18:39:24 -05:00
FatBoy 0d51afb737 pet damage adjustment 2024-05-28 19:28:41 -05:00
FatBoy 60e331de1a animation work 2024-05-28 19:12:00 -05:00
FatBoy 4a554b0d61 animation work 2024-05-28 19:09:46 -05:00
FatBoy 3f3d85fb36 animation work 2024-05-28 18:55:54 -05:00
MagicBot d2d655a839 Null check for vendor workorder lookup. 2024-05-28 18:31:16 -04:00
FatBoy 0096b8051c updated range chack and hitbox calculations 2024-05-27 19:59:35 -05:00
FatBoy 86102c8933 updated range chack and hitbox calculations 2024-05-27 19:50:52 -05:00
FatBoy f06e2c2e5c traveller open gate fix 2024-05-26 22:36:12 -05:00
FatBoy 74b425e567 casting fix for lore rulesets 2024-05-26 22:20:30 -05:00
FatBoy 22c8cdcf65 fixed pet attack and null weapon combat issue 2024-05-26 22:00:52 -05:00
FatBoy 7ed026f088 machine gun combat fixed 2024-05-26 21:49:36 -05:00
FatBoy 232c381e96 early exit for attack timer 2024-05-26 21:41:59 -05:00
FatBoy 69ea460d5e early exit for attack timer 2024-05-26 20:31:22 -05:00
FatBoy cbe9a30590 corrected convention for naming auto attack job 2024-05-26 20:17:15 -05:00
FatBoy 1bbbc396bd handle destory or derank for buildings 2024-05-22 20:49:33 -05:00
FatBoy 8601f9fcd5 special animation case for Siege Bow 2024-05-22 19:52:21 -05:00
FatBoy 7f029fd0e2 invalid range check for ranged characters attacking a building 2024-05-22 19:45:16 -05:00
FatBoy cc7188b404 invalid range check for ranged characters attacking a building 2024-05-22 19:40:25 -05:00
FatBoy aa0621bb02 bane live processing with vulnerable buildings 2024-05-22 19:27:44 -05:00
FatBoy b4ff1a3f7f swing animation lookup 2024-05-17 20:34:26 -05:00
FatBoy 9d6b1dcf60 swing animation lookup 2024-05-17 20:22:56 -05:00
FatBoy 6e123ecb86 swing animation lookup 2024-05-17 20:17:17 -05:00
FatBoy 2b8b9464af swing animation lookup 2024-05-17 20:09:46 -05:00
FatBoy cd8099b42f noob island guard aggro 2024-05-17 20:01:39 -05:00
FatBoy 2cdcba47a5 noob island guard aggro 2024-05-17 19:57:18 -05:00
FatBoy b7b4623c75 noob island guard aggro 2024-05-17 19:53:39 -05:00
FatBoy 2d958b929d noob island guard aggro 2024-05-17 19:50:44 -05:00
FatBoy e8f0e9f5de noob island guard aggro 2024-05-17 19:50:09 -05:00
FatBoy 03f0f3fcf0 noob island guard aggro 2024-05-17 19:41:26 -05:00
FatBoy 65db64d3df null spam fix for hamlet guards 2024-05-16 19:41:06 -05:00
FatBoy 5a25958aa5 cannot teleport od repledge to perdition or bastion 2024-05-14 19:35:37 -05:00
FatBoy 1f8c5495ab repledge work 2024-05-14 19:28:19 -05:00
FatBoy a54aa03ade can always teleport and repledge to your own nation 2024-05-14 19:22:31 -05:00
FatBoy e82445fcd2 teleport and repledge inside your own nation 2024-05-14 19:14:40 -05:00
FatBoy 9e9716fc88 Lore Teleport list and repledge list construction 2024-05-14 19:10:01 -05:00
FatBoy 4f01da368c Lore Guard AI Aggro 2024-05-14 18:49:30 -05:00
FatBoy 93c4103f61 Lore Mob AI Aggro 2024-05-14 18:42:38 -05:00
MagicBot f8180a7000 Removed custom exception candy 2024-05-12 13:42:11 -04:00
MagicBot 634f1478ce Removed custom exception candy 2024-05-12 13:36:47 -04:00
MagicBot 7335946c10 Removed 4 squigglies 2024-05-12 13:31:05 -04:00
MagicBot fb4eea67ed Comment cleanup 2024-05-12 13:18:51 -04:00
MagicBot 96ba17f67a DispatchManager is now an official manager singleton. 2024-05-12 13:14:42 -04:00
MagicBot ff17cacda7 magicvalue update 2024-05-12 12:54:11 -04:00
MagicBot 4d6ce2b155 Update to value in item rs constructor 2024-05-12 12:06:30 -04:00
MagicBot b2c9331899 Unused variables removed 2024-05-12 11:57:26 -04:00
MagicBot 1cb01b1cce Unused field removed 2024-05-12 11:55:12 -04:00
MagicBot e79fd0c3b4 Unused method removed 2024-05-12 11:46:28 -04:00
MagicBot 6dd1d97be5 Comment cleanup 2024-05-12 11:34:22 -04:00
MagicBot 805034e30b Comment cleanup 2024-05-12 11:32:00 -04:00
MagicBot 9646964698 TODO touchup 2024-05-12 11:31:25 -04:00
MagicBot 9ffaf96017 recalc magic value 2024-05-12 11:24:01 -04:00
MagicBot ce98f80b85 recalc magic value 2024-05-12 11:22:12 -04:00
MagicBot f683201086 recalc magic value 2024-05-12 11:18:22 -04:00
MagicBot 4796f7042d Bugfix in update_value 2024-05-12 11:09:45 -04:00
MagicBot 94ff3cf222 New rolling duration method moved to manager singleton. 2024-05-12 08:14:06 -04:00
MagicBot 174be35cac Comment cleanup 2024-05-12 07:17:31 -04:00
MagicBot ba266e506a Comment cleanup 2024-05-12 07:15:55 -04:00
MagicBot 4123157b92 Comment cleanup 2024-05-11 13:12:10 -04:00
MagicBot 7bb9aeacf7 Comment cleanup 2024-05-11 11:06:07 -04:00
MagicBot 1eda55a3f1 Serialization update 2024-05-11 11:01:49 -04:00
MagicBot f670e3143c Serialization update 2024-05-11 10:52:31 -04:00
MagicBot d55b57f7d0 Flag testing 2024-05-11 10:46:34 -04:00
MagicBot ea2f6f4593 Remove from dbManager cache 2024-05-11 09:37:23 -04:00
MagicBot b592f050c2 convention is == false 2024-05-11 09:33:54 -04:00
MagicBot 25f522c539 Make sure no memory leaks 2024-05-11 09:25:57 -04:00
MagicBot e89404abda json and string methods updated 2024-05-11 09:19:29 -04:00
MagicBot ad2cde9d85 Atomic instead of volatile to match counter 2024-05-11 09:16:48 -04:00
MagicBot ba94fabfb8 Atomic instead of volatile to match counter 2024-05-11 09:15:11 -04:00
MagicBot f7ab38e9a8 Comment updated 2024-05-11 09:02:54 -04:00
MagicBot 0d97fa614b Equals and hash overrides for workObject 2024-05-11 08:57:26 -04:00
MagicBot 6878916874 Update to workOrder cleanup 2024-05-11 08:51:41 -04:00
MagicBot c545468f26 Update to workOrder cleanup 2024-05-11 08:49:44 -04:00
MagicBot 7993fb22d2 Thread consistency for these 2024-05-11 08:33:34 -04:00
MagicBot 19bdb89c0f Unused variable removed 2024-05-11 08:30:32 -04:00
MagicBot 6b0b0cc357 Workorder set to completed when redeeding. 2024-05-11 08:07:04 -04:00
MagicBot bc1ae9a2c9 Minor cleanup 2024-05-11 08:02:19 -04:00
MagicBot 408e3a45ca Workorders cleared with hireling removal. 2024-05-11 07:51:56 -04:00
MagicBot 52e0b5be4d Minor cleanup 2024-05-11 07:31:09 -04:00
MagicBot 161335da26 Comment cleanup 2024-05-10 10:12:45 -04:00
MagicBot 7f1bc2a4b7 Update to workOrder loading. 2024-05-10 09:50:14 -04:00
MagicBot e37a4fab38 Update to workOrder loading. 2024-05-10 09:44:11 -04:00
MagicBot 2760a45d2f Early exit moved to run() 2024-05-10 09:39:43 -04:00
MagicBot 77673fde5f completed workOrders handling update 2024-05-10 09:34:58 -04:00
MagicBot 5fd4e5a088 Early exit for no avail slots 2024-05-09 14:50:47 -04:00
MagicBot b01b62ac3d Withdraw logic cleanup 2024-05-09 14:40:40 -04:00
MagicBot 7193ff7698 Withdraw logic cleanup 2024-05-09 14:12:55 -04:00
MagicBot dd72e20ff9 Withdraw logic cleanup 2024-05-09 14:04:19 -04:00
MagicBot f465ea4045 Withdraw logic cleanup 2024-05-09 11:32:26 -04:00
MagicBot 973dfc94f7 Withdraw logic cleanup 2024-05-09 11:31:12 -04:00
MagicBot a5255bcf11 Simplify total cost calc 2024-05-08 15:40:35 -04:00
MagicBot ec35228de9 Beardstyle bugfix 2024-05-08 13:31:47 -04:00
MagicBot 47a93f6545 sql parm count fix 2024-05-06 13:56:18 -04:00
MagicBot 0cff40070b Realm derived not stored 2024-05-06 13:33:28 -04:00
FatBoy 3f3fb53675 hamlet guard aggro 2024-05-05 19:45:46 -05:00
FatBoy b198dbcc09 Added ./setrace command 2024-05-04 21:39:35 -05:00
FatBoy 60b8843563 Added ./setrace command 2024-05-04 21:38:06 -05:00
MagicBot eff8be91d6 Comment cleanup 2024-05-04 13:38:38 -04:00
MagicBot 55e2d3fb5e Class cleanup 2024-05-04 13:33:33 -04:00
MagicBot a6f417d9cc Comment cleanup 2024-05-04 13:23:33 -04:00
MagicBot 7b1b09dc40 Comment cleanup 2024-05-04 13:20:26 -04:00
MagicBot 5724608005 Class cleanup 2024-05-04 13:18:34 -04:00
MagicBot f5d410f868 typo fixed contextually 2024-05-04 12:58:46 -04:00
MagicBot a5c1422534 unused variable removed 2024-05-04 12:55:51 -04:00
MagicBot 6df0e5625c Class cleanup. 2024-05-04 12:53:06 -04:00
MagicBot 5de932b095 Comment updated. 2024-05-04 12:41:45 -04:00
MagicBot db7d606b36 Devcmd removed. 2024-05-04 12:31:25 -04:00
FatBoy 30d302c43e Lore Guards use charter restrictions when aggroing 2024-04-30 21:45:28 -05:00
FatBoy 95cfc43956 debug option added in canJoin for charter type 2024-04-28 13:49:14 -05:00
FatBoy 7c8d78581e debug option added in canJoin for charter type 2024-04-28 13:46:35 -05:00
FatBoy 6f4a9f7d1a debug option added in canJoin for charter type 2024-04-28 13:44:35 -05:00
FatBoy 7a5569ab89 return guild charter type 2024-04-28 13:39:24 -05:00
FatBoy 042f7c675f cleanup dbEffectsResourceCostHandler 2024-04-28 13:28:53 -05:00
MagicBot 3c4d8239db Charter template id is stored not ordinal 2024-04-28 14:18:13 -04:00
MagicBot 4f20cc9aba Comment update. 2024-04-28 13:56:03 -04:00
MagicBot 34812694b7 Comparison fix 2024-04-28 13:49:21 -04:00
MagicBot 0bbbcbaa81 Removed squiggles 2024-04-28 13:44:35 -04:00
FatBoy 72172b9f05 GuildType lookup work 2024-04-28 12:40:53 -05:00
MagicBot 1876e09b48 method for populating lookup table 2024-04-28 13:34:45 -04:00
MagicBot 31c83f2bb5 upgraded protection for variables 2024-04-28 13:26:07 -04:00
MagicBot 065aa34652 Update to type constructor 2024-04-28 13:23:52 -04:00
FatBoy 8bbaae418d fix for player guild checks 2024-04-28 12:05:56 -05:00
FatBoy 10db850de4 replace == "LORE" with .equals("LORE") 2024-04-28 11:58:55 -05:00
FatBoy 753c3686ea Added MB Dev Notes 2024-04-28 11:44:28 -05:00
FatBoy f4bd928796 Lore check for telport and repledge 2024-04-28 11:34:03 -05:00
MagicBot 916a12a434 City realm id lookup not db load 2024-04-27 11:32:05 -04:00
MagicBot 3a8521683b Bootstrap logging info update 2024-04-27 09:32:25 -04:00
MagicBot df4d5a654f Comment cleanup 2024-04-27 08:58:28 -04:00
MagicBot 7fb5d7d23d Comment cleanup 2024-04-27 08:53:50 -04:00
MagicBot a7c9a15405 Comment cleanup 2024-04-27 08:47:04 -04:00
MagicBot b3b115e9ba Comment cleanup 2024-04-27 08:37:20 -04:00
MagicBot 1b5a64d8fc Minor cleanup 2024-04-27 08:17:43 -04:00
MagicBot 01f0e25e08 Minor cleanup 2024-04-27 08:17:17 -04:00
MagicBot 0782814c8e Update to junk handling 2024-04-27 08:14:31 -04:00
MagicBot 111ba02289 Merge remote-tracking branch 'refs/remotes/origin/feature-workorder2.8' into magicbox-1.5.2.1 2024-04-27 07:28:55 -04:00
MagicBot f09a7d4d12 Unused method removed 2024-04-27 07:27:03 -04:00
MagicBot e1e72b71bd Better name for context 2024-04-27 07:24:57 -04:00
MagicBot 4dce2e2aa2 Comment cleanup 2024-04-27 07:22:20 -04:00
MagicBot 743c897254 total_to_produce updated when slot removed from workOrder 2024-04-27 07:18:24 -04:00
MagicBot f134f71695 Squiggly removal 2024-04-27 07:07:59 -04:00
MagicBot 91016dd53c Cleanup in bane handling 2024-04-27 07:06:39 -04:00
FatBoy 39d04188b4 cleanup old rune handler in ObjectActionMsgHandler 2024-04-26 19:10:56 -05:00
FatBoy c99433c9bd missing case for type RUNE in ObjectActionMsgHandler 2024-04-26 19:07:33 -05:00
FatBoy 6cc94e076d promoting was attempting to use players promotion class (which is null) 2024-04-26 19:00:12 -05:00
MagicBot f294e48140 Null check added for city 2024-04-26 16:15:16 -04:00
MagicBot c25f325f87 Null check added for city 2024-04-26 16:15:07 -04:00
MagicBot ac0c11cb46 Comment cleanup 2024-04-26 15:56:04 -04:00
MagicBot 79e86e0a6f Comment cleanup 2024-04-26 15:43:45 -04:00
MagicBot 46f35f0b10 Minor update to keyset() usages 2024-04-26 15:37:37 -04:00
MagicBot 1b20201f8d MB Dev note added 2024-04-26 15:32:17 -04:00
MagicBot 0d744d900c MB Dev note added 2024-04-26 15:12:53 -04:00
MagicBot 9a8e0bd5c9 Comment cleanup 2024-04-26 15:10:49 -04:00
MagicBot 6b6be80fa8 Comment cleanup 2024-04-26 15:02:19 -04:00
MagicBot c2152432ce Comment cleanup 2024-04-26 15:00:03 -04:00
MagicBot 9348852e2c Comment cleanup 2024-04-26 14:57:02 -04:00
MagicBot 4b67f97ded MB Dev Notes added 2024-04-26 08:21:15 -04:00
MagicBot 2a9463be4e camelCase 2024-04-26 08:14:16 -04:00
MagicBot 67bc13dcde MB Dev Notes added to critical classes. 2024-04-26 08:09:07 -04:00
MagicBot 7d6407fbf5 comment cleanup 2024-04-25 20:26:13 -04:00
MagicBot 7b6f5f752b comment cleanup 2024-04-25 20:25:16 -04:00
MagicBot ef43211103 comment cleanup 2024-04-25 20:24:15 -04:00
MagicBot b312904548 comment cleanup 2024-04-25 20:22:55 -04:00
MagicBot 3b1db51a5e comment cleanup 2024-04-25 20:22:29 -04:00
MagicBot 17011de201 comment cleanup 2024-04-25 19:59:15 -04:00
MagicBot f03edf5c5d comment cleanup 2024-04-25 19:57:56 -04:00
MagicBot 320f06e1db comment cleanup 2024-04-25 10:08:27 -04:00
MagicBot 78480ca3dd comment cleanup 2024-04-25 10:06:55 -04:00
MagicBot 2e5f8701df comment cleanup 2024-04-25 10:04:58 -04:00
MagicBot 3a514dc771 comment cleanup 2024-04-25 10:03:37 -04:00
MagicBot c0b93ff809 comment cleanup 2024-04-25 09:51:34 -04:00
MagicBot 31037c9324 comment cleanup 2024-04-25 09:47:58 -04:00
MagicBot 2464deb3f3 comment cleanup 2024-04-25 09:41:02 -04:00
MagicBot dbf42bfbef json fix in constructor 2024-04-25 09:39:03 -04:00
MagicBot e80cdc192d Update to withdraw calc 2024-04-25 09:33:47 -04:00
MagicBot 9850b54981 Comment cleanup 2024-04-25 09:22:50 -04:00
MagicBot a3a30f3f8a Comment cleanup 2024-04-25 09:02:52 -04:00
MagicBot 4d0018b176 Comment cleanup 2024-04-25 08:51:33 -04:00
MagicBot a9dcac0ad7 Comment cleanup 2024-04-25 08:49:59 -04:00
MagicBot adaa521bf5 Comment cleanup 2024-04-25 08:49:13 -04:00
MagicBot 0fe04041f6 Workorder method moved to workorder 2024-04-25 08:42:20 -04:00
MagicBot 9dd2e1d5e5 Comment cleanup 2024-04-25 08:41:23 -04:00
MagicBot 81d6054982 Debit building first then warehouse 2024-04-25 07:44:19 -04:00
MagicBot ff2e381999 Update to validation order. 2024-04-24 13:47:25 -04:00
MagicBot e1d43ce0d0 Expand scope of try block. 2024-04-24 13:44:22 -04:00
MagicBot a906e30931 Setting containertype. 2024-04-24 13:36:32 -04:00
MagicBot 6a17f93e41 Setting containertype. 2024-04-24 13:13:48 -04:00
MagicBot 1edd4d681b Update to protection check. 2024-04-23 15:14:43 -04:00
MagicBot 911698a7e3 Method moved to WorkOrder 2024-04-23 15:11:56 -04:00
MagicBot 4fa646ce94 New costmap data implemented 2024-04-23 15:05:03 -04:00
MagicBot bcb40fecbb Loading effect costmap data at bootsrap 2024-04-23 14:56:30 -04:00
MagicBot 147b9a42c4 Costmap data generated; removed from bootstrap 2024-04-23 14:41:34 -04:00
MagicBot 81f86ceca9 Code written to refactor db call out of effect costs. 2024-04-23 14:36:01 -04:00
MagicBot e2dbc19adc Code written to refactor db call out of effect costs. 2024-04-23 14:31:08 -04:00
MagicBot d590511035 Code written to refactor db call out of effect costs. 2024-04-23 14:27:12 -04:00
MagicBot f48b9f10e1 Code written to refactor db call out of effect costs. 2024-04-23 14:25:19 -04:00
MagicBot 2607962038 Minor cleanup 2024-04-23 13:40:51 -04:00
MagicBot 4e05c2ab74 Warehouse debit work 2024-04-23 13:38:35 -04:00
MagicBot 6cbcef00aa Serialization update 2024-04-23 13:27:01 -04:00
MagicBot a76fd9f319 Update to identify assignment 2024-04-23 13:20:34 -04:00
MagicBot 8d7d3227cb Update to submit logging 2024-04-23 13:15:15 -04:00
MagicBot 9102fe1f6c Update to single item rolling config 2024-04-23 13:12:49 -04:00
MagicBot d999d00755 Rebuild of ./createitem 2024-04-23 12:42:12 -04:00
MagicBot a7e953ac20 Rebuild of ./createitem 2024-04-23 12:41:10 -04:00
MagicBot 46b4c110e5 Rebuild of ./createitem 2024-04-23 12:38:49 -04:00
MagicBot 30787f7ae2 Remnants of old garbage system removed 2024-04-23 12:25:26 -04:00
MagicBot 9de1afa0fd Comment update 2024-04-23 12:15:26 -04:00
MagicBot 9efba13b03 Simplified lambda function 2024-04-23 12:14:31 -04:00
MagicBot d7ac838b6d Simplified lambda function 2024-04-23 12:11:04 -04:00
MagicBot 50a169149f Resubmit unfinished workorders 2024-04-22 16:33:29 -04:00
MagicBot de65f6bcef Bugfix in pre/suf parsing 2024-04-22 16:28:02 -04:00
MagicBot 2adaff8f66 workOrderID added to output 2024-04-22 16:21:00 -04:00
MagicBot e8032f65d1 Loading workorders at bootstrap 2024-04-22 16:14:10 -04:00
MagicBot e710cf0930 Loading workorders at bootstrap 2024-04-22 16:12:26 -04:00
MagicBot 286a76b1de More workorder loading work 2024-04-22 16:07:25 -04:00
MagicBot 73e30062ea Method to load workorders on bootstrap 2024-04-22 16:02:22 -04:00
MagicBot 7300af9073 Method to load workorders on bootstrap 2024-04-22 15:49:57 -04:00
MagicBot 2a2b61bc0f Method to load workorders on bootstrap 2024-04-22 15:43:13 -04:00
MagicBot 89c3eb4d47 New workorder constructor 2024-04-22 15:34:57 -04:00
MagicBot c03f464043 More workorder db work 2024-04-22 15:12:46 -04:00
MagicBot 7b7492b5cc Workokrders updates as they cycle 2024-04-22 15:09:43 -04:00
MagicBot 684a5459b3 Worker saved upon submit 2024-04-22 15:02:15 -04:00
MagicBot bb5904552a Worker saved upon submit 2024-04-22 14:57:00 -04:00
MagicBot fb9d65b54d Method to save workorders to disk created 2024-04-22 14:55:46 -04:00
MagicBot a53848334f id is key not saved in json 2024-04-22 14:47:42 -04:00
MagicBot 19c6cd76a9 Warehouse updated for org.json 2024-04-22 13:43:22 -04:00
MagicBot d92b1c7473 Helpee and groupee parsing 2024-04-22 13:38:04 -04:00
MagicBot 07a5de2c57 Helpee and groupee parsing 2024-04-22 13:33:03 -04:00
MagicBot d0a837783e Update to sparsetype parsing 2024-04-22 13:23:18 -04:00
MagicBot 576f4af433 Update to sparsetype parsing 2024-04-22 13:18:41 -04:00
MagicBot 8ce81b144a Update to sparsetype parsing 2024-04-22 13:01:25 -04:00
MagicBot fcbb9b0cf1 Update to sparsetype parsing 2024-04-22 12:56:01 -04:00
MagicBot 4f115291eb No some are longs 2024-04-22 12:50:45 -04:00
MagicBot 79079e200a Bitvectors use int not long for mb 2024-04-22 12:48:03 -04:00
MagicBot dbab8f66da Migration to org.json 2024-04-22 12:42:52 -04:00
MagicBot 1d847d781b Migration to org.json 2024-04-22 12:34:57 -04:00
MagicBot 7604b7b07f Migration to org.json 2024-04-22 12:20:53 -04:00
MagicBot 8818282341 Migration to org.json 2024-04-22 11:49:41 -04:00
MagicBot 475ccaff0c Migration to org.json 2024-04-22 09:32:20 -04:00
MagicBot ba47b30673 Migration to org.json 2024-04-22 09:21:46 -04:00
MagicBot d557e30716 Workorder to json work 2024-04-22 08:57:02 -04:00
MagicBot 6499a16cc2 Workorder to json work 2024-04-22 08:53:33 -04:00
MagicBot a851d9a6ec Workorder to json work 2024-04-22 08:40:20 -04:00
MagicBot c09ae5d32f Workorder to json work 2024-04-22 08:35:58 -04:00
MagicBot 27d140f703 Junk or completion removes slot from workOrder 2024-04-22 08:28:43 -04:00
MagicBot 41aefa4a48 Comment cleanup 2024-04-22 08:20:02 -04:00
MagicBot 4723eb4bf2 Serialization update. 2024-04-22 07:56:25 -04:00
MagicBot 28c6953c3d Serialization update. 2024-04-22 07:54:03 -04:00
MagicBot 746a95e7d5 Overflow calc updated 2024-04-22 07:44:47 -04:00
MagicBot 0e7336b8c6 Concurrency update 2024-04-22 07:35:59 -04:00
MagicBot 11013bcd07 Reformat for easier debugging 2024-04-22 01:13:26 -04:00
MagicBot 63c7fb08e0 Concurrency update 2024-04-22 00:46:59 -04:00
MagicBot 6f39767fb4 Concurrency update 2024-04-22 00:37:49 -04:00
MagicBot 2de1f78f22 Slot tracking update 2024-04-22 00:25:16 -04:00
MagicBot 98b73d978a Slot tracking update 2024-04-22 00:19:29 -04:00
MagicBot 5a62361edd Slot tracking update 2024-04-22 00:10:32 -04:00
MagicBot 127f80054f Slot tracking update 2024-04-22 00:03:03 -04:00
FatBoy 41b1718df1 use delay for attacks for players 2024-04-21 13:19:50 -05:00
MagicBot d3b1cf9928 Comment update 2024-04-21 14:10:35 -04:00
MagicBot 7f8c297ae2 City check moved outside of validation 2024-04-21 14:08:27 -04:00
FatBoy 979cd70d65 update class type when promoting 2024-04-21 13:04:47 -05:00
FatBoy 35945f7542 equipping bug 2024-04-21 12:53:38 -05:00
FatBoy 84233ecdd6 use of proper animations 2024-04-21 12:43:23 -05:00
FatBoy 4d601f13a0 Merge remote-tracking branch 'origin/feature-workorder2.7' into feature-workorder2.7 2024-04-21 12:22:02 -05:00
FatBoy 1911de0757 random animation for weapon powers 2024-04-21 12:21:34 -05:00
MagicBot e00871324e Float fix 2024-04-21 13:21:00 -04:00
MagicBot 0286b63a8e Class reformat 2024-04-21 12:56:41 -04:00
FatBoy a84c712110 random animation for weapon powers 2024-04-21 11:52:47 -05:00
FatBoy 8e93e82526 random animation for weapon powers 2024-04-21 11:50:04 -05:00
FatBoy 67bf8c2b11 animation combat cleanup 2024-04-21 11:46:45 -05:00
FatBoy b8dbcb62db early exit for combat cycle 2024-04-21 11:21:40 -05:00
FatBoy bb5d257ae8 early exit for out of stam when attacking 2024-04-21 11:14:10 -05:00
MagicBot 2391bd6606 Unused method removed 2024-04-21 11:54:17 -04:00
MagicBot dc83bee227 File reformat 2024-04-21 11:40:27 -04:00
MagicBot 3ff7414fb4 Rework of item forge method collection usage 2024-04-21 11:39:59 -04:00
MagicBot 1e5790e6b9 Rework of item forge method collection usage 2024-04-21 08:23:58 -04:00
MagicBot 364fb40e0b junk, complete and produce wrapped with same lock as warehouse. 2024-04-20 16:52:24 -04:00
MagicBot 6a72a83076 Must be in a building and in city 2024-04-20 16:22:22 -04:00
MagicBot a83008ea4f Removed bypass in prep for db load. 2024-04-20 16:00:58 -04:00
MagicBot 89f672e0b0 json constructor for workOrders 2024-04-20 15:58:01 -04:00
MagicBot cc324777d1 Warehouse withdraws are persisted 2024-04-20 15:54:31 -04:00
MagicBot 692e7ec416 Comment cleanup 2024-04-20 13:35:04 -04:00
MagicBot 6cba850af5 Class cleanup and comment fixes 2024-04-20 13:26:44 -04:00
MagicBot f3e266cf46 Class cleanup 2024-04-20 13:21:53 -04:00
MagicBot ac347db0c8 debitWorkOrderCost method created 2024-04-20 13:05:19 -04:00
MagicBot 70e6756651 debitWorkOrderCost method created 2024-04-20 13:01:21 -04:00
MagicBot a46205b67b Uses mainline cache for virtual items 2024-04-20 12:45:05 -04:00
MagicBot 80aa413ea8 Methods moved to itemmanger 2024-04-20 12:37:55 -04:00
MagicBot 98d03620bc Persisting effects in complete item 2024-04-20 12:33:55 -04:00
MagicBot cca4521c93 Item prefix and suffix applied 2024-04-20 12:28:30 -04:00
MagicBot a859150a20 Item prefix and suffix applied 2024-04-20 12:17:37 -04:00
MagicBot d64bd193d8 Item prefix and suffix applied 2024-04-20 12:13:33 -04:00
MagicBot d0df406236 Item prefix and suffix applied 2024-04-20 11:53:53 -04:00
MagicBot 92c8430031 Item prefix and suffix applied 2024-04-20 11:13:31 -04:00
MagicBot 99671697ba Item prefix and suffix applied 2024-04-20 11:05:30 -04:00
MagicBot 171c79dcf6 Item prefix and suffix applied 2024-04-20 11:02:35 -04:00
MagicBot 726d471e95 Item prefix and suffix applied 2024-04-20 10:57:51 -04:00
MagicBot c0ed59f14f Item prefix and suffix applied 2024-04-20 10:43:39 -04:00
MagicBot c19c516669 Item prefix and suffix applied 2024-04-20 10:39:45 -04:00
MagicBot 589ea1bce8 Item prefix and suffix applied 2024-04-20 10:26:21 -04:00
MagicBot c133b2da5c Item prefix and suffix applied 2024-04-20 10:20:02 -04:00
MagicBot 24a05543c8 Item prefix and suffix applied 2024-04-20 10:11:56 -04:00
MagicBot 90271890d7 Item prefix and suffix applied 2024-04-20 09:59:04 -04:00
MagicBot 225dc2af18 Item prefix and suffix applied 2024-04-20 09:42:48 -04:00
MagicBot 501c68b1e3 Item prefix and suffix applied 2024-04-20 09:34:49 -04:00
MagicBot 13a75fcd5d Item prefix and suffix applied 2024-04-20 09:10:31 -04:00
MagicBot 1bc3609cbe Unused method removed 2024-04-20 08:57:42 -04:00
MagicBot 2c87e48178 Work on adding modifiers 2024-04-20 08:55:04 -04:00
MagicBot ac10b78d68 Work on adding modifiers 2024-04-20 08:54:28 -04:00
MagicBot 4549688ad7 Update to modifier returned 2024-04-20 08:43:12 -04:00
MagicBot 0a6e40eb74 removed for testing 2024-04-19 10:55:07 -04:00
MagicBot b1b635380a Completed items are identified 2024-04-19 10:49:19 -04:00
MagicBot 7309fdc62f Method moved to Warehouse 2024-04-19 10:46:31 -04:00
MagicBot 412ef0f642 Do not remove until complete pressed 2024-04-19 10:45:28 -04:00
MagicBot 3071cb5847 Apply effects to item 2024-04-19 10:40:03 -04:00
MagicBot 1a7f63ce05 lastNegativeId moved to ItemManager 2024-04-19 10:32:36 -04:00
MagicBot c03c1f4057 Update to item effect serialization 2024-04-19 10:11:27 -04:00
MagicBot 264094924b Proper accounting for workOrder removal post completion 2024-04-19 09:50:29 -04:00
MagicBot 0ec2b436de Window refresh update 2024-04-19 09:38:01 -04:00
MagicBot f36239a67e Window refresh update 2024-04-19 09:30:59 -04:00
MagicBot b673ca9636 Window refresh update 2024-04-19 09:27:50 -04:00
MagicBot cba7ee4066 Window refresh update 2024-04-19 09:23:34 -04:00
MagicBot 0f2b46b898 Window refresh update 2024-04-19 09:20:01 -04:00
MagicBot d76b670b75 Window refresh update 2024-04-19 09:18:30 -04:00
MagicBot ca71079106 Window refresh update 2024-04-19 09:16:38 -04:00
MagicBot adf686974d Window refresh update 2024-04-19 09:16:01 -04:00
MagicBot 6ecaa4dc0c Window refresh update 2024-04-19 09:07:49 -04:00
MagicBot c1939075cd Window refresh update 2024-04-19 09:07:23 -04:00
MagicBot 18587e281f refactored out collection 2024-04-19 09:03:35 -04:00
MagicBot dbd4c5d246 Method added to replace collection 2024-04-19 08:59:10 -04:00
MagicBot 919b29c38f Deduct cost from warehouse 2024-04-19 08:15:17 -04:00
MagicBot 01113fc3a6 Configure before setting cost 2024-04-17 14:24:05 -04:00
MagicBot b9627e1643 Class cleanup 2024-04-17 14:15:12 -04:00
MagicBot e6d83ca36c Mobloot vestiges removed 2024-04-17 14:07:42 -04:00
MagicBot a522eeb823 Update to completion 2024-04-17 13:59:34 -04:00
MagicBot 8d1561cd29 Update to completion 2024-04-17 13:58:25 -04:00
MagicBot d7ba42f4da Update to batch completion 2024-04-17 13:48:39 -04:00
MagicBot 689fc142d0 Persisted items belong in vendor inventory not virtual ones. 2024-04-17 13:46:10 -04:00
MagicBot 8df0c838cc More completion work 2024-04-17 12:47:28 -04:00
MagicBot f9825900cc More completion work 2024-04-17 12:36:23 -04:00
MagicBot 1a27a54926 Not right place for this perhaps 2024-04-17 12:24:17 -04:00
MagicBot 1e003c28ab Completion work 2024-04-17 12:20:45 -04:00
MagicBot 8cada05424 Completion time reset before new batch 2024-04-17 12:04:41 -04:00
MagicBot dda98318eb Work on virtual item handling 2024-04-17 11:56:23 -04:00
MagicBot 6e95ae5245 Variable naming update 2024-04-16 16:01:17 -04:00
MagicBot a4a9a26ac4 Complete is complete 2024-04-16 15:53:13 -04:00
MagicBot 93aec63f78 File reformat 2024-04-16 15:40:10 -04:00
MagicBot 9804a0fc89 Debug strings were removed 2024-04-16 15:35:55 -04:00
MagicBot 3484802a24 Comment cleanup 2024-04-16 15:34:39 -04:00
MagicBot 946a150db1 Comment cleanup 2024-04-16 15:34:14 -04:00
MagicBot 197df90a21 Comment cleanup 2024-04-16 15:33:39 -04:00
MagicBot a944f7342a All rolls treated equally 2024-04-16 15:17:15 -04:00
MagicBot 7c855afbe7 All runs set to complete 2024-04-16 15:11:03 -04:00
MagicBot d42bc3520d Single runs are set to complete. Multiple item runs are dumped to inventory. 2024-04-16 15:03:59 -04:00
MagicBot a86d90ef41 serialization work 2024-04-16 14:55:03 -04:00
MagicBot c5dfb3ad81 Serialization work 2024-04-16 14:47:35 -04:00
MagicBot e879c588dc More window work. 2024-04-16 14:21:29 -04:00
MagicBot 862e75cd4c Serialization updated. Collection adds slot. 2024-04-16 14:01:46 -04:00
MagicBot d47643e730 Error logging added 2024-04-15 15:48:15 -04:00
MagicBot 0727361933 More window work 2024-04-15 15:29:13 -04:00
MagicBot c1b0bcedf4 Remove workorder when completed 2024-04-15 15:22:11 -04:00
MagicBot 315c2abfb9 Remove workorder when completed 2024-04-15 15:15:08 -04:00
MagicBot b0c0c507e5 More window work 2024-04-15 14:59:07 -04:00
MagicBot 12b6e41432 Fixing Junk functionality 2024-04-15 14:45:34 -04:00
MagicBot a2484f94eb Bugfix in forge contains 2024-04-15 14:33:33 -04:00
MagicBot b4824c69b8 Window work 2024-04-15 14:24:50 -04:00
MagicBot 03fb180f02 Set variable on submit 2024-04-15 12:49:37 -04:00
MagicBot 250afe3bba Serialization update 2024-04-15 12:41:05 -04:00
MagicBot b80b3a81b5 Message sent early 2024-04-15 12:34:35 -04:00
MagicBot cd8b910262 Clear collections last 2024-04-15 12:31:16 -04:00
MagicBot d007850afe Clear collections last 2024-04-15 12:23:46 -04:00
MagicBot 7f3873b63f fail fast on null 2024-04-15 12:23:01 -04:00
MagicBot 963df074a4 More persist work 2024-04-15 12:17:57 -04:00
MagicBot 5505d7bc61 Items are persisted and moved to vendor inventory 2024-04-15 12:12:40 -04:00
MagicBot 0c9ec31fa3 Window serialization work 2024-04-15 11:53:24 -04:00
MagicBot d71c65702d Window serialization work 2024-04-15 11:49:42 -04:00
MagicBot a4af39cab7 Window serialization work 2024-04-15 11:45:38 -04:00
MagicBot 9ba697c310 Persist item work 2024-04-15 11:30:56 -04:00
MagicBot 2b670ea53a Persist item work 2024-04-15 11:17:10 -04:00
MagicBot 5ade37f7a4 Persist item work 2024-04-15 11:15:34 -04:00
MagicBot 1be657d3ef Persist item work 2024-04-15 11:07:26 -04:00
MagicBot 9dbefcd830 Unused variable removed 2024-04-15 11:01:53 -04:00
MagicBot e1a9ddae89 forged items are persisted 2024-04-14 17:30:35 -04:00
MagicBot 2690c3212b forged items are persisted 2024-04-14 17:18:58 -04:00
MagicBot aac7e46ae8 forged items are persisted 2024-04-14 17:04:59 -04:00
MagicBot a16bef418b forged items are persisted 2024-04-14 17:02:36 -04:00
MagicBot 8b4b3b971a forged items are persisted 2024-04-14 16:46:31 -04:00
MagicBot 692ee51608 forged items are persisted 2024-04-14 16:31:05 -04:00
MagicBot d5bd500f39 forged items are persisted 2024-04-14 16:29:17 -04:00
MagicBot e195d86fb6 Serialization update 2024-04-14 15:49:08 -04:00
MagicBot 114aeb9f64 Update NPC window 2024-04-14 15:38:24 -04:00
MagicBot d95bc5c261 Initialize all collections for npc 2024-04-14 15:30:10 -04:00
MagicBot 73fa5b5c7e Support for non-random rolling 2024-04-14 15:19:55 -04:00
MagicBot 85e5e2a7e3 Init forge support only for valid contracts 2024-04-14 15:17:32 -04:00
MagicBot 48f88ec819 Serialization update 2024-04-14 15:11:10 -04:00
MagicBot 139998eaa1 Moved declaration outside of loop 2024-04-14 15:02:52 -04:00
MagicBot 673f606de8 Cleanup of cache usage 2024-04-14 15:00:25 -04:00
MagicBot 9464500e95 More integration work 2024-04-14 14:48:59 -04:00
MagicBot 5e5b9884ef Begin integration 2024-04-14 14:13:10 -04:00
MagicBot 94ab64d629 reformat class 2024-04-14 14:11:22 -04:00
MagicBot 2c89509fa2 Moved logging message up 2024-04-14 14:07:06 -04:00
MagicBot fae81a0263 Removed cast in validation 2024-04-14 13:58:25 -04:00
MagicBot a8d5521dd8 Mobtype work related to ForgeManager 2024-04-14 13:51:37 -04:00
MagicBot ea555be08e Mobtype work related to ForgeManager 2024-04-14 13:13:28 -04:00
MagicBot 74e97fb435 Minor cleanup 2024-04-14 12:41:16 -04:00
MagicBot eed25d8c16 Minor cleanup 2024-04-14 12:24:53 -04:00
MagicBot bc195c27db Rework of error handling. 2024-04-14 12:14:17 -04:00
MagicBot 0653828fe3 Rework of error handling. 2024-04-14 12:13:51 -04:00
MagicBot 2feba8ac50 Rework of error handling. 2024-04-14 12:08:51 -04:00
MagicBot 5e7515a9ad Merge remote-tracking branch 'refs/remotes/origin/bugfix-combat-range' into feature-workorder2.4 2024-04-14 11:55:19 -04:00
FatBoy 2aaca661e2 new combat finalized 2024-04-13 19:44:03 -05:00
FatBoy 3f27bae099 mobs dont double tap when unarmed 2024-04-13 19:12:09 -05:00
FatBoy 79f4a33b6e add half player character height to attack range in lieu of hitbox 2024-04-13 19:10:10 -05:00
MagicBot ec47e24549 Not yet set when validating. 2024-04-13 12:26:39 -04:00
MagicBot 8fe7a6e896 Class cleanup 2024-04-13 11:28:48 -04:00
MagicBot f068e6891e Collection declaration cleanup 2024-04-13 10:10:17 -04:00
MagicBot cabbf8bf44 Java 8 TimeUnit 2024-04-13 10:06:44 -04:00
MagicBot 9c146fff4d Only random rolled items are unidentified. 2024-04-13 10:01:35 -04:00
MagicBot 333fcc9d14 Multiple item workOrder work 2024-04-13 09:53:20 -04:00
MagicBot 4aca075da6 Multiple item workOrder work 2024-04-13 09:38:58 -04:00
MagicBot a5bcdff216 Multiple item workOrder work 2024-04-13 09:31:18 -04:00
MagicBot 3c704d6b85 Multiple item workOrder work 2024-04-13 09:22:23 -04:00
MagicBot d26214d032 Multiple item workOrder work 2024-04-13 09:20:25 -04:00
MagicBot 09c96c772e Multiple item workOrder work 2024-04-13 09:10:56 -04:00
MagicBot f6e1c78b0b Debug string update 2024-04-13 08:57:53 -04:00
MagicBot ec80146117 forge items each cycle 2024-04-13 08:51:02 -04:00
MagicBot 980dee2e14 Work on multiple slot support 2024-04-13 08:31:36 -04:00
MagicBot 832b994757 Begin work on forgeItem() 2024-04-13 08:19:09 -04:00
MagicBot a18785fb3d Begin work on forgeItem() 2024-04-13 08:10:59 -04:00
MagicBot f076b38044 Contextual variable name updates 2024-04-13 07:54:26 -04:00
MagicBot 68f2af5306 Bugfix in delay override 2024-04-13 07:44:16 -04:00
MagicBot 052867893c Bugfix in delay override 2024-04-13 07:31:17 -04:00
MagicBot 13ba31285e Logging on each cycle 2024-04-13 07:26:39 -04:00
MagicBot 61a418fd8e Debug comment update 2024-04-13 07:18:55 -04:00
MagicBot 3fa4185b7f Debug comment update 2024-04-13 06:55:49 -04:00
MagicBot 5cb08c1dc0 Forge must be protected 2024-04-13 06:53:36 -04:00
MagicBot fc3a0eaf0c Forge must be protected 2024-04-13 06:48:58 -04:00
MagicBot 2e83b8c693 Better context in name 2024-04-13 06:42:21 -04:00
MagicBot 44eafc3345 Validation work 2024-04-12 17:41:08 -04:00
MagicBot 29ce3537f7 Work on cost overflow calculations 2024-04-12 17:29:52 -04:00
MagicBot 058887ff4d Locked resources are always unavailable. 2024-04-12 17:16:12 -04:00
MagicBot dc18e71ee4 Locked resources are always unavailable. 2024-04-12 17:15:04 -04:00
MagicBot 479e38e3f6 Validation work 2024-04-12 17:06:42 -04:00
MagicBot dd764281e8 Rolling duration updated 2024-04-12 16:52:43 -04:00
MagicBot f7959a51bd Rolling duration updated 2024-04-12 16:43:22 -04:00
MagicBot 97e0ada1a9 workerOrder cost updating 2024-04-12 16:16:34 -04:00
MagicBot cc3d5fe076 workerOrder cost updating 2024-04-12 15:48:25 -04:00
MagicBot 2200cb9bef workerOrder cost updating 2024-04-12 15:41:15 -04:00
MagicBot a16cda8a4a workerOrder cost updating 2024-04-12 15:31:12 -04:00
MagicBot af53859ba9 Comment added 2024-04-11 13:46:24 -04:00
MagicBot a7a1230f1b Work on wordOrder iteration 2024-04-10 18:01:27 -04:00
MagicBot df037a51f0 More info on template bootstrap 2024-04-10 17:40:00 -04:00
MagicBot 4d18e71aa1 More info on template bootstrap 2024-04-10 17:33:59 -04:00
MagicBot 7f579e5268 Bane rank loaded from template 2024-04-10 17:22:45 -04:00
MagicBot f6c53e51ed Calculate cost of workOrder 2024-04-10 16:47:02 -04:00
MagicBot 1429a3a4d5 Configure upon submit() 2024-04-10 16:06:09 -04:00
FatBoy dc81ddaba7 handle retaliate when being attacked 2024-04-09 21:23:29 -05:00
FatBoy 4a001179b5 add hitbox to abs vs abs range checks 2024-04-08 20:37:27 -05:00
FatBoy 1bff06cde0 using building bounds and hitBox for mele range 2024-04-08 20:20:16 -05:00
MagicBot ba4648f812 Minor class cleanup 2024-04-08 17:56:51 -04:00
MagicBot 1d0ab95b88 Minor class cleanup 2024-04-08 17:52:35 -04:00
MagicBot 275644ec83 Minor class cleanup 2024-04-08 17:42:47 -04:00
MagicBot 69416528b3 Minor class cleanup 2024-04-08 17:40:38 -04:00
MagicBot d3e0146d86 Minor class cleanup 2024-04-08 17:16:05 -04:00
MagicBot 35fab88949 Minor class cleanup 2024-04-08 17:15:56 -04:00
MagicBot 27a37eba79 Minor class cleanup 2024-04-08 17:06:42 -04:00
MagicBot deb5b36309 Minor class cleanup 2024-04-08 17:02:20 -04:00
MagicBot b84de95865 Minor class cleanup 2024-04-08 16:58:07 -04:00
MagicBot 5650c0f05a Minor class cleanup 2024-04-08 16:54:33 -04:00
MagicBot afa1b8478a Minor class cleanup 2024-04-08 16:53:53 -04:00
MagicBot cafe0a0fe1 Minor class cleanup 2024-04-08 16:49:19 -04:00
MagicBot bfa43823f6 Minor class cleanup 2024-04-08 16:42:44 -04:00
MagicBot 533ed87321 Minor class cleanup 2024-04-08 16:26:56 -04:00
MagicBot 129bd4aaa6 Minor class cleanup 2024-04-08 16:26:29 -04:00
MagicBot eb93481fda Merge branch 'feature-workorder2.4' of http://repo.magicbane.com/MagicBane/Server into feature-workorder2.4 2024-04-08 16:23:41 -04:00
MagicBot a160fe1b00 Time recycle update 2024-04-08 16:23:08 -04:00
MagicBot c2f70c0f26 Unused method removed 2024-04-08 15:58:48 -04:00
MagicBot 98c0712dea Method to calculate warehosue overflow. 2024-04-08 15:55:57 -04:00
MagicBot 7c4f7f391b Method to calculate warehosue overflow. 2024-04-08 15:54:25 -04:00
MagicBot e01dc9b09c More fleshing out of workorder usage 2024-04-08 13:15:40 -04:00
MagicBot 178bb3718a Slot count calculated 2024-04-08 13:10:23 -04:00
MagicBot f088d2aa72 More WorkOrder work 2024-04-08 13:06:22 -04:00
MagicBot 0645a93b9c Track items and their workorders. 2024-04-08 04:46:54 -04:00
MagicBot 8b38f1a695 Track items and their workorders. 2024-04-08 04:42:44 -04:00
MagicBot 652476fde8 Track items and their workorders. 2024-04-08 04:37:27 -04:00
MagicBot 74a7a255be Track items and their workorders. 2024-04-08 04:32:04 -04:00
MagicBot abd112035a Track items and their workorders. 2024-04-08 04:17:31 -04:00
MagicBot f5f92a1d88 rollingDuration fleshed out 2024-04-07 23:21:35 -04:00
MagicBot 75d520831f More workorder logic work 2024-04-07 23:00:37 -04:00
MagicBot 92402097d4 ForgeManager started at boot 2024-04-07 22:53:41 -04:00
MagicBot 5e92bab977 submit workorder to forgemanager 2024-04-07 22:40:14 -04:00
MagicBot a5df674fbe Update to debug strings 2024-04-07 22:34:06 -04:00
MagicBot 4462f74f8c More workorder work. 2024-04-07 22:31:58 -04:00
MagicBot 781053ab22 Debug string added 2024-04-07 22:28:07 -04:00
MagicBot 053c105c26 Method to validate workorder 2024-04-07 22:21:47 -04:00
MagicBot 46bf67672a workorder fields assigned 2024-04-07 22:18:12 -04:00
MagicBot d539e419fe Begin adding workOrder logic 2024-04-07 22:15:06 -04:00
MagicBot ec5a8f5281 Logic cleanup. 2024-04-07 13:25:42 -04:00
MagicBot 97558b51c8 Method moved to top of handler. 2024-04-07 13:23:22 -04:00
MagicBot 4a3a8d4b65 Minor class cleanup 2024-04-07 13:10:58 -04:00
MagicBot 85a66339e2 inline accessors 2024-04-07 13:08:00 -04:00
MagicBot b785d35231 Removed unused method 2024-04-07 13:03:24 -04:00
MagicBot 21b1dba84d Switch directly on actiontype 2024-04-07 13:01:43 -04:00
MagicBot fc71b8cb61 Inline setter 2024-04-07 12:53:55 -04:00
MagicBot 31129493e5 ActionType Take 2024-04-07 12:51:58 -04:00
MagicBot 8b4eafebf3 Elevate access. It's a message... 2024-04-07 12:48:56 -04:00
MagicBot cf38362d84 Handler uses enumeration 2024-04-07 12:45:13 -04:00
MagicBot 30800478f2 Message now uses enum 2024-04-07 12:04:15 -04:00
MagicBot 9bbe9b399e Better name for map 2024-04-06 16:08:06 -04:00
MagicBot 16d17798be Mirror field in client 2024-04-06 16:06:55 -04:00
MagicBot 679c7afe0e field is templateID not item uuid. 2024-04-06 16:05:52 -04:00
MagicBot f10141eddb Variable removed from city 2024-04-06 15:45:45 -04:00
MagicBot 10805a7d37 Class moved up in package 2024-04-06 15:30:35 -04:00
MagicBot b979fbb1bc Begin message rewrite 2024-04-06 14:01:23 -04:00
MagicBot b86ca33087 Unused variables removed 2024-04-06 10:56:31 -04:00
MagicBot 993abfbf6f variable renamed 2024-04-06 07:26:17 -04:00
MagicBot ffd41101c3 variable renamed 2024-04-05 20:14:29 -04:00
MagicBot 39e06994d9 Workorder and Forgemanger classes created 2024-04-05 20:13:16 -04:00
MagicBot ec405226c5 Formation refactored to enum 2024-04-05 19:37:45 -04:00
MagicBot 627a35e364 Update to devcmd 2024-04-05 09:43:30 -04:00
MagicBot 6254472bb8 New column used in rs constructor 2024-04-05 09:35:38 -04:00
MagicBot 0bbedd5983 Code removed; column populated 2024-04-05 09:33:57 -04:00
MagicBot 58fb2a9b90 Populate new column in table. 2024-04-05 09:30:00 -04:00
MagicBot f7c76937fb Writing string of bitset for contracts. 2024-04-05 09:18:12 -04:00
MagicBot 52865d7cfd refactored out dependency 2024-04-05 08:57:00 -04:00
MagicBot 8424aa557f refactored out dependency 2024-04-05 08:55:41 -04:00
MagicBot 0ab7bafe5e refactored out dependency 2024-04-05 08:54:58 -04:00
MagicBot 43b212ed42 refactored out dependency 2024-04-05 08:53:18 -04:00
MagicBot 0b4873a522 refactored out dependency 2024-04-05 08:44:59 -04:00
MagicBot d3d1227d6c refactored out dependency 2024-04-05 08:35:48 -04:00
MagicBot 181e7661c1 fromString and asString EnumSet helper methods created 2024-04-05 08:10:28 -04:00
MagicBot c1ee6f5b52 Renamed class to not conflict with the java.lang version. 2024-04-05 07:59:44 -04:00
MagicBot dd84615ca1 Optimization moved to method 2024-04-04 15:26:32 -04:00
MagicBot aad0418260 Faster if bitvector is 0. 2024-04-04 15:18:43 -04:00
MagicBot 46f3850e93 Values parsed as behaviourtype enumset 2024-04-04 15:16:11 -04:00
MagicBot ab34931c3d Test if value is enumset 2024-04-04 15:05:25 -04:00
MagicBot 52116063e5 Test if value is enumset 2024-04-04 15:02:19 -04:00
MagicBot 04243cc21e Arraylists of ints 2024-04-04 14:27:07 -04:00
MagicBot 1ab041ce0f Last two variables need work. 2024-04-04 14:05:05 -04:00
MagicBot 1dac740fca Bitvector helper method added. 2024-04-04 13:59:30 -04:00
MagicBot 1e3e173dfe Final class cleanup. 2024-04-04 13:27:43 -04:00
MagicBot 27971c5fb3 not_enemy_types_json parsed 2024-04-04 13:18:37 -04:00
MagicBot 52fab5d92b not_enemy_types_json parsed 2024-04-04 13:18:19 -04:00
MagicBot 5054006ffc not_enemy_types_json parsed 2024-04-04 13:15:53 -04:00
MagicBot f4e24e032b rune_enemy_monster_types parsed 2024-04-04 13:14:21 -04:00
MagicBot 2248361503 rune_enemy_monster_types parsed 2024-04-04 13:13:14 -04:00
MagicBot 5c20fca28a Rune skill adjusts parsed 2024-04-04 12:16:29 -04:00
MagicBot 9bbb949868 Rune skill adjusts parsed 2024-04-04 11:54:01 -04:00
MagicBot 3e6bfacd86 Fix for mixed type values 2024-04-04 11:43:02 -04:00
MagicBot 1043c84b9d Both sparse fields parsed 2024-04-04 11:34:02 -04:00
MagicBot febada8d63 Both sparse fields parsed 2024-04-04 11:15:47 -04:00
MagicBot 8b6fef4cbc Both sparse fields parsed 2024-04-04 11:13:58 -04:00
MagicBot 1ce9029edf Fix to rune_group parsing 2024-04-04 11:02:50 -04:00
MagicBot 587ac802de Fix to rune_group parsing 2024-04-04 11:00:19 -04:00
MagicBot 58455843f9 long not double 2024-04-04 10:54:43 -04:00
MagicBot a09ac1f2a2 long not double 2024-04-04 10:54:22 -04:00
MagicBot 8c454c5d7c Using name as template id is not yet set. 2024-04-04 10:47:55 -04:00
MagicBot 83dd47d22a Test 2024-04-04 10:46:40 -04:00
MagicBot c2910bb87c Test 2024-04-04 10:45:45 -04:00
MagicBot 7e6c051a02 More parsing work; sparse_data field loaded into string for now. 2024-04-04 10:39:54 -04:00
MagicBot 35b368d7fe rune_speed parsed 2024-04-04 10:37:12 -04:00
MagicBot d39790ab4c More parsing work 2024-04-04 10:23:21 -04:00
MagicBot 09d28b964a More parsing work 2024-04-04 10:13:25 -04:00
MagicBot 139490e943 Fields defined. 2024-04-04 10:07:42 -04:00
MagicBot 8830388728 More rune parsing work 2024-04-04 09:56:25 -04:00
MagicBot 68b9f9e887 More rune parsing 2024-04-04 09:54:52 -04:00
MagicBot 5ef45a2212 Parsing power_granted_skills 2024-04-04 09:52:19 -04:00
MagicBot 772e7f7f29 Parsing power_granted_skills 2024-04-04 09:43:41 -04:00
MagicBot 8afa00f885 Parsing skill_granted_skills 2024-04-04 09:34:44 -04:00
MagicBot fcf76011f4 power_granted_skills hashmap defined 2024-04-03 16:14:21 -04:00
MagicBot 3e2f420c30 skills_granted_array started for rune 2024-04-03 13:40:24 -04:00
MagicBot 26fd6f8de2 Update to error string 2024-04-03 12:57:02 -04:00
MagicBot 0966b82d5f rune_skill_grant parsed 2024-04-02 15:24:52 -04:00
MagicBot d526d69bca rune_skill_grant parsed 2024-04-02 15:17:33 -04:00
MagicBot 242984ffaf Rune attribute and max attribute adjusts parsed 2024-04-02 14:44:50 -04:00
MagicBot 4746a8c9cf More parsing work. 2024-04-02 14:41:22 -04:00
MagicBot 1603c8d8e9 Rename to conform 2024-04-02 14:37:01 -04:00
MagicBot ddba4f290d Rename to conform 2024-04-02 14:14:27 -04:00
MagicBot d621877e8c Begin rune parsing 2024-04-02 14:11:01 -04:00
MagicBot 713a52f705 Serialize current stats 2024-04-02 13:09:24 -04:00
MagicBot c68d5e0730 Attack bypass inserted 2024-04-02 12:49:36 -04:00
MagicBot 49c62fae60 Debug string 2024-04-02 12:42:28 -04:00
MagicBot 3bd4e75422 Debug string 2024-04-02 12:38:19 -04:00
MagicBot 791e5cb9b8 Attack early exit 2024-04-02 12:36:36 -04:00
MagicBot 2fb8f53751 Attack early exit 2024-04-02 12:33:01 -04:00
MagicBot dc366068a9 Methods moved to new handler 2024-04-02 12:00:59 -04:00
MagicBot 3ec76ab816 ItemManager created 2024-04-02 11:53:22 -04:00
MagicBot d8750f5e2c Unused methods removed 2024-04-01 17:28:48 -04:00
MagicBot f272be8b4d Header added to class 2024-04-01 17:26:38 -04:00
MagicBot f8f86d8e46 Header added to new class 2024-04-01 17:25:56 -04:00
MagicBot ee030a690a Project reformat 2024-04-01 17:00:14 -04:00
MagicBot 3df1da364c Magic number removed 2024-04-01 16:54:10 -04:00
MagicBot 389373be30 Not static 2024-04-01 16:45:00 -04:00
MagicBot cc02be95f3 Proper parsing of power grants 2024-04-01 16:32:17 -04:00
MagicBot 5a1027c611 Proper parsing of power grants 2024-04-01 16:26:35 -04:00
MagicBot 64e780744d Proper parsing of power grants 2024-04-01 16:23:54 -04:00
MagicBot 0abffeeb7f Proper parsing of power grants 2024-04-01 16:21:56 -04:00
MagicBot 75f11deee1 Proper parsing of power grants 2024-04-01 16:20:03 -04:00
MagicBot db91b606f6 Proper parsing of power grants 2024-04-01 16:12:52 -04:00
MagicBot 82373f8cc8 Proper parsing of power grants 2024-04-01 16:05:55 -04:00
MagicBot 946714d3ae Proper parsing of power grants 2024-04-01 15:53:36 -04:00
MagicBot 8414b0f4cf Consumable items are item_power_grant for their lookup 2024-04-01 15:26:52 -04:00
MagicBot faa262db99 Revert "Temp fix for 3 modifiers"
This reverts commit 6955f69156.
2024-04-01 14:21:16 -04:00
MagicBot 6955f69156 Temp fix for 3 modifiers 2024-04-01 13:51:20 -04:00
MagicBot 2ae39d2a29 Corrected source type 2024-04-01 13:07:18 -04:00
MagicBot 8e44adf16e No need for toUpper() here. 2024-04-01 12:58:16 -04:00
MagicBot fd73dbc349 Source types updated to match damage type 2024-04-01 12:53:49 -04:00
MagicBot f58aa61859 PIERCING 2024-04-01 12:42:49 -04:00
MagicBot ae7fecbf6d Effectbase updated with new enum 2024-04-01 12:41:33 -04:00
MagicBot 5ed497dd69 All damage type lookups go through method 2024-04-01 12:35:44 -04:00
MagicBot 14ee83e147 DamageType defined as in JSON 2024-04-01 12:13:19 -04:00
MagicBot a29269e335 Initial refactor of damagetype 2024-04-01 09:19:37 -04:00
MagicBot adfbf87056 Handler update. 2024-03-31 11:22:22 -04:00
MagicBot d80231eef0 Handler update. 2024-03-31 11:20:32 -04:00
MagicBot 3395efee49 bugfix: wrong char! 2024-03-31 11:01:12 -04:00
MagicBot 7acaccc77d Protocol handler code update 2024-03-31 10:54:33 -04:00
MagicBot 5aa01d94fd New handlers plugged into protocol class 2024-03-31 10:50:40 -04:00
MagicBot 7b405bbbf3 New handlers plugged into protocol class 2024-03-31 10:49:08 -04:00
MagicBot 504e26114e Migration to protocol class 2024-03-31 10:42:17 -04:00
MagicBot 4e5e49606c Methods moved out of old login handler 2024-03-31 10:37:03 -04:00
MagicBot f62f11a66c Handler created for GameServerIPRequestMsg 2024-03-31 10:33:46 -04:00
MagicBot 7911a17f0c Handler created for deletecharmsg 2024-03-31 10:26:01 -04:00
MagicBot 5c8c4fc817 Handler created for deletecharmsg 2024-03-31 10:25:25 -04:00
MagicBot 854d0a8a68 Handler created for commitnewcharmsg 2024-03-31 10:20:44 -04:00
MagicBot 61fca2c742 Handler created for ServerInfoMsg 2024-03-31 10:13:17 -04:00
MagicBot b752006d6f Handlers created for VersionInfoMsg and ClientLoginInfoMsg 2024-03-31 10:09:32 -04:00
612 changed files with 7613 additions and 8873 deletions
+4 -4
View File
@@ -9,8 +9,8 @@
package discord;
import engine.Enum;
import engine.gameManager.ConfigManager;
import engine.mbEnums;
import org.pmw.tinylog.Logger;
import java.sql.*;
@@ -70,7 +70,7 @@ public class Database {
}
}
public boolean updateAccountStatus(String discordAccountID, Enum.AccountStatus accountStatus) {
public boolean updateAccountStatus(String discordAccountID, mbEnums.AccountStatus accountStatus) {
try (Connection connection = DriverManager.getConnection(sqlURI, ConfigManager.MB_DATABASE_USER.getValue(),
ConfigManager.MB_DATABASE_PASS.getValue());
@@ -131,7 +131,7 @@ public class Database {
discordAccount = new DiscordAccount();
discordAccount.discordAccount = rs.getString("discordAccount");
discordAccount.gameAccountName = rs.getString("acct_uname");
discordAccount.status = Enum.AccountStatus.valueOf(rs.getString("status"));
discordAccount.status = mbEnums.AccountStatus.valueOf(rs.getString("status"));
discordAccount.isDiscordAdmin = rs.getByte("discordAdmin"); // Registration date cannot be null
Timestamp registrationDate = rs.getTimestamp("registrationDate");
@@ -328,7 +328,7 @@ public class Database {
discordAccount = new DiscordAccount();
discordAccount.discordAccount = rs.getString("discordAccount");
discordAccount.gameAccountName = rs.getString("acct_uname");
discordAccount.status = Enum.AccountStatus.valueOf(rs.getString("status"));
discordAccount.status = mbEnums.AccountStatus.valueOf(rs.getString("status"));
// Registration date cannot be null
+2 -2
View File
@@ -8,14 +8,14 @@
package discord;
import engine.Enum;
import engine.mbEnums;
import java.time.LocalDateTime;
public class DiscordAccount {
public String discordAccount;
public String gameAccountName;
public Enum.AccountStatus status;
public mbEnums.AccountStatus status;
public LocalDateTime registrationDate;
public LocalDateTime lastUpdateRequest;
public byte isDiscordAdmin;
+2 -2
View File
@@ -11,7 +11,7 @@ package discord.handlers;
import discord.Database;
import discord.DiscordAccount;
import discord.MagicBot;
import engine.Enum;
import engine.mbEnums;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import java.util.List;
@@ -21,7 +21,7 @@ public class AccountInfoRequest {
public static void handleRequest(MessageReceivedEvent event) {
String discordAccountID = event.getAuthor().getId();
Enum.AccountStatus accountStatus;
mbEnums.AccountStatus accountStatus;
if (Database.online == false) {
+6 -6
View File
@@ -11,7 +11,7 @@ package discord.handlers;
import discord.DiscordAccount;
import discord.MagicBot;
import discord.RobotSpeak;
import engine.Enum;
import engine.mbEnums;
import net.dv8tion.jda.api.entities.User;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import org.pmw.tinylog.Logger;
@@ -23,7 +23,7 @@ public class BanToggleHandler {
public static void handleRequest(MessageReceivedEvent event, String[] args) {
String discordAccountID;
Enum.AccountStatus accountStatus;
mbEnums.AccountStatus accountStatus;
// Early exit if database unavailable or is not an admin
@@ -55,10 +55,10 @@ public class BanToggleHandler {
// toggle ban status
if (discordAccounts.get(0).status.equals(Enum.AccountStatus.BANNED))
accountStatus = Enum.AccountStatus.ACTIVE;
if (discordAccounts.get(0).status.equals(mbEnums.AccountStatus.BANNED))
accountStatus = mbEnums.AccountStatus.ACTIVE;
else
accountStatus = Enum.AccountStatus.BANNED;
accountStatus = mbEnums.AccountStatus.BANNED;
// We have a valid discord ID at this point. Banstick?
@@ -82,7 +82,7 @@ public class BanToggleHandler {
// If we're toggling status to active we're done here.
if (accountStatus.equals(Enum.AccountStatus.ACTIVE))
if (accountStatus.equals(mbEnums.AccountStatus.ACTIVE))
return;
// Set users role to noob
@@ -11,7 +11,7 @@ package discord.handlers;
import discord.Database;
import discord.DiscordAccount;
import discord.MagicBot;
import engine.Enum;
import engine.mbEnums;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import org.pmw.tinylog.Logger;
@@ -53,7 +53,7 @@ public class PasswordChangeHandler {
// Banned or suspended user's get no love.
if (discordAccount.status.equals(Enum.AccountStatus.BANNED)) {
if (discordAccount.status.equals(mbEnums.AccountStatus.BANNED)) {
MagicBot.sendResponse(event,
"Sorry but that is too much work. \n" +
"Your account detailings cannot for to log into game!");
@@ -8,16 +8,16 @@
package engine.InterestManagement;
import engine.Enum;
import engine.Enum.DispatchChannel;
import engine.Enum.GameObjectType;
import engine.gameManager.DispatchManager;
import engine.gameManager.GroupManager;
import engine.gameManager.SessionManager;
import engine.job.JobScheduler;
import engine.jobs.RefreshGroupJob;
import engine.mbEnums;
import engine.mbEnums.DispatchChannel;
import engine.mbEnums.GameObjectType;
import engine.net.AbstractNetMsg;
import engine.net.Dispatch;
import engine.net.DispatchMessage;
import engine.net.client.ClientConnection;
import engine.net.client.msg.LoadCharacterMsg;
import engine.net.client.msg.LoadStructureMsg;
@@ -88,7 +88,7 @@ public enum InterestManager implements Runnable {
if (send) {
Dispatch dispatch = Dispatch.borrow(player, msg);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
DispatchManager.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
}
}
}
@@ -270,7 +270,7 @@ public enum InterestManager implements Runnable {
}
Dispatch dispatch = Dispatch.borrow(player, uom);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
DispatchManager.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
}
loadedStaticObjects.removeAll(toRemove);
@@ -292,7 +292,7 @@ public enum InterestManager implements Runnable {
lcm = new LoadCharacterMsg(corpse, PlayerCharacter.hideNonAscii());
Dispatch dispatch = Dispatch.borrow(player, lcm);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
DispatchManager.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
} else if (awo.getObjectType().equals(GameObjectType.NPC)) {
NPC npc = (NPC) awo;
@@ -304,13 +304,13 @@ public enum InterestManager implements Runnable {
if (lsm.getStructureList().size() > 0) {
Dispatch dispatch = Dispatch.borrow(player, lsm);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
DispatchManager.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
}
for (LoadCharacterMsg lc : lcmList) {
Dispatch dispatch = Dispatch.borrow(player, lc);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
DispatchManager.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
}
loadedStaticObjects.addAll(toLoad);
@@ -414,7 +414,7 @@ public enum InterestManager implements Runnable {
if (!uom.getObjectList().isEmpty()) {
Dispatch dispatch = Dispatch.borrow(player, uom);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
DispatchManager.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
}
}
@@ -482,7 +482,7 @@ public enum InterestManager implements Runnable {
awonpc.playerAgroMap.put(player.getObjectUUID(), 0f);
if ((awonpc.agentType.equals(Enum.AIAgentType.MOBILE)))
if ((awonpc.agentType.equals(mbEnums.AIAgentType.MOBILE)))
((Mob) awonpc).setCombatTarget(null);
lcm = new LoadCharacterMsg(awonpc, PlayerCharacter.hideNonAscii());
@@ -492,7 +492,7 @@ public enum InterestManager implements Runnable {
if (lcm != null) {
Dispatch dispatch = Dispatch.borrow(player, lcm);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
DispatchManager.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
}
+16 -13
View File
@@ -8,14 +8,10 @@
package engine.InterestManagement;
/* This class is the main interface for Magicbane's
* Interest management facilities.
*/
import engine.Enum;
import engine.gameManager.DispatchManager;
import engine.math.Vector3fImmutable;
import engine.mbEnums;
import engine.net.Dispatch;
import engine.net.DispatchMessage;
import engine.net.client.msg.TerritoryChangeMessage;
import engine.objects.City;
import engine.objects.PlayerCharacter;
@@ -31,10 +27,17 @@ import static engine.objects.Realm.getRealm;
public enum RealmMap {
REALM_MAP;
// MB Dev Notes:
// This class loads and caches realm maps used by each
// map set for its realm overlay. The RealmMap loaded is
// controlled by config entry MB_WORLD_REALMMAP
//
// Unlike a Heightmap this is a just color lookup; identical to
// the old image maps used in 90s web technology.
//
// Realm Map images are stored on disk in /mb.data/realmmaps/
// Spatial hashmap. Used for determining which Realm
// a player is currently located within.
REALM_MAP;
private static final HashMap<Color, Integer> _rgbToIDMap = new HashMap<>();
public static int[][] _realmImageMap;
@@ -65,7 +68,7 @@ public enum RealmMap {
public static Realm getRealmForCity(City city) {
Realm outRealm = null;
outRealm = city.getRealm();
outRealm = city.realm;
return outRealm;
}
@@ -88,17 +91,17 @@ public enum RealmMap {
if (city != null) {
TerritoryChangeMessage tcm = new TerritoryChangeMessage((PlayerCharacter) realm.getRulingCity().getOwner(), realm);
Dispatch dispatch = Dispatch.borrow(player, tcm);
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.PRIMARY);
DispatchManager.dispatchMsgDispatch(dispatch, mbEnums.DispatchChannel.PRIMARY);
} else {
TerritoryChangeMessage tcm = new TerritoryChangeMessage(null, realm);
Dispatch dispatch = Dispatch.borrow(player, tcm);
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.PRIMARY);
DispatchManager.dispatchMsgDispatch(dispatch, mbEnums.DispatchChannel.PRIMARY);
}
} else {
TerritoryChangeMessage tcm = new TerritoryChangeMessage(null, realm);
Dispatch dispatch = Dispatch.borrow(player, tcm);
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.PRIMARY);
DispatchManager.dispatchMsgDispatch(dispatch, mbEnums.DispatchChannel.PRIMARY);
}
}
+9 -1
View File
@@ -18,6 +18,14 @@ import java.util.HashMap;
import static java.lang.Math.PI;
// MB Dev Notes:
// The Terrain class handles lookups into the Heightmap data.
// It supports all current maps along with the differences in
// their parenting configuration.
//
// Heightmap images are stored on disk in /mb.data/heightmaps/
public class Terrain {
public static final HashMap<Integer, short[][]> _heightmap_pixel_cache = new HashMap<>();
public short[][] terrain_pixel_data;
@@ -112,7 +120,7 @@ public class Terrain {
public static float getWorldHeight(Zone zone, Vector3fImmutable world_loc) {
// Retrieve the next zone with a terrain defined.
// Retrieve the next zone up in the tree with a terrain defined.
Zone terrainZone = getNextZoneWithTerrain(zone);
Zone parentZone = getNextZoneWithTerrain(zone.parent);
+11 -11
View File
@@ -8,11 +8,11 @@
package engine.InterestManagement;
import engine.Enum.GridObjectType;
import engine.gameManager.DispatchManager;
import engine.math.FastMath;
import engine.math.Vector3f;
import engine.math.Vector3fImmutable;
import engine.net.DispatchMessage;
import engine.mbEnums.GridObjectType;
import engine.net.client.ClientConnection;
import engine.net.client.msg.LoadCharacterMsg;
import engine.net.client.msg.LoadStructureMsg;
@@ -201,7 +201,7 @@ public class WorldGrid {
UnloadObjectsMsg uom = new UnloadObjectsMsg();
uom.addObject(awo);
DispatchMessage.sendToAllInRange(awo, uom);
DispatchManager.sendToAllInRange(awo, uom);
}
public static void loadObject(AbstractWorldObject awo) {
@@ -213,15 +213,15 @@ public class WorldGrid {
case Building:
lsm = new LoadStructureMsg();
lsm.addObject((Building) awo);
DispatchMessage.sendToAllInRange(awo, lsm);
DispatchManager.sendToAllInRange(awo, lsm);
break;
case NPC:
lcm = new LoadCharacterMsg((NPC) awo, false);
DispatchMessage.sendToAllInRange(awo, lcm);
DispatchManager.sendToAllInRange(awo, lcm);
break;
case Mob:
lcm = new LoadCharacterMsg((Mob) awo, false);
DispatchMessage.sendToAllInRange(awo, lcm);
DispatchManager.sendToAllInRange(awo, lcm);
break;
default:
// *** Refactor: Log error?
@@ -239,19 +239,19 @@ public class WorldGrid {
case Building:
lsm = new LoadStructureMsg();
lsm.addObject((Building) awo);
DispatchMessage.sendToAllInRange(awo, lsm);
DispatchManager.sendToAllInRange(awo, lsm);
break;
case NPC:
lcm = new LoadCharacterMsg((NPC) awo, false);
DispatchMessage.sendToAllInRange(awo, lcm);
DispatchManager.sendToAllInRange(awo, lcm);
break;
case Mob:
lcm = new LoadCharacterMsg((Mob) awo, false);
DispatchMessage.sendToAllInRange(awo, lcm);
DispatchManager.sendToAllInRange(awo, lcm);
break;
case PlayerCharacter:
lcm = new LoadCharacterMsg((PlayerCharacter) awo, false);
DispatchMessage.sendToAllInRange(awo, lcm);
DispatchManager.sendToAllInRange(awo, lcm);
break;
default:
// *** Refactor: Log error?
@@ -263,7 +263,7 @@ public class WorldGrid {
ClientConnection origin) {
UnloadObjectsMsg uom = new UnloadObjectsMsg();
uom.addObject(awo);
DispatchMessage.sendToAllInRange(awo, uom);
DispatchManager.sendToAllInRange(awo, uom);
}
public static void addObject(AbstractWorldObject awo, PlayerCharacter pc) {
+4 -4
View File
@@ -9,8 +9,8 @@
package engine.db.archive;
import engine.Enum;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.Bane;
import engine.objects.City;
import engine.workthreads.WarehousePushThread;
@@ -21,7 +21,7 @@ import java.sql.*;
import java.time.LocalDateTime;
import java.util.concurrent.LinkedBlockingQueue;
import static engine.Enum.RecordEventType;
import static engine.mbEnums.RecordEventType;
public class BaneRecord extends DataRecord {
@@ -38,7 +38,7 @@ public class BaneRecord extends DataRecord {
private DateTime baneDropTime;
private BaneRecord(Bane bane) {
this.recordType = Enum.DataRecordType.BANE;
this.recordType = mbEnums.DataRecordType.BANE;
this.eventType = RecordEventType.PENDING;
}
@@ -51,7 +51,7 @@ public class BaneRecord extends DataRecord {
baneRecord = new BaneRecord(bane);
baneRecord.eventType = eventType;
} else {
baneRecord.recordType = Enum.DataRecordType.BANE;
baneRecord.recordType = mbEnums.DataRecordType.BANE;
baneRecord.eventType = eventType;
}
+3 -3
View File
@@ -9,8 +9,8 @@
package engine.db.archive;
import engine.Enum;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.Guild;
import engine.objects.PlayerCharacter;
import engine.workthreads.WarehousePushThread;
@@ -33,7 +33,7 @@ public class CharacterRecord extends DataRecord {
private PlayerCharacter player;
private CharacterRecord(PlayerCharacter player) {
this.recordType = Enum.DataRecordType.CHARACTER;
this.recordType = mbEnums.DataRecordType.CHARACTER;
this.player = player;
}
@@ -45,7 +45,7 @@ public class CharacterRecord extends DataRecord {
if (characterRecord == null) {
characterRecord = new CharacterRecord(player);
} else {
characterRecord.recordType = Enum.DataRecordType.CHARACTER;
characterRecord.recordType = mbEnums.DataRecordType.CHARACTER;
characterRecord.player = player;
}
+7 -7
View File
@@ -9,8 +9,8 @@
package engine.db.archive;
import engine.Enum;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.City;
import engine.workthreads.WarehousePushThread;
@@ -20,7 +20,7 @@ import java.util.concurrent.LinkedBlockingQueue;
public class CityRecord extends DataRecord {
private static final LinkedBlockingQueue<CityRecord> recordPool = new LinkedBlockingQueue<>();
private Enum.RecordEventType eventType;
private mbEnums.RecordEventType eventType;
private City city;
private String cityHash;
private String cityGuildHash;
@@ -32,13 +32,13 @@ public class CityRecord extends DataRecord {
private java.time.LocalDateTime establishedDatetime;
private CityRecord(City city) {
this.recordType = Enum.DataRecordType.CITY;
this.recordType = mbEnums.DataRecordType.CITY;
this.city = city;
this.eventType = Enum.RecordEventType.CREATE;
this.eventType = mbEnums.RecordEventType.CREATE;
}
public static CityRecord borrow(City city, Enum.RecordEventType eventType) {
public static CityRecord borrow(City city, mbEnums.RecordEventType eventType) {
CityRecord cityRecord;
cityRecord = recordPool.poll();
@@ -47,7 +47,7 @@ public class CityRecord extends DataRecord {
cityRecord = new CityRecord(city);
cityRecord.eventType = eventType;
} else {
cityRecord.recordType = Enum.DataRecordType.CITY;
cityRecord.recordType = mbEnums.DataRecordType.CITY;
cityRecord.eventType = eventType;
cityRecord.city = city;
@@ -69,7 +69,7 @@ public class CityRecord extends DataRecord {
cityRecord.zoneHash = cityRecord.city.getParent().hash;
if (cityRecord.eventType.equals(Enum.RecordEventType.CREATE))
if (cityRecord.eventType.equals(mbEnums.RecordEventType.CREATE))
cityRecord.establishedDatetime = cityRecord.city.established;
else
cityRecord.establishedDatetime = java.time.LocalDateTime.now();
+2 -2
View File
@@ -9,11 +9,11 @@
package engine.db.archive;
import engine.Enum;
import engine.mbEnums;
class DataRecord {
public Enum.DataRecordType recordType;
public mbEnums.DataRecordType recordType;
DataRecord() {
+1 -1
View File
@@ -22,7 +22,7 @@ import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.concurrent.LinkedBlockingQueue;
import static engine.Enum.DataRecordType;
import static engine.mbEnums.DataRecordType;
public class DataWarehouse implements Runnable {
+9 -8
View File
@@ -9,9 +9,9 @@
package engine.db.archive;
import engine.Enum;
import engine.Enum.RecordEventType;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.mbEnums.RecordEventType;
import engine.objects.Guild;
import engine.workthreads.WarehousePushThread;
@@ -30,7 +30,7 @@ public class GuildRecord extends DataRecord {
public static HashMap<Integer, GuildRecord> GuildRecordCache = null;
public String guildHash;
public int guildID;
private Enum.RecordEventType eventType;
private mbEnums.RecordEventType eventType;
private Guild guild;
private String guildName;
private String charterName;
@@ -44,9 +44,9 @@ public class GuildRecord extends DataRecord {
private java.time.LocalDateTime eventDatetime;
private GuildRecord(Guild guild) {
this.recordType = Enum.DataRecordType.GUILD;
this.recordType = mbEnums.DataRecordType.GUILD;
this.guild = guild;
this.eventType = Enum.RecordEventType.CREATE;
this.eventType = mbEnums.RecordEventType.CREATE;
}
@@ -71,7 +71,7 @@ public class GuildRecord extends DataRecord {
}
public static GuildRecord borrow(Guild guild, Enum.RecordEventType eventType) {
public static GuildRecord borrow(Guild guild, mbEnums.RecordEventType eventType) {
GuildRecord guildRecord;
//add
guildRecord = recordPool.poll();
@@ -81,7 +81,7 @@ public class GuildRecord extends DataRecord {
guildRecord.eventType = eventType;
} else {
guildRecord.guild = guild;
guildRecord.recordType = Enum.DataRecordType.GUILD;
guildRecord.recordType = mbEnums.DataRecordType.GUILD;
guildRecord.eventType = eventType;
}
@@ -89,7 +89,8 @@ public class GuildRecord extends DataRecord {
guildRecord.guildHash = guildRecord.guild.getHash();
guildRecord.guildID = guildRecord.guild.getObjectUUID();
guildRecord.guildName = guildRecord.guild.getName();
guildRecord.charterName = Enum.GuildCharterType.getGuildTypeFromInt(guildRecord.guild.getCharter()).getCharterName();
mbEnums.GuildCharterType guildCharterType = guild.charter;
guildRecord.charterName = guildCharterType.name;
guildRecord.GLHash = DataWarehouse.hasher.encrypt(guildRecord.guild.getGuildLeaderUUID());
+7 -7
View File
@@ -9,8 +9,8 @@
package engine.db.archive;
import engine.Enum;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.AbstractCharacter;
import engine.objects.Mine;
import engine.objects.PlayerCharacter;
@@ -23,7 +23,7 @@ import java.util.concurrent.LinkedBlockingQueue;
public class MineRecord extends DataRecord {
private static final LinkedBlockingQueue<MineRecord> recordPool = new LinkedBlockingQueue<>();
private Enum.RecordEventType eventType;
private mbEnums.RecordEventType eventType;
private String zoneHash;
private String charHash;
private String mineGuildHash;
@@ -33,12 +33,12 @@ public class MineRecord extends DataRecord {
private float locY;
private MineRecord() {
this.recordType = Enum.DataRecordType.MINE;
this.eventType = Enum.RecordEventType.CAPTURE;
this.recordType = mbEnums.DataRecordType.MINE;
this.eventType = mbEnums.RecordEventType.CAPTURE;
}
public static MineRecord borrow(Mine mine, AbstractCharacter character, Enum.RecordEventType eventType) {
public static MineRecord borrow(Mine mine, AbstractCharacter character, mbEnums.RecordEventType eventType) {
MineRecord mineRecord;
mineRecord = recordPool.poll();
@@ -48,13 +48,13 @@ public class MineRecord extends DataRecord {
mineRecord = new MineRecord();
mineRecord.eventType = eventType;
} else {
mineRecord.recordType = Enum.DataRecordType.MINE;
mineRecord.recordType = mbEnums.DataRecordType.MINE;
mineRecord.eventType = eventType;
}
mineRecord.zoneHash = mine.getParentZone().hash;
if (character.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)) {
if (character.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)) {
player = (PlayerCharacter) character;
mineRecord.charHash = player.getHash();
} else
+2 -2
View File
@@ -23,8 +23,8 @@ import java.time.LocalDateTime;
import java.util.LinkedList;
import java.util.concurrent.LinkedBlockingQueue;
import static engine.Enum.DataRecordType;
import static engine.Enum.PvpHistoryType;
import static engine.mbEnums.DataRecordType;
import static engine.mbEnums.PvpHistoryType;
public class PvpRecord extends DataRecord {
+8 -8
View File
@@ -9,8 +9,8 @@
package engine.db.archive;
import engine.Enum;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.Realm;
import engine.workthreads.WarehousePushThread;
@@ -23,20 +23,20 @@ public class RealmRecord extends DataRecord {
private static final LinkedBlockingQueue<RealmRecord> recordPool = new LinkedBlockingQueue<>();
private Realm realm;
private Enum.RecordEventType eventType;
private mbEnums.RecordEventType eventType;
private String cityHash;
private String guildHash;
private String charterType;
private LocalDateTime eventDateTime;
private RealmRecord(Realm realm) {
this.recordType = Enum.DataRecordType.REALM;
this.recordType = mbEnums.DataRecordType.REALM;
this.realm = realm;
this.eventType = Enum.RecordEventType.CAPTURE;
this.eventType = mbEnums.RecordEventType.CAPTURE;
}
public static RealmRecord borrow(Realm realm, Enum.RecordEventType eventType) {
public static RealmRecord borrow(Realm realm, mbEnums.RecordEventType eventType) {
RealmRecord realmRecord;
realmRecord = recordPool.poll();
@@ -45,7 +45,7 @@ public class RealmRecord extends DataRecord {
realmRecord = new RealmRecord(realm);
realmRecord.eventType = eventType;
} else {
realmRecord.recordType = Enum.DataRecordType.REALM;
realmRecord.recordType = mbEnums.DataRecordType.REALM;
realmRecord.eventType = eventType;
realmRecord.realm = realm;
@@ -53,9 +53,9 @@ public class RealmRecord extends DataRecord {
realmRecord.cityHash = realm.getRulingCity().getHash();
realmRecord.guildHash = realm.getRulingCity().getGuild().getHash();
realmRecord.charterType = Enum.CharterType.getCharterTypeByID(realmRecord.realm.getCharterType()).name();
realmRecord.charterType = mbEnums.CharterType.getCharterTypeByID(realmRecord.realm.getCharterType()).name();
if (realmRecord.eventType.equals(Enum.RecordEventType.CAPTURE))
if (realmRecord.eventType.equals(mbEnums.RecordEventType.CAPTURE))
realmRecord.eventDateTime = realm.ruledSince;
else
realmRecord.eventDateTime = LocalDateTime.now();
+4 -4
View File
@@ -9,10 +9,10 @@
package engine.db.handlers;
import engine.Enum;
import engine.Enum.GameObjectType;
import engine.gameManager.ConfigManager;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.mbEnums.GameObjectType;
import engine.objects.Account;
import engine.objects.PlayerCharacter;
import org.pmw.tinylog.Logger;
@@ -27,7 +27,7 @@ public class dbAccountHandler extends dbHandlerBase {
public dbAccountHandler() {
this.localClass = Account.class;
this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public Account GET_ACCOUNT(int accountID) {
@@ -204,7 +204,7 @@ public class dbAccountHandler extends dbHandlerBase {
if (account != null) {
account.runAfterLoad();
if (ConfigManager.serverType.equals(Enum.ServerType.LOGINSERVER))
if (ConfigManager.serverType.equals(mbEnums.ServerType.LOGINSERVER))
Account.AccountsMap.put(uname, account.getObjectUUID());
}
@@ -9,9 +9,9 @@
package engine.db.handlers;
import engine.Enum;
import engine.Enum.GameObjectType;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.mbEnums.GameObjectType;
import engine.objects.BaseClass;
import org.pmw.tinylog.Logger;
@@ -25,7 +25,7 @@ public class dbBaseClassHandler extends dbHandlerBase {
public dbBaseClassHandler() {
this.localClass = BaseClass.class;
this.localObjectType = Enum.GameObjectType.BaseClass;
this.localObjectType = mbEnums.GameObjectType.BaseClass;
}
public BaseClass GET_BASE_CLASS(final int id) {
@@ -9,13 +9,13 @@
package engine.db.handlers;
import engine.Enum;
import engine.Enum.DbObjectType;
import engine.Enum.ProtectionState;
import engine.Enum.TaxType;
import engine.gameManager.BuildingManager;
import engine.gameManager.DbManager;
import engine.math.Vector3fImmutable;
import engine.mbEnums;
import engine.mbEnums.DbObjectType;
import engine.mbEnums.ProtectionState;
import engine.mbEnums.TaxType;
import engine.objects.*;
import org.joda.time.DateTime;
import org.pmw.tinylog.Logger;
@@ -34,7 +34,7 @@ public class dbBuildingHandler extends dbHandlerBase {
public dbBuildingHandler() {
this.localClass = Building.class;
this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public Building CREATE_BUILDING(int parentZoneID, int OwnerUUID, String name, int meshUUID,
@@ -112,7 +112,7 @@ public class dbBuildingHandler extends dbHandlerBase {
if (uuid == 0)
return null;
Building building = (Building) DbManager.getFromCache(Enum.GameObjectType.Building, uuid);
Building building = (Building) DbManager.getFromCache(mbEnums.GameObjectType.Building, uuid);
if (building != null)
return building;
@@ -10,6 +10,7 @@
package engine.db.handlers;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.BuildingLocation;
import org.pmw.tinylog.Logger;
@@ -23,7 +24,7 @@ public class dbBuildingLocationHandler extends dbHandlerBase {
public dbBuildingLocationHandler() {
this.localClass = BuildingLocation.class;
this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public ArrayList<BuildingLocation> LOAD_BUILDING_LOCATIONS() {
@@ -10,6 +10,7 @@
package engine.db.handlers;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.Account;
import engine.objects.PlayerCharacter;
import engine.session.CSSession;
@@ -26,7 +27,7 @@ public class dbCSSessionHandler extends dbHandlerBase {
public dbCSSessionHandler() {
this.localClass = CSSession.class;
this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public boolean ADD_CSSESSION(String secKey, Account acc, InetAddress inet, String machineID) {
@@ -9,8 +9,8 @@
package engine.db.handlers;
import engine.Enum;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.CharacterPower;
import engine.objects.PlayerCharacter;
import engine.server.MBServerStatics;
@@ -23,7 +23,7 @@ public class dbCharacterPowerHandler extends dbHandlerBase {
public dbCharacterPowerHandler() {
this.localClass = CharacterPower.class;
this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public CharacterPower ADD_CHARACTER_POWER(CharacterPower toAdd) {
@@ -74,7 +74,7 @@ public class dbCharacterPowerHandler extends dbHandlerBase {
public CharacterPower GET_CHARACTER_POWER(int objectUUID) {
CharacterPower characterPower = (CharacterPower) DbManager.getFromCache(Enum.GameObjectType.CharacterPower, objectUUID);
CharacterPower characterPower = (CharacterPower) DbManager.getFromCache(mbEnums.GameObjectType.CharacterPower, objectUUID);
if (characterPower != null)
return characterPower;
@@ -9,8 +9,8 @@
package engine.db.handlers;
import engine.Enum;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.CharacterRune;
import org.pmw.tinylog.Logger;
@@ -21,7 +21,7 @@ public class dbCharacterRuneHandler extends dbHandlerBase {
public dbCharacterRuneHandler() {
this.localClass = CharacterRune.class;
this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public CharacterRune ADD_CHARACTER_RUNE(final CharacterRune toAdd) {
@@ -49,7 +49,7 @@ public class dbCharacterRuneHandler extends dbHandlerBase {
public CharacterRune GET_CHARACTER_RUNE(int runeID) {
CharacterRune characterRune = (CharacterRune) DbManager.getFromCache(Enum.GameObjectType.CharacterRune, runeID);
CharacterRune characterRune = (CharacterRune) DbManager.getFromCache(mbEnums.GameObjectType.CharacterRune, runeID);
if (characterRune != null)
return characterRune;
@@ -9,8 +9,8 @@
package engine.db.handlers;
import engine.Enum;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.AbstractCharacter;
import engine.objects.CharacterSkill;
import engine.objects.PlayerCharacter;
@@ -24,7 +24,7 @@ public class dbCharacterSkillHandler extends dbHandlerBase {
public dbCharacterSkillHandler() {
this.localClass = CharacterSkill.class;
this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public CharacterSkill ADD_SKILL(CharacterSkill toAdd) {
@@ -72,7 +72,7 @@ public class dbCharacterSkillHandler extends dbHandlerBase {
public CharacterSkill GET_SKILL(final int objectUUID) {
CharacterSkill characterSkill = (CharacterSkill) DbManager.getFromCache(Enum.GameObjectType.CharacterSkill, objectUUID);
CharacterSkill characterSkill = (CharacterSkill) DbManager.getFromCache(mbEnums.GameObjectType.CharacterSkill, objectUUID);
if (characterSkill != null)
return characterSkill;
@@ -95,7 +95,7 @@ public class dbCharacterSkillHandler extends dbHandlerBase {
ConcurrentHashMap<String, CharacterSkill> characterSkills = new ConcurrentHashMap<>(MBServerStatics.CHM_INIT_CAP, MBServerStatics.CHM_LOAD, MBServerStatics.CHM_THREAD_LOW);
if (ac == null || (!(ac.getObjectType().equals(Enum.GameObjectType.PlayerCharacter))))
if (ac == null || (!(ac.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter))))
return characterSkills;
PlayerCharacter playerCharacter = (PlayerCharacter) ac;
+13 -14
View File
@@ -9,8 +9,8 @@
package engine.db.handlers;
import engine.Enum;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.AbstractGameObject;
import engine.objects.Building;
import engine.objects.City;
@@ -25,7 +25,7 @@ public class dbCityHandler extends dbHandlerBase {
public dbCityHandler() {
this.localClass = City.class;
this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public static void addObject(ArrayList<AbstractGameObject> list, ResultSet rs) throws SQLException {
@@ -52,25 +52,24 @@ public class dbCityHandler extends dbHandlerBase {
}
}
public ArrayList<AbstractGameObject> CREATE_CITY(int ownerID, int parentZoneID, int realmID, float xCoord, float yCoord, float zCoord, float rotation, float W, String name, LocalDateTime established) {
public ArrayList<AbstractGameObject> CREATE_CITY(int ownerID, int parentZoneID, float xCoord, float yCoord, float zCoord, float rotation, float W, String name, LocalDateTime established) {
LocalDateTime upgradeTime = LocalDateTime.now().plusHours(2);
ArrayList<AbstractGameObject> objectList = new ArrayList<>();
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("CALL `city_CREATE`(?, ?, ?, ?, ?, ?, ?, ?, ?,?,?)")) {
PreparedStatement preparedStatement = connection.prepareStatement("CALL `city_CREATE`(?, ?, ?, ?, ?, ?, ?, ?,?,?)")) {
preparedStatement.setLong(1, ownerID); //objectUUID of owning player
preparedStatement.setLong(2, parentZoneID); //objectUUID of parent (continent) zone
preparedStatement.setLong(3, realmID); //objectUUID of realm city belongs in
preparedStatement.setFloat(4, xCoord); //xOffset from parentZone center
preparedStatement.setFloat(5, yCoord); //yOffset from parentZone center
preparedStatement.setFloat(6, zCoord); //zOffset from parentZone center
preparedStatement.setString(7, name); //city name
preparedStatement.setTimestamp(8, Timestamp.valueOf(established));
preparedStatement.setFloat(9, rotation);
preparedStatement.setFloat(10, W);
preparedStatement.setTimestamp(11, Timestamp.valueOf(upgradeTime));
preparedStatement.setFloat(3, xCoord); //xOffset from parentZone center
preparedStatement.setFloat(4, yCoord); //yOffset from parentZone center
preparedStatement.setFloat(5, zCoord); //zOffset from parentZone center
preparedStatement.setString(6, name); //city name
preparedStatement.setTimestamp(7, Timestamp.valueOf(established));
preparedStatement.setFloat(8, rotation);
preparedStatement.setFloat(9, W);
preparedStatement.setTimestamp(10, Timestamp.valueOf(upgradeTime));
boolean work = preparedStatement.execute();
@@ -118,7 +117,7 @@ public class dbCityHandler extends dbHandlerBase {
public City GET_CITY(final int cityId) {
City city = (City) DbManager.getFromCache(Enum.GameObjectType.City, cityId);
City city = (City) DbManager.getFromCache(mbEnums.GameObjectType.City, cityId);
if (city != null)
return city;
+10 -10
View File
@@ -9,11 +9,11 @@
package engine.db.handlers;
import engine.Enum;
import engine.gameManager.DbManager;
import engine.gameManager.ItemManager;
import engine.mbEnums;
import engine.objects.Contract;
import engine.objects.Item;
import engine.objects.MobLoot;
import org.pmw.tinylog.Logger;
import java.sql.Connection;
@@ -25,12 +25,12 @@ public class dbContractHandler extends dbHandlerBase {
public dbContractHandler() {
this.localClass = Contract.class;
this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public Contract GET_CONTRACT(final int objectUUID) {
Contract contract = (Contract) DbManager.getFromCache(Enum.GameObjectType.Contract, objectUUID);
Contract contract = (Contract) DbManager.getFromCache(mbEnums.GameObjectType.Contract, objectUUID);
if (contract != null)
return contract;
@@ -66,7 +66,7 @@ public class dbContractHandler extends dbHandlerBase {
int templateID = rs.getInt("templateID");
Item item = new Item(templateID);
item.objectUUID = MobLoot.lastNegativeID.decrementAndGet();
item.objectUUID = ItemManager.lastNegativeID.decrementAndGet();
contract.getSellInventory().add(item);
}
@@ -106,12 +106,12 @@ public class dbContractHandler extends dbHandlerBase {
}
}
public boolean updateAllowedBuildings(final Contract con, final long slotbitvalue) {
public boolean updateAllowedBuildings(final Contract con) {
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `static_npc_contract` SET `allowedBuildingTypeID`=? WHERE `contractID`=?")) {
PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `static_npc_contract` SET `slotInBuildings`=? WHERE `contractID`=?")) {
preparedStatement.setLong(1, slotbitvalue);
preparedStatement.setString(1, mbEnums.asString(con.allowedBuildings));
preparedStatement.setInt(2, con.getContractID());
return (preparedStatement.executeUpdate() > 0);
@@ -126,7 +126,7 @@ public class dbContractHandler extends dbHandlerBase {
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `static_npc_contract` SET `contractID`=?, `name`=?, "
+ "`mobbaseID`=?, `classID`=?, vendorDialog=?, iconID=?, allowedBuildingTypeID=? WHERE `ID`=?")) {
+ "`mobbaseID`=?, `classID`=?, vendorDialog=?, iconID=?, slotInBuildings=? WHERE `ID`=?")) {
preparedStatement.setInt(1, con.getContractID());
preparedStatement.setString(2, con.getName());
@@ -135,7 +135,7 @@ public class dbContractHandler extends dbHandlerBase {
preparedStatement.setInt(5, (con.getVendorDialog() != null) ? con.getVendorDialog().getObjectUUID() : 0);
preparedStatement.setInt(6, con.getIconID());
preparedStatement.setInt(8, con.getObjectUUID());
preparedStatement.setLong(7, con.getAllowedBuildings().toLong());
preparedStatement.setString(7, mbEnums.asString(con.allowedBuildings));
return (preparedStatement.executeUpdate() > 0);
@@ -9,9 +9,9 @@
package engine.db.handlers;
import engine.Enum;
import engine.gameManager.DbManager;
import engine.gameManager.PowersManager;
import engine.mbEnums;
import engine.powers.EffectsBase;
import engine.powers.effectmodifiers.*;
import org.pmw.tinylog.Logger;
@@ -63,7 +63,7 @@ public class dbEffectsBaseHandler extends dbHandlerBase {
IDString = rs.getString("IDString");
EffectsBase effectBase = PowersManager.getEffectByIDString(IDString);
Enum.ModType modifier = Enum.ModType.GetModType(rs.getString("modType"));
mbEnums.ModType modifier = mbEnums.ModType.GetModType(rs.getString("modType"));
//combine item prefix and suffix effect modifiers
@@ -86,7 +86,7 @@ public class dbEffectsBaseHandler extends dbHandlerBase {
}
private static AbstractEffectModifier getCombinedModifiers(AbstractEffectModifier abstractEffectModifier, ResultSet rs, EffectsBase effectBase, Enum.ModType modifier) throws SQLException {
private static AbstractEffectModifier getCombinedModifiers(AbstractEffectModifier abstractEffectModifier, ResultSet rs, EffectsBase effectBase, mbEnums.ModType modifier) throws SQLException {
switch (modifier) {
case AdjustAboveDmgCap:
abstractEffectModifier = new AdjustAboveDmgCapEffectModifier(rs);
@@ -10,38 +10,49 @@
package engine.db.handlers;
import engine.gameManager.DbManager;
import engine.gameManager.PowersManager;
import engine.mbEnums;
import engine.objects.EffectsResourceCosts;
import org.json.JSONObject;
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;
public class dbEffectsResourceCostHandler extends dbHandlerBase {
public dbEffectsResourceCostHandler() {
this.localClass = EffectsResourceCosts.class;
this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public ArrayList<EffectsResourceCosts> GET_ALL_EFFECT_RESOURCES(String idString) {
ArrayList<EffectsResourceCosts> effectsResourceCosts = new ArrayList<>();
public void LOAD_ALL_COSTMAPS() {
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_power_effectcost` WHERE `IDString` = ?")) {
preparedStatement.setString(1, idString);
PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_effect_costmaps`")) {
ResultSet rs = preparedStatement.executeQuery();
effectsResourceCosts = getObjectsFromRs(rs, 1000);
while (rs.next()) {
String effectID = rs.getString("effectID");
String costString = rs.getString("costmap");
JSONObject costJSON = new JSONObject(costString);
HashMap<mbEnums.ResourceType, Integer> costmap = new HashMap<>();
for (String key : costJSON.keySet()) {
int value = costJSON.getInt(key);
costmap.put(mbEnums.ResourceType.valueOf(key), value);
}
PowersManager._effect_costMaps.put(effectID, costmap);
}
} catch (SQLException e) {
Logger.error(e);
}
return effectsResourceCosts;
}
}
+6 -6
View File
@@ -9,9 +9,9 @@
package engine.db.handlers;
import engine.Enum;
import engine.Enum.GuildHistoryType;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.mbEnums.GuildHistoryType;
import engine.objects.*;
import engine.server.world.WorldServer;
import org.joda.time.DateTime;
@@ -24,7 +24,7 @@ public class dbGuildHandler extends dbHandlerBase {
public dbGuildHandler() {
this.localClass = Guild.class;
this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public static ArrayList<PlayerCharacter> GET_GUILD_BANISHED(final int id) {
@@ -276,7 +276,7 @@ public class dbGuildHandler extends dbHandlerBase {
public Guild GET_GUILD(int id) {
Guild guild = (Guild) DbManager.getFromCache(Enum.GameObjectType.Guild, id);
Guild guild = (Guild) DbManager.getFromCache(mbEnums.GameObjectType.Guild, id);
if (guild != null)
return guild;
@@ -427,7 +427,7 @@ public class dbGuildHandler extends dbHandlerBase {
preparedStatement.setInt(6, guildTag.symbolColor);
preparedStatement.setInt(7, guildTag.backgroundDesign);
preparedStatement.setInt(8, guildTag.symbol);
preparedStatement.setInt(9, g.getCharter());
preparedStatement.setInt(9, g.charter.templateID);
preparedStatement.setString(10, g.getLeadershipType());
preparedStatement.setString(11, g.getMotto());
@@ -573,7 +573,7 @@ public class dbGuildHandler extends dbHandlerBase {
preparedStatement.setInt(4, g.getGuildTag().symbolColor);
preparedStatement.setInt(5, g.getGuildTag().backgroundDesign);
preparedStatement.setInt(6, g.getGuildTag().symbol);
preparedStatement.setInt(7, g.getCharter());
preparedStatement.setInt(7, g.charter.templateID);
preparedStatement.setString(8, g.getMOTD());
preparedStatement.setString(9, g.getICMOTD());
preparedStatement.setString(10, "");
+3 -3
View File
@@ -9,10 +9,10 @@
package engine.db.handlers;
import engine.Enum;
import engine.Enum.GameObjectType;
import engine.gameManager.ConfigManager;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.mbEnums.GameObjectType;
import engine.objects.AbstractGameObject;
import engine.objects.AbstractWorldObject;
import org.pmw.tinylog.Logger;
@@ -42,7 +42,7 @@ public abstract class dbHandlerBase {
// Only call runAfterLoad() for objects instanced on the world server
if ((abstractGameObject != null && abstractGameObject instanceof AbstractWorldObject) &&
(ConfigManager.serverType.equals(Enum.ServerType.WORLDSERVER) ||
(ConfigManager.serverType.equals(mbEnums.ServerType.WORLDSERVER) ||
(abstractGameObject.getObjectType() == GameObjectType.Guild)))
((AbstractWorldObject) abstractGameObject).runAfterLoad();
+19 -15
View File
@@ -9,16 +9,15 @@
package engine.db.handlers;
import engine.Enum;
import engine.Enum.ItemContainerType;
import engine.Enum.ItemType;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.mbEnums.ItemContainerType;
import engine.mbEnums.ItemType;
import engine.objects.AbstractCharacter;
import engine.objects.CharacterItemManager;
import engine.objects.Item;
import engine.objects.ItemTemplate;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.JSONObject;
import org.pmw.tinylog.Logger;
import java.sql.Connection;
@@ -26,6 +25,7 @@ import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
@@ -33,7 +33,7 @@ public class dbItemHandler extends dbHandlerBase {
public dbItemHandler() {
this.localClass = Item.class;
this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
private static String formatTradeString(HashSet<Integer> list) {
@@ -92,14 +92,14 @@ public class dbItemHandler extends dbHandlerBase {
break;
}
if (toAdd.equipSlot.equals(Enum.EquipSlotType.NONE))
if (toAdd.equipSlot.equals(mbEnums.EquipSlotType.NONE))
preparedStatement.setString(7, "");
else
preparedStatement.setString(7, toAdd.equipSlot.name());
String flagString = "";
for (Enum.ItemFlags itemflag : toAdd.flags)
for (mbEnums.ItemFlags itemflag : toAdd.flags)
flagString += itemflag.toString() + ";";
flagString = flagString.replaceAll(";$", "");
@@ -179,7 +179,7 @@ public class dbItemHandler extends dbHandlerBase {
public void LOAD_ITEM_TEMPLATES() {
JSONParser jsonParser = new JSONParser();
HashMap<ItemType, Integer> templateTCountMap = new HashMap<>();
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_item_templates`;");
@@ -187,12 +187,15 @@ public class dbItemHandler extends dbHandlerBase {
while (rs.next()) {
int templateID = rs.getInt("id");
JSONObject jsonObject = (JSONObject) jsonParser.parse(rs.getString("template"));
JSONObject jsonObject = new JSONObject(rs.getString("template"));
ItemTemplate itemTemplate = new ItemTemplate(jsonObject);
itemTemplate.template_id = templateID;
ItemTemplate.templates.put(templateID, itemTemplate);
templateTCountMap.merge(itemTemplate.item_type, 1, Integer::sum);
}
Logger.info(templateTCountMap.toString());
} catch (Exception e) {
Logger.error(e);
}
@@ -216,6 +219,7 @@ public class dbItemHandler extends dbHandlerBase {
}
}
public Item GET_ITEM(final int itemUUID) {
Item item;
@@ -365,7 +369,7 @@ public class dbItemHandler extends dbHandlerBase {
//Used to transfer a single item between owners or equip or vault or bank or inventory
public boolean UPDATE_OWNER(final Item item, int newOwnerID,
ItemContainerType containerType, Enum.EquipSlotType slot) {
ItemContainerType containerType, mbEnums.EquipSlotType slot) {
boolean worked = false;
@@ -400,7 +404,7 @@ public class dbItemHandler extends dbHandlerBase {
break;
}
if (slot.equals(Enum.EquipSlotType.NONE))
if (slot.equals(mbEnums.EquipSlotType.NONE))
preparedStatement.setString(4, "");
else
preparedStatement.setString(4, slot.name());
@@ -530,7 +534,7 @@ public class dbItemHandler extends dbHandlerBase {
String flagString = "";
for (Enum.ItemFlags itemflag : item.flags)
for (mbEnums.ItemFlags itemflag : item.flags)
flagString += itemflag.toString() + ";";
flagString = flagString.replaceAll(";$", "");
@@ -550,7 +554,7 @@ public class dbItemHandler extends dbHandlerBase {
// Write 0 if we will not modify the value from template
if (item.value == item.template.item_value)
if (value == item.template.item_value)
value = 0;
try (Connection connection = DbManager.getConnection();
@@ -572,7 +576,7 @@ public class dbItemHandler extends dbHandlerBase {
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_item` SET `equipSlot`=? WHERE `UID` = ?")) {
if (item.equipSlot.equals(Enum.EquipSlotType.NONE))
if (item.equipSlot.equals(mbEnums.EquipSlotType.NONE))
preparedStatement.setString(1, "");
else
preparedStatement.setString(1, item.equipSlot.name());
+2 -1
View File
@@ -10,6 +10,7 @@
package engine.db.handlers;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.Kit;
import org.pmw.tinylog.Logger;
@@ -23,7 +24,7 @@ public class dbKitHandler extends dbHandlerBase {
public dbKitHandler() {
this.localClass = Kit.class;
this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public ArrayList<Kit> GET_ALL_KITS() {
+2 -1
View File
@@ -10,6 +10,7 @@
package engine.db.handlers;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.MenuOption;
import org.pmw.tinylog.Logger;
@@ -23,7 +24,7 @@ public class dbMenuHandler extends dbHandlerBase {
public dbMenuHandler() {
this.localClass = MenuOption.class;
this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public ArrayList<MenuOption> GET_MENU_OPTIONS(final int id) {
+4 -4
View File
@@ -8,8 +8,8 @@
package engine.db.handlers;
import engine.Enum;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.Mine;
import engine.objects.MineProduction;
import org.pmw.tinylog.Logger;
@@ -24,7 +24,7 @@ public class dbMineHandler extends dbHandlerBase {
public dbMineHandler() {
this.localClass = Mine.class;
this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public Mine GET_MINE(int id) {
@@ -32,7 +32,7 @@ public class dbMineHandler extends dbHandlerBase {
if (id == 0)
return null;
Mine mine = (Mine) DbManager.getFromCache(Enum.GameObjectType.Mine, id);
Mine mine = (Mine) DbManager.getFromCache(mbEnums.GameObjectType.Mine, id);
if (mine != null)
return mine;
@@ -83,7 +83,7 @@ public class dbMineHandler extends dbHandlerBase {
return false;
}
public boolean CHANGE_RESOURCE(Mine mine, Enum.ResourceType resource) {
public boolean CHANGE_RESOURCE(Mine mine, mbEnums.ResourceType resource) {
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_mine` SET `mine_resource`=? WHERE `UID`=?")) {
+3 -2
View File
@@ -9,8 +9,9 @@
package engine.db.handlers;
import engine.Enum.GameObjectType;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.mbEnums.GameObjectType;
import engine.objects.MobBase;
import engine.objects.MobBaseEffects;
import engine.objects.MobBaseStats;
@@ -26,7 +27,7 @@ public class dbMobBaseHandler extends dbHandlerBase {
public dbMobBaseHandler() {
this.localClass = MobBase.class;
this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public MobBase GET_MOBBASE(int id) {
+2 -1
View File
@@ -10,6 +10,7 @@
package engine.db.handlers;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.Mob;
import org.joda.time.DateTime;
import org.pmw.tinylog.Logger;
@@ -24,7 +25,7 @@ public class dbMobHandler extends dbHandlerBase {
public dbMobHandler() {
this.localClass = Mob.class;
this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public Mob PERSIST(Mob toAdd) {
+19 -114
View File
@@ -9,12 +9,12 @@
package engine.db.handlers;
import engine.Enum.ProfitType;
import engine.gameManager.DbManager;
import engine.math.Vector3fImmutable;
import engine.mbEnums;
import engine.mbEnums.ProfitType;
import engine.objects.NPC;
import engine.objects.NPCProfits;
import engine.objects.ProducedItem;
import org.joda.time.DateTime;
import org.pmw.tinylog.Logger;
@@ -29,7 +29,7 @@ public class dbNPCHandler extends dbHandlerBase {
public dbNPCHandler() {
this.localClass = NPC.class;
this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public static HashMap<Integer, ArrayList<Integer>> LOAD_RUNES_FOR_NPC_AND_MOBS() {
@@ -310,6 +310,22 @@ public class dbNPCHandler extends dbHandlerBase {
}
}
public boolean UPDATE_RACE(NPC npc, int value) {
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `obj_npc` SET `npc_raceID`=? WHERE `UID`=?")) {
preparedStatement.setInt(1, value);
preparedStatement.setLong(2, npc.getObjectUUID());
return (preparedStatement.executeUpdate() > 0);
} catch (SQLException e) {
Logger.error(e);
return false;
}
}
public void LOAD_PIRATE_NAMES() {
String pirateName;
@@ -345,117 +361,6 @@ public class dbNPCHandler extends dbHandlerBase {
+ NPC._pirateNames.size() + " mobBases");
}
public boolean ADD_TO_PRODUCTION_LIST(final long ID, final long npcUID, final long templateID, DateTime dateTime, String prefix, String suffix, String name, boolean isRandom, int playerID) {
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO `dyn_npc_production` (`ID`,`npcUID`, `templateID`,`dateToUpgrade`, `isRandom`, `prefix`, `suffix`, `name`,`playerID`) VALUES (?,?,?,?,?,?,?,?,?)")) {
preparedStatement.setLong(1, ID);
preparedStatement.setLong(2, npcUID);
preparedStatement.setLong(3, templateID);
preparedStatement.setTimestamp(4, new java.sql.Timestamp(dateTime.getMillis()));
preparedStatement.setBoolean(5, isRandom);
preparedStatement.setString(6, prefix);
preparedStatement.setString(7, suffix);
preparedStatement.setString(8, name);
preparedStatement.setInt(9, playerID);
return (preparedStatement.executeUpdate() > 0);
} catch (SQLException e) {
Logger.error(e);
return false;
}
}
public boolean REMOVE_FROM_PRODUCTION_LIST(final long ID, final long npcUID) {
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("DELETE FROM `dyn_npc_production` WHERE `ID`=? AND `npcUID`=?;")) {
preparedStatement.setLong(1, ID);
preparedStatement.setLong(2, npcUID);
return (preparedStatement.executeUpdate() > 0);
} catch (SQLException e) {
Logger.error(e);
return false;
}
}
public boolean UPDATE_ITEM_TO_INVENTORY(final long ID, final long npcUID) {
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `dyn_npc_production` SET `inForge`=? WHERE `ID`=? AND `npcUID`=?;")) {
preparedStatement.setByte(1, (byte) 0);
preparedStatement.setLong(2, ID);
preparedStatement.setLong(3, npcUID);
return (preparedStatement.executeUpdate() > 0);
} catch (SQLException e) {
Logger.error(e);
return false;
}
}
public boolean UPDATE_ITEM_PRICE(final long ID, final long npcUID, int value) {
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `dyn_npc_production` SET `value`=? WHERE `ID`=? AND `npcUID`=?;")) {
preparedStatement.setInt(1, value);
preparedStatement.setLong(2, ID);
preparedStatement.setLong(3, npcUID);
return (preparedStatement.executeUpdate() > 0);
} catch (SQLException e) {
Logger.error(e);
return false;
}
}
public boolean UPDATE_ITEM_ID(final long ID, final long npcUID, final long value) {
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("UPDATE `dyn_npc_production` SET `ID`=? WHERE `ID`=? AND `npcUID`=? LIMIT 1;")) {
preparedStatement.setLong(1, value);
preparedStatement.setLong(2, ID);
preparedStatement.setLong(3, npcUID);
return (preparedStatement.executeUpdate() > 0);
} catch (SQLException e) {
Logger.error(e);
return false;
}
}
public void LOAD_ALL_ITEMS_TO_PRODUCE(NPC npc) {
if (npc == null)
return;
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `dyn_npc_production` WHERE `npcUID` = ?")) {
preparedStatement.setInt(1, npc.getObjectUUID());
ResultSet rs = preparedStatement.executeQuery();
while (rs.next()) {
ProducedItem producedItem = new ProducedItem(rs);
npc.forgedItems.add(producedItem);
}
} catch (SQLException e) {
Logger.error(e);
}
}
public boolean UPDATE_PROFITS(NPC npc, ProfitType profitType, float value) {
try (Connection connection = DbManager.getConnection();
@@ -9,8 +9,8 @@
package engine.db.handlers;
import engine.Enum;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.Petition;
import org.pmw.tinylog.Logger;
@@ -58,8 +58,8 @@ public class dbPetitionHandler extends dbHandlerBase {
" VALUES (?,?,?,?,?,?,?,?,?);")) {
preparedStatement.setTimestamp(1, new java.sql.Timestamp(System.currentTimeMillis()));
preparedStatement.setString(2, Enum.PetitionType.values()[petition.primaryType].name());
preparedStatement.setString(3, Enum.PetitionSubType.values()[petition.subType].name());
preparedStatement.setString(2, mbEnums.PetitionType.values()[petition.primaryType].name());
preparedStatement.setString(3, mbEnums.PetitionSubType.values()[petition.subType].name());
preparedStatement.setInt(4, petition.reportAccount.getObjectUUID());
preparedStatement.setString(5, petition.reportAccount.getUname());
preparedStatement.setInt(6, petition.reportPlayer.getObjectUUID());
@@ -9,9 +9,12 @@
package engine.db.handlers;
import engine.Enum;
import engine.gameManager.DbManager;
import engine.objects.*;
import engine.mbEnums;
import engine.objects.AbstractWorldObject;
import engine.objects.Heraldry;
import engine.objects.PlayerCharacter;
import engine.objects.PlayerFriends;
import engine.server.MBServerStatics;
import org.pmw.tinylog.Logger;
@@ -26,7 +29,7 @@ public class dbPlayerCharacterHandler extends dbHandlerBase {
public dbPlayerCharacterHandler() {
this.localClass = PlayerCharacter.class;
this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public PlayerCharacter ADD_PLAYER_CHARACTER(final PlayerCharacter toAdd) {
@@ -173,7 +176,7 @@ public class dbPlayerCharacterHandler extends dbHandlerBase {
if (objectUUID == 0)
return null;
PlayerCharacter playerCharacter = (PlayerCharacter) DbManager.getFromCache(Enum.GameObjectType.PlayerCharacter, objectUUID);
PlayerCharacter playerCharacter = (PlayerCharacter) DbManager.getFromCache(mbEnums.GameObjectType.PlayerCharacter, objectUUID);
if (playerCharacter != null)
return playerCharacter;
+3 -3
View File
@@ -9,9 +9,9 @@
package engine.db.handlers;
import engine.Enum;
import engine.gameManager.DbManager;
import engine.gameManager.PowersManager;
import engine.mbEnums;
import engine.objects.Mob;
import engine.powers.EffectsBase;
import org.pmw.tinylog.Logger;
@@ -25,7 +25,7 @@ public class dbPowerHandler extends dbHandlerBase {
public dbPowerHandler() {
this.localClass = Mob.class;
this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public static void addAllSourceTypes() {
@@ -41,7 +41,7 @@ public class dbPowerHandler extends dbHandlerBase {
int token = DbManager.hasher.SBStringHash(IDString);
source = rs.getString("source").replace("-", "").trim();
Enum.EffectSourceType effectSourceType = Enum.EffectSourceType.GetEffectSourceType(source);
mbEnums.EffectSourceType effectSourceType = mbEnums.EffectSourceType.GetEffectSourceType(source);
if (EffectsBase.effectSourceTypeMap.containsKey(token) == false)
EffectsBase.effectSourceTypeMap.put(token, new HashSet<>());
@@ -10,6 +10,7 @@
package engine.db.handlers;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.PromotionClass;
import org.pmw.tinylog.Logger;
@@ -23,7 +24,7 @@ public class dbPromotionClassHandler extends dbHandlerBase {
public dbPromotionClassHandler() {
this.localClass = PromotionClass.class;
this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public ArrayList<Integer> GET_ALLOWED_RUNES(final PromotionClass pc) {
@@ -10,6 +10,7 @@
package engine.db.handlers;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.RuneBaseAttribute;
import org.pmw.tinylog.Logger;
@@ -23,7 +24,7 @@ public class dbRuneBaseAttributeHandler extends dbHandlerBase {
public dbRuneBaseAttributeHandler() {
this.localClass = RuneBaseAttribute.class;
this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public ArrayList<RuneBaseAttribute> GET_ATTRIBUTES_FOR_RUNEBASE() {
@@ -9,8 +9,9 @@
package engine.db.handlers;
import engine.Enum.GameObjectType;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.mbEnums.GameObjectType;
import engine.objects.AbstractGameObject;
import engine.objects.RuneBaseEffect;
import org.pmw.tinylog.Logger;
@@ -26,7 +27,7 @@ public class dbRuneBaseEffectHandler extends dbHandlerBase {
public dbRuneBaseEffectHandler() {
this.localClass = RuneBaseEffect.class;
this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public ArrayList<RuneBaseEffect> GET_EFFECTS_FOR_RUNEBASE(int id) {
@@ -10,6 +10,7 @@
package engine.db.handlers;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.RuneBase;
import engine.powers.RunePowerEntry;
import engine.powers.RuneSkillAdjustEntry;
@@ -26,7 +27,7 @@ public class dbRuneBaseHandler extends dbHandlerBase {
public dbRuneBaseHandler() {
this.localClass = RuneBase.class;
this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public static HashMap<Integer, ArrayList<RunePowerEntry>> LOAD_RUNE_POWERS() {
@@ -9,8 +9,8 @@
package engine.db.handlers;
import engine.Enum;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.Building;
import engine.objects.Portal;
import org.pmw.tinylog.Logger;
@@ -49,7 +49,7 @@ public class dbRunegateHandler extends dbHandlerBase {
public ArrayList<Portal> GET_PORTAL_LIST(int gateUID) {
ArrayList<Portal> portalList = new ArrayList<>();
Building sourceBuilding = (Building) DbManager.getObject(Enum.GameObjectType.Building, gateUID);
Building sourceBuilding = (Building) DbManager.getObject(mbEnums.GameObjectType.Building, gateUID);
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `static_runegate_portals` WHERE `sourceBuilding` = ?;")) {
@@ -60,8 +60,8 @@ public class dbRunegateHandler extends dbHandlerBase {
while (rs.next()) {
int targetBuildingID = rs.getInt("targetBuilding");
Building targetBuilding = (Building) DbManager.getObject(Enum.GameObjectType.Building, targetBuildingID);
Enum.PortalType portalType = Enum.PortalType.valueOf(rs.getString("portalType"));
Building targetBuilding = (Building) DbManager.getObject(mbEnums.GameObjectType.Building, targetBuildingID);
mbEnums.PortalType portalType = mbEnums.PortalType.valueOf(rs.getString("portalType"));
Portal portal = new Portal(sourceBuilding, portalType, targetBuilding);
portalList.add(portal);
}
+3 -2
View File
@@ -9,9 +9,10 @@
package engine.db.handlers;
import engine.Enum.ProtectionState;
import engine.gameManager.DbManager;
import engine.math.Vector3fImmutable;
import engine.mbEnums;
import engine.mbEnums.ProtectionState;
import engine.objects.AbstractGameObject;
import engine.objects.Building;
import engine.objects.Shrine;
@@ -28,7 +29,7 @@ public class dbShrineHandler extends dbHandlerBase {
public dbShrineHandler() {
this.localClass = Shrine.class;
this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public static void addObject(ArrayList<AbstractGameObject> list, ResultSet rs) throws SQLException {
@@ -9,9 +9,9 @@
package engine.db.handlers;
import engine.Enum;
import engine.Enum.GameObjectType;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.mbEnums.GameObjectType;
import engine.objects.MaxSkills;
import engine.objects.SkillsBase;
import org.pmw.tinylog.Logger;
@@ -27,7 +27,7 @@ public class dbSkillBaseHandler extends dbHandlerBase {
public dbSkillBaseHandler() {
this.localClass = SkillsBase.class;
this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public SkillsBase GET_BASE(final int objectUUID) {
@@ -10,6 +10,7 @@
package engine.db.handlers;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.SkillReq;
import engine.powers.PowersBase;
import org.pmw.tinylog.Logger;
@@ -25,7 +26,7 @@ public class dbSkillReqHandler extends dbHandlerBase {
public dbSkillReqHandler() {
this.localClass = SkillReq.class;
this.localObjectType = engine.Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public static ArrayList<PowersBase> getAllPowersBase() {
@@ -9,8 +9,8 @@
package engine.db.handlers;
import engine.Enum;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.VendorDialog;
import org.pmw.tinylog.Logger;
@@ -23,12 +23,12 @@ public class dbVendorDialogHandler extends dbHandlerBase {
public dbVendorDialogHandler() {
this.localClass = VendorDialog.class;
this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public VendorDialog GET_VENDORDIALOG(final int objectUUID) {
VendorDialog vendorDialog = (VendorDialog) DbManager.getFromCache(Enum.GameObjectType.VendorDialog, objectUUID);
VendorDialog vendorDialog = (VendorDialog) DbManager.getFromCache(mbEnums.GameObjectType.VendorDialog, objectUUID);
if (vendorDialog != null)
return vendorDialog;
+90 -13
View File
@@ -9,19 +9,20 @@
package engine.db.handlers;
import engine.Enum;
import engine.Enum.GameObjectType;
import engine.Enum.TransactionType;
import engine.gameManager.DbManager;
import engine.gameManager.ForgeManager;
import engine.loot.WorkOrder;
import engine.mbEnums;
import engine.mbEnums.GameObjectType;
import engine.mbEnums.TransactionType;
import engine.objects.Building;
import engine.objects.City;
import engine.objects.Transaction;
import engine.objects.Warehouse;
import engine.server.MBServerStatics;
import org.joda.time.DateTime;
import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.JSONArray;
import org.json.JSONObject;
import org.pmw.tinylog.Logger;
import java.sql.Connection;
@@ -39,7 +40,7 @@ public class dbWarehouseHandler extends dbHandlerBase {
}
public boolean CREATE_TRANSACTION(int warehouseBuildingID, GameObjectType targetType, int targetUUID, TransactionType transactionType, Enum.ResourceType resource, int amount, DateTime date) {
public boolean CREATE_TRANSACTION(int warehouseBuildingID, GameObjectType targetType, int targetUUID, TransactionType transactionType, mbEnums.ResourceType resource, int amount, DateTime date) {
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO `dyn_warehouse_transactions` (`warehouseUID`, `targetType`,`targetUID`, `type`,`resource`,`amount`,`date` ) VALUES (?,?,?,?,?,?,?)")) {
@@ -105,8 +106,8 @@ public class dbWarehouseHandler extends dbHandlerBase {
JSONArray locks = new JSONArray();
for (Enum.ResourceType resource : warehouse.locked)
locks.add(resource.name());
for (mbEnums.ResourceType resource : warehouse.locked)
locks.put(resource.name());
warehouseJSON.put("locked", locks);
@@ -127,22 +128,26 @@ public class dbWarehouseHandler extends dbHandlerBase {
public void LOAD_WAREHOUSES() {
JSONParser jsonParser = new JSONParser();
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `dyn_warehouse`;");
ResultSet rs = preparedStatement.executeQuery()) {
while (rs.next()) {
int cityUID = rs.getInt("cityUUID");
JSONObject jsonObject = (JSONObject) jsonParser.parse(rs.getString("warehouse"));
JSONObject jsonObject = new JSONObject(rs.getString("warehouse"));
City city = City.getCity(cityUID);
if (city == null) {
Logger.error("No city " + cityUID + " for warehouse");
continue;
}
city.warehouse = new Warehouse(jsonObject);
city.warehouse.city = city;
// Locate warehouse building
for (Building building : city.parentZone.zoneBuildingSet) {
if (building.getBlueprint().getBuildingGroup().equals(Enum.BuildingGroup.WAREHOUSE)) {
if (building.getBlueprint().getBuildingGroup().equals(mbEnums.BuildingGroup.WAREHOUSE)) {
city.warehouse.building = building;
break;
}
@@ -154,4 +159,76 @@ public class dbWarehouseHandler extends dbHandlerBase {
Logger.error(e);
}
}
public boolean WRITE_WORKORDER(WorkOrder workOrder) {
JSONObject warehouseJSON = WorkOrder.toJson(workOrder);
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO `dyn_workorders` (`workorderID`, `workorder`) VALUES (?, ?) " +
"ON DUPLICATE KEY UPDATE `workorder` = VALUES(`workorder`)")) {
preparedStatement.setInt(1, workOrder.workOrderID);
preparedStatement.setString(2, warehouseJSON.toString());
return (preparedStatement.executeUpdate() > 0);
} catch (SQLException e) {
Logger.error(e);
}
return false;
}
public void DELETE_WORKORDER(WorkOrder workOrder) {
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("DELETE FROM `dyn_workorders` WHERE `workorderID` = ?;")) {
preparedStatement.setInt(1, workOrder.workOrderID);
preparedStatement.executeUpdate();
} catch (SQLException e) {
Logger.error(e);
}
}
public void LOAD_WORKORDERS() {
// Method loads NPC workOrders from disk at bootstrap.
// A workOrder will persist until completed or junked
// via the client interface.
ArrayList<WorkOrder> submitList = new ArrayList<>();
ArrayList<WorkOrder> orphanList = new ArrayList<>();
try (Connection connection = DbManager.getConnection();
PreparedStatement preparedStatement = connection.prepareStatement("SELECT * FROM `dyn_workorders`;");
ResultSet rs = preparedStatement.executeQuery()) {
while (rs.next()) {
JSONObject jsonObject = new JSONObject(rs.getString("workorder"));
WorkOrder workOrder = new WorkOrder(jsonObject);
submitList.add(workOrder);
}
} catch (Exception e) {
Logger.error(e);
}
// Submit new workOrders to the ForgeManager
for (WorkOrder workOrder : submitList) {
DbManager.WarehouseQueries.DELETE_WORKORDER(workOrder);
// Delete but do not reconstitute orphan workOrders
if (workOrder.vendor == null)
continue;
workOrder.workOrderID = ForgeManager.workOrderCounter.incrementAndGet();
DbManager.WarehouseQueries.WRITE_WORKORDER(workOrder);
ForgeManager.vendorWorkOrderLookup.get(workOrder.vendor).add(workOrder);
ForgeManager.forge.add(workOrder);
}
}
}
+5 -5
View File
@@ -9,9 +9,9 @@
package engine.db.handlers;
import engine.Enum;
import engine.gameManager.DbManager;
import engine.gameManager.ZoneManager;
import engine.mbEnums;
import engine.objects.Zone;
import engine.objects.ZoneTemplate;
import org.pmw.tinylog.Logger;
@@ -26,7 +26,7 @@ public class dbZoneHandler extends dbHandlerBase {
public dbZoneHandler() {
this.localClass = Zone.class;
this.localObjectType = Enum.GameObjectType.valueOf(this.localClass.getSimpleName());
this.localObjectType = mbEnums.GameObjectType.valueOf(this.localClass.getSimpleName());
}
public ArrayList<Zone> GET_ALL_ZONES() {
@@ -48,7 +48,7 @@ public class dbZoneHandler extends dbHandlerBase {
public Zone GET_BY_UID(long ID) {
Zone zone = (Zone) DbManager.getFromCache(Enum.GameObjectType.Zone, (int) ID);
Zone zone = (Zone) DbManager.getFromCache(mbEnums.GameObjectType.Zone, (int) ID);
if (zone != null)
return zone;
@@ -90,8 +90,8 @@ public class dbZoneHandler extends dbHandlerBase {
zoneTemplate.max_blend = 128;
zoneTemplate.min_blend = 128;
zoneTemplate.terrain_max_y = 5;
zoneTemplate.major_radius = (int) Enum.CityBoundsType.ZONE.halfExtents;
zoneTemplate.minor_radius = (int) Enum.CityBoundsType.ZONE.halfExtents;
zoneTemplate.major_radius = (int) mbEnums.CityBoundsType.ZONE.halfExtents;
zoneTemplate.minor_radius = (int) mbEnums.CityBoundsType.ZONE.halfExtents;
zoneTemplate.terrain_type = "PLANAR";
ZoneManager._zone_templates.put(zoneTemplate.templateID, zoneTemplate);
+1 -1
View File
@@ -9,9 +9,9 @@
package engine.devcmd;
import engine.Enum.GameObjectType;
import engine.gameManager.ChatManager;
import engine.gameManager.DbManager;
import engine.mbEnums.GameObjectType;
import engine.objects.*;
import java.util.ArrayList;
+1 -1
View File
@@ -9,7 +9,6 @@
package engine.devcmd.cmds;
import engine.Enum.ProtectionState;
import engine.InterestManagement.WorldGrid;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.ChatManager;
@@ -17,6 +16,7 @@ import engine.gameManager.DbManager;
import engine.gameManager.ZoneManager;
import engine.math.Vector3f;
import engine.math.Vector3fImmutable;
import engine.mbEnums.ProtectionState;
import engine.objects.*;
import engine.server.MBServerStatics;
+2 -2
View File
@@ -9,10 +9,10 @@
package engine.devcmd.cmds;
import engine.Enum;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.ChatManager;
import engine.gameManager.ZoneManager;
import engine.mbEnums;
import engine.objects.AbstractGameObject;
import engine.objects.Mob;
import engine.objects.PlayerCharacter;
@@ -61,7 +61,7 @@ public class AddMobCmd extends AbstractDevCmd {
}
Mob mob = Mob.createMob(loadID, pc.getLoc(),
null, zone, null, null, "", 1, Enum.AIAgentType.MOBILE);
null, zone, null, null, "", 1, mbEnums.AIAgentType.MOBILE);
if (mob != null) {
mob.updateDatabase();
+1 -1
View File
@@ -9,10 +9,10 @@
package engine.devcmd.cmds;
import engine.Enum.GameObjectType;
import engine.InterestManagement.WorldGrid;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.*;
import engine.mbEnums.GameObjectType;
import engine.objects.*;
import org.pmw.tinylog.Logger;
+1 -1
View File
@@ -9,10 +9,10 @@
package engine.devcmd.cmds;
import engine.Enum.PowerActionType;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.ChatManager;
import engine.gameManager.PowersManager;
import engine.mbEnums.PowerActionType;
import engine.objects.AbstractGameObject;
import engine.objects.PlayerCharacter;
import engine.powers.ActionsBase;
+1 -1
View File
@@ -9,8 +9,8 @@
package engine.devcmd.cmds;
import engine.Enum.GameObjectType;
import engine.devcmd.AbstractDevCmd;
import engine.mbEnums.GameObjectType;
import engine.objects.AbstractGameObject;
import engine.objects.Building;
import engine.objects.PlayerCharacter;
+33 -4
View File
@@ -10,9 +10,14 @@
package engine.devcmd.cmds;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.ChatManager;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.AbstractGameObject;
import engine.objects.ItemFactory;
import engine.objects.Item;
import engine.objects.ItemTemplate;
import engine.objects.PlayerCharacter;
import org.pmw.tinylog.Logger;
/**
* @author Eighty
@@ -24,22 +29,46 @@ public class CreateItemCmd extends AbstractDevCmd {
}
@Override
protected void _doCmd(PlayerCharacter pc, String[] words,
protected void _doCmd(PlayerCharacter playerCharacter, String[] words,
AbstractGameObject target) {
if (words.length < 2) {
this.sendUsage(pc);
this.sendUsage(playerCharacter);
return;
}
int templateID = Integer.parseInt(words[0]);
ItemTemplate template = ItemTemplate.templates.get(templateID);
if (template == null) {
ChatManager.chatSystemInfo(playerCharacter, "No such template found.");
return;
}
int size = 1;
if (words.length == 2)
size = Integer.parseInt(words[1]);
ItemFactory.fillInventory(pc, templateID, size);
for (int i = 0; i < size; i++) {
if (!playerCharacter.charItemManager.hasRoomInventory(template.item_wt)) {
ChatManager.chatSystemInfo(playerCharacter, "You are encumbered!.");
break;
}
Item item = new Item(templateID);
item.ownerID = playerCharacter.getObjectUUID();
item.ownerType = mbEnums.OwnerType.PlayerCharacter;
item.containerType = mbEnums.ItemContainerType.INVENTORY;
try {
item = DbManager.ItemQueries.PERSIST(item);
playerCharacter.charItemManager.addItemToInventory(item);
} catch (Exception e) {
Logger.error(e);
}
}
playerCharacter.charItemManager.updateInventory();
}
@Override
+1 -1
View File
@@ -9,11 +9,11 @@
package engine.devcmd.cmds;
import engine.Enum.GameObjectType;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.DbManager;
import engine.gameManager.SessionManager;
import engine.math.Vector3fImmutable;
import engine.mbEnums.GameObjectType;
import engine.objects.*;
import engine.server.MBServerStatics;
+8 -8
View File
@@ -9,10 +9,10 @@
package engine.devcmd.cmds;
import engine.Enum;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.DbManager;
import engine.math.Vector3fImmutable;
import engine.mbEnums;
import engine.objects.*;
public class GotoObj extends AbstractDevCmd {
@@ -27,7 +27,7 @@ public class GotoObj extends AbstractDevCmd {
int uuid;
Vector3fImmutable targetLoc = Vector3fImmutable.ZERO;
Enum.DbObjectType objectType;
mbEnums.DbObjectType objectType;
try {
uuid = Integer.parseInt(words[0]);
@@ -41,37 +41,37 @@ public class GotoObj extends AbstractDevCmd {
switch (objectType) {
case NPC:
NPC npc = (NPC) DbManager.getFromCache(Enum.GameObjectType.NPC, uuid);
NPC npc = (NPC) DbManager.getFromCache(mbEnums.GameObjectType.NPC, uuid);
if (npc != null)
targetLoc = npc.getLoc();
break;
case MOB:
Mob mob = (Mob) DbManager.getFromCache(Enum.GameObjectType.Mob, uuid);
Mob mob = (Mob) DbManager.getFromCache(mbEnums.GameObjectType.Mob, uuid);
if (mob != null)
targetLoc = mob.getLoc();
break;
case CHARACTER:
PlayerCharacter playerCharacter = (PlayerCharacter) DbManager.getFromCache(Enum.GameObjectType.PlayerCharacter, uuid);
PlayerCharacter playerCharacter = (PlayerCharacter) DbManager.getFromCache(mbEnums.GameObjectType.PlayerCharacter, uuid);
if (playerCharacter != null)
targetLoc = playerCharacter.getLoc();
break;
case BUILDING:
Building building = (Building) DbManager.getFromCache(Enum.GameObjectType.Building, uuid);
Building building = (Building) DbManager.getFromCache(mbEnums.GameObjectType.Building, uuid);
if (building != null)
targetLoc = building.getLoc();
break;
case ZONE:
Zone zone = (Zone) DbManager.getFromCache(Enum.GameObjectType.Zone, uuid);
Zone zone = (Zone) DbManager.getFromCache(mbEnums.GameObjectType.Zone, uuid);
if (zone != null)
targetLoc = zone.getLoc();
break;
case CITY:
City city = (City) DbManager.getFromCache(Enum.GameObjectType.City, uuid);
City city = (City) DbManager.getFromCache(mbEnums.GameObjectType.City, uuid);
if (city != null)
targetLoc = city.getLoc();
+11 -9
View File
@@ -9,14 +9,14 @@
package engine.devcmd.cmds;
import engine.Enum;
import engine.Enum.BuildingGroup;
import engine.Enum.GameObjectType;
import engine.Enum.TargetColor;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.BuildingManager;
import engine.gameManager.SessionManager;
import engine.math.Vector3fImmutable;
import engine.mbEnums;
import engine.mbEnums.BuildingGroup;
import engine.mbEnums.GameObjectType;
import engine.mbEnums.TargetColor;
import engine.objects.*;
import engine.util.StringUtils;
@@ -369,7 +369,8 @@ public class InfoCmd extends AbstractDevCmd {
output += newline;
output += "InventorySet: " + targetNPC.getContract().inventorySet;
output += newline;
output += targetNPC.getContract().getAllowedBuildings().toString();
Contract contract1 = targetNPC.getContract();
output += contract1.allowedBuildings.toString();
output += newline;
output += "Extra Rune: " + targetNPC.getContract().getExtraRune();
@@ -383,7 +384,8 @@ public class InfoCmd extends AbstractDevCmd {
output += newline;
if (mobBase != null) {
output += newline;
output += "Slottable: " + targetNPC.getContract().getAllowedBuildings().toString();
Contract contract = targetNPC.getContract();
output += "Slottable: " + contract.allowedBuildings.toString();
output += newline;
output += "EquipSet: " + targetNPC.getEquipmentSetID();
output += newline;
@@ -436,7 +438,7 @@ public class InfoCmd extends AbstractDevCmd {
if (targetMob.isPet()) {
output += "isPet: true";
output += newline;
if ((targetMob.agentType.equals(Enum.AIAgentType.PET)))
if ((targetMob.agentType.equals(mbEnums.AIAgentType.PET)))
output += "isSummonedPet: true";
else
output += "isSummonedPet: false";
@@ -456,7 +458,7 @@ public class InfoCmd extends AbstractDevCmd {
output += newline;
}
if ((targetMob.agentType.equals(Enum.AIAgentType.MOBILE))) {
if ((targetMob.agentType.equals(mbEnums.AIAgentType.MOBILE))) {
output += "SpawnRadius: " + targetMob.getSpawnRadius();
output += newline;
output += "Spawn Timer: " + targetMob.getSpawnTimeAsString();
@@ -473,7 +475,7 @@ public class InfoCmd extends AbstractDevCmd {
output += "EquipSet: " + targetMob.equipmentSetID;
output += newline;
try {
output += "Parent Zone LoadNum : " + targetMob.getParentZone().templateID;
output += "Parent Zone LoadNum : " + targetMob.parentZone.templateID;
} catch (Exception ex) {
//who cares
}
-212
View File
@@ -1,212 +0,0 @@
// ·. · · · · .
// · ·
// · ·
//
// · · ·
// Magicbane Emulator Project © 2013 - 2022
// www.magicbane.com
package engine.devcmd.cmds;
import engine.Enum.ProtectionState;
import engine.InterestManagement.WorldGrid;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.BuildingManager;
import engine.gameManager.ChatManager;
import engine.gameManager.DbManager;
import engine.gameManager.ZoneManager;
import engine.math.Vector3f;
import engine.math.Vector3fImmutable;
import engine.objects.*;
import org.pmw.tinylog.Logger;
/**
* @author Eighty
*/
public class MakeBaneCmd extends AbstractDevCmd {
public MakeBaneCmd() {
super("makebane");
}
@Override
protected void _doCmd(PlayerCharacter pc, String[] words,
AbstractGameObject target) {
if (words.length < 1 || words.length > 2) {
this.sendUsage(pc);
return;
}
int attackerID = 0;
int rank = 8;
if (words.length == 2) {
try {
attackerID = Integer.parseInt(words[0]);
rank = Integer.parseInt(words[1]);
} catch (NumberFormatException e) {
throwbackError(pc, "AttackerGuildID must be a number, " + words[0] + " is invalid");
return;
}
} else if (words.length == 1) {
if (target == null) {
throwbackError(pc, "No target specified");
return;
}
if (!(target instanceof PlayerCharacter)) {
throwbackError(pc, "Target is not a player");
return;
}
attackerID = target.getObjectUUID();
try {
rank = Integer.parseInt(words[0]);
} catch (NumberFormatException e) {
throwbackError(pc, "Rank must be specified, 1 through 8");
return;
}
}
if (rank < 1 || rank > 8) {
throwbackError(pc, "Rank must be 1 through 8");
return;
}
PlayerCharacter player = PlayerCharacter.getPlayerCharacter(attackerID);
if (player.getGuild().isEmptyGuild()) {
throwbackError(pc, "Errant's can not place banes");
return;
}
AbstractCharacter attackerAGL = Guild.GetGL(player.getGuild());
if (attackerAGL == null) {
throwbackError(pc, "No guild leader found for attacking guild.");
return;
}
if (!(attackerAGL instanceof PlayerCharacter)) {
throwbackError(pc, "Attacking guild leader is an NPC.");
return;
}
if (player.getGuild().isNPCGuild()) {
throwbackError(pc, "The guild used is an npc guild. They can not bane.");
return;
}
// if (player.getGuild().getOwnedCity() != null) {
// throwbackError(pc, "The attacking guild already has a city.");
// return;
// }
Zone zone = ZoneManager.findSmallestZone(pc.getLoc());
if (zone == null) {
throwbackError(pc, "Unable to find the zone you're in.");
return;
}
if (!zone.guild_zone) {
throwbackError(pc, "This is not a player city.");
return;
}
City city = City.getCity(zone.playerCityUUID);
if (city == null) {
throwbackError(pc, "Unable to find the city associated with this zone.");
return;
}
if (city.getTOL() == null) {
throwbackError(pc, "Unable to find the tree of life for this city.");
return;
}
if (city.getBane() != null) {
throwbackError(pc, "This city is already baned.");
return;
}
if (Bane.getBaneByAttackerGuild(player.getGuild()) != null) {
throwbackError(pc, "This guild is already baning someone.");
return;
}
Blueprint blueprint = Blueprint.getBlueprint(24300);
if (blueprint == null) {
throwbackError(pc, "Unable to find building set for banestone.");
return;
}
Vector3f rot = new Vector3f(0, 0, 0);
// *** Refactor : Overlap test goes here
//Let's drop a banestone!
Vector3fImmutable localLocation = ZoneManager.worldToLocal(pc.getLoc(), zone);
if (localLocation == null) {
ChatManager.chatSystemError(pc, "Failed to convert world location to zone location. Contact a CCR.");
Logger.info("Failed to Convert World coordinates to local zone coordinates");
return;
}
Building stone = DbManager.BuildingQueries.CREATE_BUILDING(
zone.getObjectUUID(), pc.getObjectUUID(), blueprint.getName(), blueprint.getBlueprintUUID(),
localLocation, 1.0f, blueprint.getMaxHealth(rank), ProtectionState.PROTECTED, 0, rank,
null, blueprint.getBlueprintUUID(), 1, 0.0f);
if (stone == null) {
ChatManager.chatSystemError(pc, "Failed to create banestone.");
return;
}
stone.addEffectBit((1 << 19));
BuildingManager.setRank(stone, (byte) rank);
stone.setMaxHitPoints(blueprint.getMaxHealth(stone.getRank()));
stone.setCurrentHitPoints(stone.getMaxHitPoints());
BuildingManager.setUpgradeDateTime(stone, null, 0);
//Make the bane
Bane bane = Bane.makeBane(player, city, stone);
if (bane == null) {
//delete bane stone, failed to make bane object
DbManager.BuildingQueries.DELETE_FROM_DATABASE(stone);
throwbackError(pc, "Failed to create bane.");
return;
}
WorldGrid.addObject(stone, pc);
//Add baned effect to TOL
city.getTOL().addEffectBit((1 << 16));
city.getTOL().updateEffects();
Vector3fImmutable movePlayerOutsideStone = player.getLoc();
movePlayerOutsideStone = movePlayerOutsideStone.setX(movePlayerOutsideStone.x + 10);
movePlayerOutsideStone = movePlayerOutsideStone.setZ(movePlayerOutsideStone.z + 10);
player.teleport(movePlayerOutsideStone);
throwbackInfo(pc, "The city has been succesfully baned.");
}
@Override
protected String _getHelpString() {
return "Creates an bane.";
}
@Override
protected String _getUsageString() {
return "'./makebane playerUUID baneRank'";
}
}
+2 -2
View File
@@ -9,10 +9,10 @@
package engine.devcmd.cmds;
import engine.Enum.ItemType;
import engine.Enum.OwnerType;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.DbManager;
import engine.mbEnums.ItemType;
import engine.mbEnums.OwnerType;
import engine.objects.*;
import engine.powers.EffectsBase;
+1 -1
View File
@@ -9,9 +9,9 @@
package engine.devcmd.cmds;
import engine.Enum.GameObjectType;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.ChatManager;
import engine.mbEnums.GameObjectType;
import engine.objects.*;
import engine.powers.effectmodifiers.AbstractEffectModifier;
+6 -6
View File
@@ -9,9 +9,9 @@
package engine.devcmd.cmds;
import engine.Enum;
import engine.Enum.GameObjectType;
import engine.devcmd.AbstractDevCmd;
import engine.mbEnums;
import engine.mbEnums.GameObjectType;
import engine.objects.*;
import java.util.concurrent.ConcurrentHashMap;
@@ -64,7 +64,7 @@ public class PrintEquipCmd extends AbstractDevCmd {
if (tar.getObjectType() == GameObjectType.Mob) {
Mob tarMob = (Mob) tar;
throwbackInfo(pc, "Equip for " + type + ' ' + name + " (" + tar.getObjectUUID() + ')');
for (Enum.EquipSlotType slot : tarMob.charItemManager.equipped.keySet()) {
for (mbEnums.EquipSlotType slot : tarMob.charItemManager.equipped.keySet()) {
Item equip = tarMob.charItemManager.equipped.get(slot);
throwbackInfo(pc, equip.templateID + " : " + equip.template.item_base_name + ", slot: " + slot);
}
@@ -74,7 +74,7 @@ public class PrintEquipCmd extends AbstractDevCmd {
if (tar.getObjectType() == GameObjectType.NPC) {
NPC tarMob = (NPC) tar;
throwbackInfo(pc, "Equip for " + type + ' ' + name + " (" + tar.getObjectUUID() + ')');
for (Enum.EquipSlotType slot : tarMob.charItemManager.equipped.keySet()) {
for (mbEnums.EquipSlotType slot : tarMob.charItemManager.equipped.keySet()) {
Item equip = tarMob.charItemManager.equipped.get(slot);
throwbackInfo(pc, equip.templateID + " : " + equip.template.item_base_name + ", slot: " + slot);
}
@@ -82,10 +82,10 @@ public class PrintEquipCmd extends AbstractDevCmd {
}
CharacterItemManager cim = ((AbstractCharacter) tar).charItemManager;
ConcurrentHashMap<Enum.EquipSlotType, Item> list = cim.getEquipped();
ConcurrentHashMap<mbEnums.EquipSlotType, Item> list = cim.getEquipped();
throwbackInfo(pc, "Equip for " + type + ' ' + name + " (" + tar.getObjectUUID() + ')');
for (Enum.EquipSlotType slot : list.keySet()) {
for (mbEnums.EquipSlotType slot : list.keySet()) {
Item item = list.get(slot);
throwbackInfo(pc, " " + item.template.item_base_name + ", slot: " + slot);
}
@@ -9,8 +9,8 @@
package engine.devcmd.cmds;
import engine.Enum.ItemType;
import engine.devcmd.AbstractDevCmd;
import engine.mbEnums.ItemType;
import engine.objects.*;
import java.text.DecimalFormat;
+1 -1
View File
@@ -9,8 +9,8 @@
package engine.devcmd.cmds;
import engine.Enum.GameObjectType;
import engine.devcmd.AbstractDevCmd;
import engine.mbEnums.GameObjectType;
import engine.objects.*;
import java.util.concurrent.ConcurrentHashMap;
+3 -2
View File
@@ -9,8 +9,9 @@
package engine.devcmd.cmds;
import engine.Enum;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.ItemManager;
import engine.mbEnums;
import engine.objects.*;
/**
@@ -87,7 +88,7 @@ public class PrintStatsCmd extends AbstractDevCmd {
//get weapons
if (tar.charItemManager.equipped.isEmpty() == false)
if (tar.charItemManager.equipped.get(Enum.EquipSlotType.LHELD) != null && !ItemTemplate.isShield(tar.charItemManager.equipped.get(Enum.EquipSlotType.LHELD))) {
if (tar.charItemManager.equipped.get(mbEnums.EquipSlotType.LHELD) != null && !ItemManager.isShield(tar.charItemManager.equipped.get(mbEnums.EquipSlotType.LHELD))) {
//off hand weapon
out += "Attack Rating: " + tar.atrHandTwo + newline;
out += "Damage: " + tar.minDamageHandTwo + " - " + tar.maxDamageHandTwo + newline;
+13 -9
View File
@@ -1,14 +1,14 @@
package engine.devcmd.cmds;
import engine.Enum;
import engine.Enum.BuildingGroup;
import engine.Enum.GameObjectType;
import engine.InterestManagement.WorldGrid;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.BuildingManager;
import engine.gameManager.DbManager;
import engine.gameManager.ZoneManager;
import engine.math.Vector3fImmutable;
import engine.mbEnums;
import engine.mbEnums.BuildingGroup;
import engine.mbEnums.GameObjectType;
import engine.objects.*;
import engine.server.MBServerStatics;
import org.pmw.tinylog.Logger;
@@ -64,8 +64,9 @@ public class PurgeObjectsCmd extends AbstractDevCmd {
WorldGrid.RemoveWorldObject(mob);
WorldGrid.removeObject(mob, pc);
if (mob.getParentZone() != null)
if (mob.getParentZone() != null) {
mob.getParentZone().zoneMobSet.remove(mob);
}
}
DbManager.NPCQueries.DELETE_NPC(npc);
@@ -78,8 +79,9 @@ public class PurgeObjectsCmd extends AbstractDevCmd {
WorldGrid.RemoveWorldObject(mob);
WorldGrid.removeObject(mob, pc);
if (mob.getParentZone() != null)
if (mob.getParentZone() != null) {
mob.getParentZone().zoneMobSet.remove(mob);
}
}
DbManager.MobQueries.DELETE_MOB(mobA);
DbManager.removeFromCache(GameObjectType.Mob,
@@ -159,11 +161,12 @@ public class PurgeObjectsCmd extends AbstractDevCmd {
WorldGrid.RemoveWorldObject(mob);
WorldGrid.removeObject(mob, pc);
if (mob.getParentZone() != null)
if (mob.getParentZone() != null) {
mob.getParentZone().zoneMobSet.remove(mob);
}
}
DbManager.NPCQueries.DELETE_NPC(npc);
DbManager.removeFromCache(Enum.GameObjectType.NPC,
DbManager.removeFromCache(mbEnums.GameObjectType.NPC,
npc.getObjectUUID());
WorldGrid.RemoveWorldObject(npc);
} else if (mobA != null) {
@@ -172,11 +175,12 @@ public class PurgeObjectsCmd extends AbstractDevCmd {
WorldGrid.RemoveWorldObject(mob);
WorldGrid.removeObject(mob, pc);
if (mob.getParentZone() != null)
if (mob.getParentZone() != null) {
mob.getParentZone().zoneMobSet.remove(mob);
}
}
DbManager.MobQueries.DELETE_MOB(mobA);
DbManager.removeFromCache(Enum.GameObjectType.Mob,
DbManager.removeFromCache(mbEnums.GameObjectType.Mob,
mobA.getObjectUUID());
WorldGrid.RemoveWorldObject(mobA);
}
+1 -1
View File
@@ -9,9 +9,9 @@
package engine.devcmd.cmds;
import engine.Enum.SiegeResult;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.ZoneManager;
import engine.mbEnums.SiegeResult;
import engine.objects.*;
/**
+12 -8
View File
@@ -9,8 +9,6 @@
package engine.devcmd.cmds;
import engine.Enum.BuildingGroup;
import engine.Enum.DbObjectType;
import engine.InterestManagement.WorldGrid;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.BuildingManager;
@@ -18,6 +16,8 @@ import engine.gameManager.ChatManager;
import engine.gameManager.DbManager;
import engine.gameManager.ZoneManager;
import engine.math.Vector3fImmutable;
import engine.mbEnums.BuildingGroup;
import engine.mbEnums.DbObjectType;
import engine.objects.*;
/**
@@ -180,8 +180,9 @@ public class RemoveObjectCmd extends AbstractDevCmd {
WorldGrid.RemoveWorldObject(minionMob);
WorldGrid.removeObject(minionMob, pc);
if (minionMob.getParentZone() != null)
if (minionMob.getParentZone() != null) {
minionMob.getParentZone().zoneMobSet.remove(minionMob);
}
}
DbManager.NPCQueries.DELETE_NPC(npc);
@@ -202,9 +203,11 @@ public class RemoveObjectCmd extends AbstractDevCmd {
return;
}
if (mob.getParentZone() != null && mob.getParentZone() != currentZone && !mob.isPet() && !mob.isNecroPet()) {
this.throwbackError(pc, "Error 376954: Could not Remove Mob.Mob is not in the same zone as player.");
return;
if (mob.getParentZone() != null) {
if (mob.parentZone != currentZone && !mob.isPet() && !mob.isNecroPet()) {
this.throwbackError(pc, "Error 376954: Could not Remove Mob.Mob is not in the same zone as player.");
return;
}
}
// Remove npc from hirelings list.
@@ -222,8 +225,9 @@ public class RemoveObjectCmd extends AbstractDevCmd {
WorldGrid.RemoveWorldObject(mob);
WorldGrid.removeObject(mob, pc);
if (mob.getParentZone() != null)
mob.getParentZone().zoneMobSet.remove(mob);
if (mob.parentZone != null) {
mob.parentZone.zoneMobSet.remove(mob);
}
ChatManager.chatSayInfo(pc,
"Mob with ID " + mob.getDBID() + " removed");
@@ -9,12 +9,12 @@
package engine.devcmd.cmds;
import engine.Enum.GameObjectType;
import engine.InterestManagement.WorldGrid;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.BuildingManager;
import engine.gameManager.DbManager;
import engine.math.Vector3fImmutable;
import engine.mbEnums.GameObjectType;
import engine.objects.AbstractGameObject;
import engine.objects.Building;
import engine.objects.PlayerCharacter;
+1 -1
View File
@@ -1,9 +1,9 @@
package engine.devcmd.cmds;
import engine.Enum.GameObjectType;
import engine.InterestManagement.WorldGrid;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.DbManager;
import engine.mbEnums.GameObjectType;
import engine.objects.AbstractGameObject;
import engine.objects.Guild;
import engine.objects.NPC;
+3 -3
View File
@@ -9,9 +9,9 @@
package engine.devcmd.cmds;
import engine.Enum.DispatchChannel;
import engine.devcmd.AbstractDevCmd;
import engine.net.DispatchMessage;
import engine.gameManager.DispatchManager;
import engine.mbEnums.DispatchChannel;
import engine.net.client.msg.TargetedActionMsg;
import engine.objects.AbstractGameObject;
import engine.objects.PlayerCharacter;
@@ -41,7 +41,7 @@ public class SetHealthCmd extends AbstractDevCmd {
// Update all surrounding clients.
TargetedActionMsg cmm = new TargetedActionMsg(pc);
DispatchMessage.dispatchMsgToInterestArea(pc, cmm, DispatchChannel.SECONDARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
DispatchManager.dispatchMsgToInterestArea(pc, cmm, DispatchChannel.SECONDARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
} catch (NumberFormatException e) {
this.throwbackError(pc, "Supplied data: " + words[0]
+3 -3
View File
@@ -10,9 +10,9 @@
package engine.devcmd.cmds;
import engine.Enum;
import engine.Enum.ProtectionState;
import engine.devcmd.AbstractDevCmd;
import engine.mbEnums;
import engine.mbEnums.ProtectionState;
import engine.objects.AbstractGameObject;
import engine.objects.Building;
import engine.objects.City;
@@ -59,7 +59,7 @@ public class SetInvulCmd extends AbstractDevCmd {
// status of the entire city
if ((b.getBlueprint() != null) &&
(b.getBlueprint().getBuildingGroup().equals(Enum.BuildingGroup.TOL))) {
(b.getBlueprint().getBuildingGroup().equals(mbEnums.BuildingGroup.TOL))) {
City city;
+3 -2
View File
@@ -1,7 +1,8 @@
package engine.devcmd.cmds;
import engine.devcmd.AbstractDevCmd;
import engine.net.DispatchMessage;
import engine.gameManager.DispatchManager;
import engine.mbEnums;
import engine.net.client.msg.TargetedActionMsg;
import engine.objects.AbstractGameObject;
import engine.objects.PlayerCharacter;
@@ -31,7 +32,7 @@ public class SetManaCmd extends AbstractDevCmd {
//Update all surrounding clients. - NOT for Mana?
TargetedActionMsg cmm = new TargetedActionMsg(pc);
DispatchMessage.dispatchMsgToInterestArea(pc, cmm, engine.Enum.DispatchChannel.SECONDARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
DispatchManager.dispatchMsgToInterestArea(pc, cmm, mbEnums.DispatchChannel.SECONDARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
} catch (NumberFormatException e) {
this.throwbackError(pc, "Supplied data: " + words[0]
+1 -1
View File
@@ -9,9 +9,9 @@
package engine.devcmd.cmds;
import engine.Enum.GameObjectType;
import engine.InterestManagement.WorldGrid;
import engine.devcmd.AbstractDevCmd;
import engine.mbEnums.GameObjectType;
import engine.objects.AbstractGameObject;
import engine.objects.NPC;
import engine.objects.PlayerCharacter;
+4 -3
View File
@@ -1,9 +1,10 @@
package engine.devcmd.cmds;
import engine.Enum.DbObjectType;
import engine.Enum.GameObjectType;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.mbEnums.DbObjectType;
import engine.mbEnums.GameObjectType;
import engine.objects.*;
@@ -37,7 +38,7 @@ public class SetOwnerCmd extends AbstractDevCmd {
// if it's a tol change ownership of the city
if (_targetBuilding.getBlueprint() != null &&
_targetBuilding.getBlueprint().getBuildingGroup().equals(engine.Enum.BuildingGroup.TOL)) {
_targetBuilding.getBlueprint().getBuildingGroup().equals(mbEnums.BuildingGroup.TOL)) {
City city = _targetBuilding.getCity();
@@ -1,10 +1,10 @@
package engine.devcmd.cmds;
import engine.Enum.DispatchChannel;
import engine.InterestManagement.InterestManager;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.ChatManager;
import engine.net.DispatchMessage;
import engine.gameManager.DispatchManager;
import engine.mbEnums.DispatchChannel;
import engine.net.client.msg.ApplyRuneMsg;
import engine.objects.AbstractGameObject;
import engine.objects.PlayerCharacter;
@@ -54,7 +54,7 @@ public class SetPromotionClassCmd extends AbstractDevCmd {
PromotionClass promo = pc.getPromotionClass();
if (promo != null) {
ApplyRuneMsg arm = new ApplyRuneMsg(pc.getObjectType().ordinal(), pc.getObjectUUID(), promo.getObjectUUID(), promo.getObjectType().ordinal(), promo.getObjectUUID(), true);
DispatchMessage.dispatchMsgToInterestArea(pc, arm, DispatchChannel.SECONDARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
DispatchManager.dispatchMsgToInterestArea(pc, arm, DispatchChannel.SECONDARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
}
}
+52
View File
@@ -0,0 +1,52 @@
// ·. · · · · .
// · ·
// · ·
//
// · · ·
// Magicbane Emulator Project © 2013 - 2022
// www.magicbane.com
package engine.devcmd.cmds;
import engine.InterestManagement.InterestManager;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.DbManager;
import engine.mbEnums;
import engine.objects.AbstractGameObject;
import engine.objects.NPC;
import engine.objects.PlayerCharacter;
public class SetRaceCmd extends AbstractDevCmd {
public SetRaceCmd() {
super("setRace");
}
@Override
protected void _doCmd(PlayerCharacter player, String[] words,
AbstractGameObject target) {
int newRace = Integer.parseInt(words[0]);
if (target.getObjectType().equals(mbEnums.GameObjectType.NPC) == false) {
throwbackError(player, "You Must Target An NPC");
}
NPC npc = (NPC) target;
npc.loadID = newRace;
DbManager.NPCQueries.UPDATE_RACE(npc, newRace);
InterestManager.reloadCharacter(npc);
}
@Override
protected String _getHelpString() {
return "Sets NPC race";
}
@Override
protected String _getUsageString() {
return "' /setrace ID'";
}
}
+3 -3
View File
@@ -9,9 +9,9 @@
package engine.devcmd.cmds;
import engine.Enum.DispatchChannel;
import engine.devcmd.AbstractDevCmd;
import engine.net.DispatchMessage;
import engine.gameManager.DispatchManager;
import engine.mbEnums.DispatchChannel;
import engine.net.client.msg.TargetedActionMsg;
import engine.objects.AbstractGameObject;
import engine.objects.PlayerCharacter;
@@ -42,7 +42,7 @@ public class SetStaminaCmd extends AbstractDevCmd {
// Update all surrounding clients.
TargetedActionMsg cmm = new TargetedActionMsg(pc);
DispatchMessage.dispatchMsgToInterestArea(pc, cmm, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
DispatchManager.dispatchMsgToInterestArea(pc, cmm, DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
} catch (NumberFormatException e) {
this.throwbackError(pc, "Supplied data: " + words[0]
+5 -5
View File
@@ -10,9 +10,9 @@
package engine.devcmd.cmds;
import engine.Enum.GameObjectType;
import engine.devcmd.AbstractDevCmd;
import engine.net.DispatchMessage;
import engine.gameManager.DispatchManager;
import engine.mbEnums.GameObjectType;
import engine.net.client.msg.ApplyBuildingEffectMsg;
import engine.net.client.msg.UpdateCharOrMobMessage;
import engine.objects.*;
@@ -39,13 +39,13 @@ public class SetSubRaceCmd extends AbstractDevCmd {
if (raceID == 0)
raceID = player.getRaceID();
UpdateCharOrMobMessage ucm = new UpdateCharOrMobMessage(player, 1, raceID);
DispatchMessage.sendToAllInRange(player, ucm);
DispatchManager.sendToAllInRange(player, ucm);
return;
}
if (words[0].equals("all")) {
for (int i = 15999; i < 16337; i++) {
ApplyBuildingEffectMsg applyBuildingEffectMsg = new ApplyBuildingEffectMsg(4, 0, target.getObjectType().ordinal(), target.getObjectUUID(), i);
DispatchMessage.sendToAllInRange((AbstractWorldObject) target, applyBuildingEffectMsg);
DispatchManager.sendToAllInRange((AbstractWorldObject) target, applyBuildingEffectMsg);
try {
Thread.sleep(500);
} catch (InterruptedException e) {
@@ -56,7 +56,7 @@ public class SetSubRaceCmd extends AbstractDevCmd {
} else {
ApplyBuildingEffectMsg applyBuildingEffectMsg = new ApplyBuildingEffectMsg(4, 0, target.getObjectType().ordinal(), target.getObjectUUID(), Integer.parseInt(words[0]));
DispatchMessage.sendToAllInRange((AbstractWorldObject) target, applyBuildingEffectMsg);
DispatchManager.sendToAllInRange((AbstractWorldObject) target, applyBuildingEffectMsg);
}
return;
+1 -1
View File
@@ -1,8 +1,8 @@
package engine.devcmd.cmds;
import engine.Enum.GameObjectType;
import engine.devcmd.AbstractDevCmd;
import engine.math.Vector3fImmutable;
import engine.mbEnums.GameObjectType;
import engine.objects.AbstractGameObject;
import engine.objects.Building;
import engine.objects.PlayerCharacter;
+8 -7
View File
@@ -9,10 +9,10 @@
package engine.devcmd.cmds;
import engine.Enum.BuildingGroup;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.ChatManager;
import engine.gameManager.DbManager;
import engine.mbEnums.BuildingGroup;
import engine.objects.*;
import engine.util.StringUtils;
import org.pmw.tinylog.Logger;
@@ -90,9 +90,9 @@ public class SlotNpcCmd extends AbstractDevCmd {
// User requests list of current groups.
if (args[0].equalsIgnoreCase("LIST")) {
if (args.length == 0 || args[0].equalsIgnoreCase("LIST")) {
outString = "Current: " + contract.getAllowedBuildings();
outString = "Current: " + contract.allowedBuildings;
throwbackInfo(pc, outString);
return;
@@ -110,9 +110,9 @@ public class SlotNpcCmd extends AbstractDevCmd {
switch (args[1].toUpperCase()) {
case "ON":
contract.getAllowedBuildings().add(buildingGroup);
contract.allowedBuildings.add(buildingGroup);
if (!DbManager.ContractQueries.updateAllowedBuildings(contract, contract.getAllowedBuildings().toLong())) {
if (!DbManager.ContractQueries.updateAllowedBuildings(contract)) {
Logger.error("Failed to update Database for Contract Allowed buildings");
ChatManager.chatSystemError(pc, "Failed to update Database for Contract Allowed buildings. ");
return;
@@ -121,8 +121,9 @@ public class SlotNpcCmd extends AbstractDevCmd {
throwbackInfo(pc, "SlotNpc " + buildingGroup.name() + " added to npc");
break;
case "OFF":
contract.getAllowedBuildings().remove(buildingGroup);
if (!DbManager.ContractQueries.updateAllowedBuildings(contract, contract.getAllowedBuildings().toLong())) {
contract.allowedBuildings.remove(buildingGroup);
if (!DbManager.ContractQueries.updateAllowedBuildings(contract)) {
Logger.error("Failed to update Database for Contract Allowed buildings");
ChatManager.chatSystemError(pc, "Failed to update Database for Contract Allowed buildings. ");
return;
+1 -1
View File
@@ -9,11 +9,11 @@
package engine.devcmd.cmds;
import engine.Enum.GameObjectType;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.BuildingManager;
import engine.gameManager.ChatManager;
import engine.math.Vector3fImmutable;
import engine.mbEnums.GameObjectType;
import engine.objects.*;
import java.util.ArrayList;
+2 -2
View File
@@ -1,9 +1,9 @@
package engine.devcmd.cmds;
import engine.Enum;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.ZoneManager;
import engine.math.Vector3fImmutable;
import engine.mbEnums;
import engine.objects.AbstractGameObject;
import engine.objects.Mob;
import engine.objects.PlayerCharacter;
@@ -111,7 +111,7 @@ public class SplatMobCmd extends AbstractDevCmd {
mobile = Mob.createMob(_mobileUUID,
Vector3fImmutable.getRandomPointInCircle(_currentLocation, _targetRange),
null, serverZone, null, null, "", 1, Enum.AIAgentType.MOBILE);
null, serverZone, null, null, "", 1, mbEnums.AIAgentType.MOBILE);
if (mobile != null) {
mobile.updateDatabase();
@@ -9,8 +9,8 @@
package engine.devcmd.cmds;
import engine.Enum.GameObjectType;
import engine.devcmd.AbstractDevCmd;
import engine.mbEnums.GameObjectType;
import engine.net.client.msg.LoadStructureMsg;
import engine.net.client.msg.MoveToPointMsg;
import engine.net.client.msg.UnloadObjectsMsg;
+5 -5
View File
@@ -9,10 +9,10 @@
package engine.devcmd.cmds;
import engine.Enum;
import engine.Enum.GameObjectType;
import engine.devcmd.AbstractDevCmd;
import engine.gameManager.PowersManager;
import engine.mbEnums;
import engine.mbEnums.GameObjectType;
import engine.mobileAI.MobAI;
import engine.objects.AbstractGameObject;
import engine.objects.Mob;
@@ -67,7 +67,7 @@ public class aiInfoCmd extends AbstractDevCmd {
if (mob.isPlayerGuard() == true) {
if (mob.agentType.equals(Enum.AIAgentType.GUARDMINION))
if (mob.agentType.equals(mbEnums.AIAgentType.GUARDMINION))
contractID = mob.guardCaptain.contract.getContractID();
else
contractID = mob.contract.getContractID();
@@ -75,7 +75,7 @@ public class aiInfoCmd extends AbstractDevCmd {
if (contractID != 0) {
if (mob.agentType.equals(Enum.AIAgentType.GUARDMINION)) {
if (mob.agentType.equals(mbEnums.AIAgentType.GUARDMINION)) {
output += "Captain Contract: " + contractID + newline;
output += "Captain UUID: " + mob.guardCaptain.getObjectUUID() + newline;
} else
@@ -128,7 +128,7 @@ public class aiInfoCmd extends AbstractDevCmd {
if (mob.contract != null)
contractEntries = new ArrayList<>(PowersManager.getPowersForRune(mob.contractUUID));
if (mob.agentType.equals(Enum.AIAgentType.GUARDMINION))
if (mob.agentType.equals(mbEnums.AIAgentType.GUARDMINION))
contractEntries = new ArrayList<>(PowersManager.getPowersForRune(mob.guardCaptain.contractUUID));
powerEntries.addAll(contractEntries);
@@ -1,31 +0,0 @@
// ·. · · · · .
// · ·
// · ·
//
// · · ·
// Magicbane Emulator Project © 2013 - 2022
// www.magicbane.com
package engine.exception;
public class MsgSendException extends MBServerException {
private static final long serialVersionUID = 6927044139998382254L;
public MsgSendException() {
super();
}
public MsgSendException(String arg0, Throwable arg1) {
super(arg0, arg1);
}
public MsgSendException(String arg0) {
super(arg0);
}
public MsgSendException(Throwable arg0) {
super(arg0);
}
}
@@ -1,31 +0,0 @@
// ·. · · · · .
// · ·
// · ·
//
// · · ·
// Magicbane Emulator Project © 2013 - 2022
// www.magicbane.com
package engine.exception;
public class SerializationException extends MBServerException {
private static final long serialVersionUID = 6927044139998382254L;
public SerializationException() {
super();
}
public SerializationException(String arg0, Throwable arg1) {
super(arg0, arg1);
}
public SerializationException(String arg0) {
super(arg0);
}
public SerializationException(Throwable arg0) {
super(arg0);
}
}
+131 -154
View File
@@ -9,16 +9,17 @@
package engine.gameManager;
import engine.Enum;
import engine.Enum.BuildingGroup;
import engine.Enum.GameObjectType;
import engine.InterestManagement.InterestManager;
import engine.InterestManagement.WorldGrid;
import engine.job.JobContainer;
import engine.job.JobScheduler;
import engine.jobs.UpgradeBuildingJob;
import engine.loot.WorkOrder;
import engine.math.Bounds;
import engine.math.Vector3fImmutable;
import engine.mbEnums;
import engine.mbEnums.BuildingGroup;
import engine.mbEnums.GameObjectType;
import engine.net.client.msg.ErrorPopupMsg;
import engine.objects.*;
import engine.server.MBServerStatics;
@@ -49,8 +50,7 @@ public enum BuildingManager {
// Some meshes might not have slot locations assigned.
if (slotLocations == null ||
slotLocations.isEmpty())
if (slotLocations == null || slotLocations.isEmpty())
return -1;
int numOfSlots = _slotLocations.get(building.meshUUID).size();
@@ -69,17 +69,15 @@ public enum BuildingManager {
// Some meshes might not have slot locations assigned.
if (slotLocations == null ||
slotLocations.isEmpty())
if (slotLocations == null || slotLocations.isEmpty())
return -1;
int numOfSlots = _slotLocations.get(building.meshUUID).size();
for (int i = numOfSlots; i > 0; i--) {
for (int i = numOfSlots; i > 0; i--)
if (!building.getHirelings().containsValue(i))
return i;
}
return -1;
}
@@ -92,9 +90,8 @@ public enum BuildingManager {
buildingLocation = _slotLocations.get(building.meshUUID).get(slot - 1); // array index
if (buildingLocation == null) {
if (buildingLocation == null)
Logger.error("Invalid slot for building: " + building.getObjectUUID());
}
return buildingLocation;
}
@@ -107,73 +104,67 @@ public enum BuildingManager {
if (building == null)
return false;
//cannot access destroyed buildings
if (building.getRank() == -1)
return false;
if (IsOwner(building, player))
return true;
//individual friend.
if (building.getFriends() != null && building.getFriends().get(player.getObjectUUID()) != null)
return true;
//Admins can access stuff
//admin characters can always access buildings
if (player.isCSR())
return true;
//Guild stuff
if (building.getGuild().isGuildLeader(player.getObjectUUID()))
return true;
if (building.getFriends().get(player.getGuild().getObjectUUID()) != null
&& building.getFriends().get(player.getGuild().getObjectUUID()).friendType == 8)
return true;
if (building.getFriends().get(player.getGuild().getObjectUUID()) != null
&& building.getFriends().get(player.getGuild().getObjectUUID()).friendType == 9
&& GuildStatusController.isInnerCouncil(player.getGuildStatus()))
return true;
if (Guild.sameGuild(building.getGuild(), player.getGuild()) && GuildStatusController.isInnerCouncil(player.getGuildStatus()))
return true;
if (Guild.sameGuild(building.getGuild(), player.getGuild()) && GuildStatusController.isGuildLeader(player.getGuildStatus()))
return true;
return false;
//TODO test friends list once added
//does not meet above criteria. Cannot access.
}
public static boolean playerCanManageNotFriends(PlayerCharacter player, Building building) {
//Player Can only Control Building if player is in Same Guild as Building and is higher rank than IC.
if (player == null)
return false;
if (building == null)
return false;
if (building.getRank() == -1)
return false;
//owner can always access their own building
if (IsOwner(building, player))
return true;
//Somehow guild leader check fails? lets check if Player is true Guild GL.
if (building.getGuild() != null && building.getGuild().isGuildLeader(player.getObjectUUID()))
return true;
if (GuildStatusController.isGuildLeader(player.getGuildStatus()) == false && GuildStatusController.isInnerCouncil(player.getGuildStatus()) == false)
return false;
//check for default IC access if building belongs to same guild
if(player.guild.equals(building.getGuild())) {
if (building.getBlueprint() != null && building.getBlueprint().getBuildingGroup() != null) {
switch (building.getBlueprint().getBuildingGroup()) {
case TOL:
case BARRACK:
case SPIRE:
case SHRINE:
case BANESTONE:
case MINE:
case WAREHOUSE:
case BULWARK:
case SIEGETENT:
if (GuildStatusController.isInnerCouncil(player.getGuildStatus()))
return true;
if (GuildStatusController.isGuildLeader(player.getGuildStatus()))
return true;
break;
}
}
}
//check against friends list entries if any present
if (building.getFriends() != null) {
//check individuals
if (building.getFriends().get(player.getObjectUUID()) != null)
return true;
if (building.getFriends().get(player.guild.objectUUID) != null) {
//check friend type for guild related access
switch (building.getFriends().get(player.guild.objectUUID).friendType) {
case 8: //full member
if (GuildStatusController.isFullMember(player.getGuildStatus()))
return true;
break;
case 9: //Inner Council
if (GuildStatusController.isInnerCouncil(player.getGuildStatus()))
return true;
if (GuildStatusController.isGuildLeader(player.getGuildStatus()))
return true;
break;
}
}
}
//did not meet access grant criteria, deny access
return false;
}
public static synchronized boolean lootBuilding(PlayerCharacter player, Building building) {
@@ -213,7 +204,7 @@ public enum BuildingManager {
if (!player.charItemManager.hasRoomInventory(template.item_wt))
return false;
if (!Item.MakeItemForPlayer(template.template_id, player, amount))
if (!ItemManager.MakeItemForPlayer(template.template_id, player, amount))
return false;
shrine.setFavors(0);
@@ -230,7 +221,7 @@ public enum BuildingManager {
if (warehouse == null)
return false;
for (Enum.ResourceType resourceType : EnumSet.allOf(Enum.ResourceType.class)) {
for (mbEnums.ResourceType resourceType : EnumSet.allOf(mbEnums.ResourceType.class)) {
if (!player.charItemManager.hasRoomInventory(resourceType.template.item_wt)) {
ChatManager.chatSystemInfo(player, "You can not carry any more of that item.");
@@ -274,9 +265,7 @@ public enum BuildingManager {
// Submit upgrade job for future date or current instant
if (building.getUpgradeDateTime().isAfter(LocalDateTime.now())) {
JobContainer jc = JobScheduler.getInstance().scheduleJob(new UpgradeBuildingJob(building),
building.getUpgradeDateTime().atZone(ZoneId.systemDefault())
.toInstant().toEpochMilli());
JobContainer jc = JobScheduler.getInstance().scheduleJob(new UpgradeBuildingJob(building), building.getUpgradeDateTime().atZone(ZoneId.systemDefault()).toInstant().toEpochMilli());
} else
JobScheduler.getInstance().scheduleJob(new UpgradeBuildingJob(building), 0);
}
@@ -323,7 +312,7 @@ public enum BuildingManager {
// Clear minions from database if a guard captain
if (guardCaptain.agentType.equals(Enum.AIAgentType.GUARDCAPTAIN))
if (guardCaptain.agentType.equals(mbEnums.AIAgentType.GUARDCAPTAIN))
DbManager.MobQueries.REMOVE_ALL_MINIONS(hireling.getObjectUUID());
}
@@ -335,8 +324,35 @@ public enum BuildingManager {
WorldGrid.RemoveWorldObject(minionMob);
WorldGrid.unloadObject(minionMob);
if (minionMob.getParentZone() != null)
minionMob.getParentZone().zoneMobSet.remove(minionMob);
if (minionMob.parentZone != null)
minionMob.parentZone.zoneMobSet.remove(minionMob);
}
// Clear all workorders for this hireling
if (hireling.getObjectType().equals(GameObjectType.NPC)) {
NPC hirelingNPC = (NPC) hireling;
if (ForgeManager.vendorWorkOrderLookup.get(hirelingNPC) != null)
for (WorkOrder workOrder : ForgeManager.vendorWorkOrderLookup.get(hirelingNPC)) {
workOrder.runCompleted.set(true);
workOrder.vendor = null;
// Remove any cooking items from collections
// to ensure we don't leak memory.
for (Item item : workOrder.cooking) {
DbManager.removeFromCache(item);
ForgeManager.itemWorkOrderLookup.remove(item);
}
DbManager.WarehouseQueries.DELETE_WORKORDER(workOrder);
}
// Finally remove the NPC from ForgeManager
ForgeManager.vendorWorkOrderLookup.remove(hirelingNPC);
}
// Remove hireling from building
@@ -349,10 +365,9 @@ public enum BuildingManager {
Mob hirelingMob = (Mob) hireling;
if (hirelingMob.getParentZone() != null)
if (hirelingMob.getParentZone().zoneMobSet.contains(hirelingMob))
hirelingMob.getParentZone().zoneMobSet.remove(hireling);
if (hirelingMob.parentZone != null)
if (hirelingMob.parentZone.zoneMobSet.contains(hirelingMob))
hirelingMob.parentZone.zoneMobSet.remove(hireling);
}
if (hireling.getObjectType().equals(GameObjectType.NPC)) {
@@ -377,10 +392,8 @@ public enum BuildingManager {
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
@@ -392,22 +405,17 @@ public enum BuildingManager {
// Remove all hirelings for destroyed buildings
if (building.getRank() < 1) {
for (AbstractCharacter slottedNPC : building.getHirelings().keySet())
BuildingManager.removeHireling(building, slottedNPC);
return;
}
// Delete hireling if building has deranked.
for (AbstractCharacter hireling : building.getHirelings().keySet()) {
for (AbstractCharacter hireling : building.getHirelings().keySet())
if (building.getHirelings().get(hireling) > building.getBlueprint().getSlotsForRank(building.getRank()))
BuildingManager.removeHireling(building, hireling);
}
refreshHirelings(building);
}
@@ -418,7 +426,7 @@ public enum BuildingManager {
Building building;
building = (Building) DbManager.getFromCache(Enum.GameObjectType.Building, id);
building = (Building) DbManager.getFromCache(mbEnums.GameObjectType.Building, id);
if (building != null)
return building;
@@ -439,6 +447,7 @@ public enum BuildingManager {
return false;
//lets pass true if player is owner anyway.
if (building.getOwner().equals(player))
return true;
@@ -451,52 +460,22 @@ public enum BuildingManager {
if (!Guild.sameGuild(building.getGuild(), player.getGuild()))
return false;
return GuildStatusController.isGuildLeader(player.getGuildStatus()) != false || GuildStatusController.isInnerCouncil(player.getGuildStatus()) != false;
}
//This is mainly used for Rolling and gold sharing between building and warehouse.
public static int GetWithdrawAmountForRolling(Building building, int cost) {
//all funds are available to roll.
if (cost <= GetAvailableGold(building))
return cost;
// cost is more than available gold, return available gold
return GetAvailableGold(building);
}
public static int GetAvailableGold(Building building) {
if (building.getStrongboxValue() == 0)
return 0;
if (building.getStrongboxValue() < building.reserve)
return 0;
return building.getStrongboxValue() - building.reserve;
}
public static int GetOverdraft(Building building, int cost) {
int availableGold = GetWithdrawAmountForRolling(building, cost);
return cost - availableGold;
return GuildStatusController.isGuildLeader(player.getGuildStatus()) || GuildStatusController.isInnerCouncil(player.getGuildStatus());
}
public static boolean IsPlayerHostile(Building building, PlayerCharacter player) {
//Nation Members and Guild members are not hostile.
// if (building.getGuild() != null){
// if (pc.getGuild() != null)
// if (building.getGuild().getObjectUUID() == pc.getGuildUUID()
// || pc.getGuild().getNation().getObjectUUID() == building.getGuild().getNation().getObjectUUID())
// return false;
// }
if (Guild.sameNationExcludeErrant(building.getGuild(), player.getGuild()))
return false;
if(building.enforceKOS) {
if (building.getCity() != null) {
Building TOL = building.getCity().getTOL();
if (TOL != null) {
building = TOL;
}
}
}
if (!building.reverseKOS) {
Condemned condemn = building.getCondemned().get(player.getObjectUUID());
@@ -548,7 +527,7 @@ public enum BuildingManager {
String pirateName = NPCManager.getPirateName(NpcID.getMobbaseID());
NPC npc = null;
NPC npc;
npc = NPC.createNPC(pirateName, NpcID.getObjectUUID(), NpcLoc, building.getGuild(), zone, (short) rank, building);
@@ -564,7 +543,7 @@ public enum BuildingManager {
public static synchronized boolean addHireling(Building building, PlayerCharacter contractOwner, Zone zone, Contract contract, Item item) {
int rank = 1;
int rank;
if (building.getBlueprintUUID() == 0)
return false;
@@ -584,14 +563,14 @@ public enum BuildingManager {
if (NPC.ISWallArcher(contract)) {
mobile = Mob.createMob(contract.getMobbaseID(), Vector3fImmutable.ZERO, contractOwner.getGuild(), zone, building, contract, pirateName, rank, Enum.AIAgentType.GUARDWALLARCHER);
mobile = Mob.createMob(contract.getMobbaseID(), Vector3fImmutable.ZERO, contractOwner.getGuild(), zone, building, contract, pirateName, rank, mbEnums.AIAgentType.GUARDWALLARCHER);
if (mobile == null)
return false;
// Configure AI and write new mobile to disk
mobile.behaviourType = Enum.MobBehaviourType.GuardWallArcher;
mobile.behaviourType = mbEnums.MobBehaviourType.GuardWallArcher;
mobile = DbManager.MobQueries.PERSIST(mobile);
// Spawn new mobile
@@ -603,14 +582,14 @@ public enum BuildingManager {
if (NPC.ISGuardCaptain(contract.getContractID())) {
mobile = Mob.createMob(contract.getMobbaseID(), Vector3fImmutable.ZERO, contractOwner.getGuild(), zone, building, contract, pirateName, rank, Enum.AIAgentType.GUARDCAPTAIN);
mobile = Mob.createMob(contract.getMobbaseID(), Vector3fImmutable.ZERO, contractOwner.getGuild(), zone, building, contract, pirateName, rank, mbEnums.AIAgentType.GUARDCAPTAIN);
if (mobile == null)
return false;
// Configure AI and write new mobile to disk
mobile.behaviourType = Enum.MobBehaviourType.GuardCaptain;
mobile.behaviourType = mbEnums.MobBehaviourType.GuardCaptain;
mobile = DbManager.MobQueries.PERSIST(mobile);
// Spawn new mobile
@@ -623,14 +602,15 @@ public enum BuildingManager {
if (contract.getContractID() == 910) {
//guard dog
mobile = Mob.createMob(contract.getMobbaseID(), Vector3fImmutable.ZERO, contractOwner.getGuild(), zone, building, contract, pirateName, rank, Enum.AIAgentType.GUARDCAPTAIN);
mobile = Mob.createMob(contract.getMobbaseID(), Vector3fImmutable.ZERO, contractOwner.getGuild(), zone, building, contract, pirateName, rank, mbEnums.AIAgentType.GUARDCAPTAIN);
if (mobile == null)
return false;
// Configure AI and write new mobile to disk
mobile.behaviourType = Enum.MobBehaviourType.GuardCaptain;
mobile.behaviourType = mbEnums.MobBehaviourType.GuardCaptain;
mobile = DbManager.MobQueries.PERSIST(mobile);
// Spawn new mobile
@@ -682,9 +662,7 @@ public enum BuildingManager {
if (building.getOwner() == null)
return false;
return building.getOwner().getObjectUUID() == player.getObjectUUID();
}
public static float GetMissingHealth(Building building) {
@@ -696,6 +674,7 @@ public enum BuildingManager {
}
public static Regions GetRegion(Building building, float x, float y, float z) {
if (building.getBounds() == null)
return null;
@@ -703,17 +682,18 @@ public enum BuildingManager {
return null;
Regions currentRegion = null;
for (Regions region : building.getBounds().getRegions()) {
if (region.isPointInPolygon(new Vector3fImmutable(x, y, z))) {
for (Regions region : building.getBounds().getRegions()) {
if (region.isPointInPolygon(new Vector3fImmutable(x, y, z)))
if (y > (region.highLerp.y - 5))
currentRegion = region;
}
}
return currentRegion;
}
public static Regions GetRegion(Building building, int room, int level, float x, float z) {
if (building.getBounds() == null)
return null;
@@ -724,12 +704,12 @@ public enum BuildingManager {
if (region.getLevel() != level)
continue;
if (region.getRoom() != room)
continue;
if (region.isPointInPolygon(new Vector3fImmutable(x, 0, z))) {
if (region.isPointInPolygon(new Vector3fImmutable(x, 0, z)))
return region;
}
}
return null;
}
@@ -739,13 +719,12 @@ public enum BuildingManager {
Vector3fImmutable bindLoc = null;
if (building == null)
return Enum.Ruins.getRandomRuin().getLocation();
return mbEnums.Ruins.getRandomRuin().getLocation();
bindLoc = building.getLoc();
float radius = Bounds.meshBoundsCache.get(building.getMeshUUID()).radius;
if (building.getRank() == 8) {
bindLoc = building.getStuckLocation();
if (bindLoc != null)
@@ -798,7 +777,6 @@ public enum BuildingManager {
int newMeshUUID;
boolean success;
// If this building has no blueprint then set rank and exit immediatly.
if (building.blueprintUUID == 0 || building.getBlueprint() != null && building.getBlueprint().getBuildingGroup().equals(BuildingGroup.MINE)) {
@@ -810,22 +788,22 @@ public enum BuildingManager {
// Delete any upgrade jobs before doing anything else. It won't quite work
// if in a few lines we happen to delete this building.
JobContainer jc = building.getTimers().get("UPGRADE");
JobContainer jobContainer = building.getTimers().get("UPGRADE");
if (jc != null) {
if (!JobScheduler.getInstance().cancelScheduledJob(jc))
if (jobContainer != null) {
if (!JobScheduler.getInstance().cancelScheduledJob(jobContainer))
Logger.error("failed to cancel existing upgrade job.");
}
// Attempt write to database, or delete the building
// Attempt to write to database or delete the building
// if we are destroying it.
if (rank == -1)
if (rank < 0)
success = DbManager.BuildingQueries.DELETE_FROM_DATABASE(building);
else
success = DbManager.BuildingQueries.updateBuildingRank(building, rank);
if (success == false) {
if (!success) {
Logger.error("Error writing to database UUID: " + building.getObjectUUID());
return;
}
@@ -856,7 +834,7 @@ public enum BuildingManager {
// protection
if (building.rank == -1)
building.protectionState = Enum.ProtectionState.NONE;
building.protectionState = mbEnums.ProtectionState.NONE;
// update object to clients
@@ -882,7 +860,6 @@ public enum BuildingManager {
if (Bounds.collide(loc, building.getBounds()))
return building;
}
return null;
}
+26 -27
View File
@@ -9,15 +9,14 @@
package engine.gameManager;
import engine.Enum;
import engine.Enum.GameObjectType;
import engine.Enum.ModType;
import engine.Enum.SourceType;
import engine.InterestManagement.WorldGrid;
import engine.db.archive.BaneRecord;
import engine.db.archive.PvpRecord;
import engine.mbEnums;
import engine.mbEnums.GameObjectType;
import engine.mbEnums.ModType;
import engine.mbEnums.SourceType;
import engine.net.Dispatch;
import engine.net.DispatchMessage;
import engine.net.MessageDispatcher;
import engine.net.client.ClientConnection;
import engine.net.client.handlers.ClientAdminCommandMsgHandler;
@@ -79,7 +78,7 @@ public enum ChatManager {
ArrayList<AbstractWorldObject> distroList = new ArrayList<>();
for (PlayerCharacter pc : SessionManager
.getAllActivePlayerCharacters()) {
if (pc.getAccount().status.equals(Enum.AccountStatus.BANNED) == false)
if (pc.getAccount().status.equals(mbEnums.AccountStatus.BANNED) == false)
distroList.add(pc);
}
// Send dispatch to each player
@@ -87,7 +86,7 @@ public enum ChatManager {
for (AbstractWorldObject abstractWorldObject : distroList) {
PlayerCharacter playerCharacter = (PlayerCharacter) abstractWorldObject;
Dispatch dispatch = Dispatch.borrow(playerCharacter, msg);
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
DispatchManager.dispatchMsgDispatch(dispatch, mbEnums.DispatchChannel.SECONDARY);
}
}
@@ -95,7 +94,7 @@ public enum ChatManager {
PlayerBonuses bonus = pc.getBonuses();
if (bonus != null && bonus.getBool(ModType.Silenced, SourceType.NONE)) {
if (bonus != null && bonus.getBool(ModType.Silenced, SourceType.None)) {
ChatManager.chatSayError(pc, SILENCED);
return true;
}
@@ -161,7 +160,7 @@ public enum ChatManager {
// Make the Message
ChatSayMsg chatSayMsg = new ChatSayMsg(player, text);
DispatchMessage.dispatchMsgToInterestArea(pcSender, chatSayMsg, Enum.DispatchChannel.SECONDARY, MBServerStatics.SAY_RANGE, true, true);
DispatchManager.dispatchMsgToInterestArea(pcSender, chatSayMsg, mbEnums.DispatchChannel.SECONDARY, MBServerStatics.SAY_RANGE, true, true);
}
@@ -169,9 +168,9 @@ public enum ChatManager {
ChatSystemMsg msg = new ChatSystemMsg(null, messageString);
msg.setMessageType(4);
msg.setChannel(engine.Enum.ChatChannelType.SYSTEM.getChannelID());
msg.setChannel(mbEnums.ChatChannelType.SYSTEM.getChannelID());
Dispatch dispatch = Dispatch.borrow(targetPlayer, msg);
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
DispatchManager.dispatchMsgDispatch(dispatch, mbEnums.DispatchChannel.SECONDARY);
}
/*
@@ -195,7 +194,7 @@ public enum ChatManager {
// Make the Message
ChatShoutMsg msg = new ChatShoutMsg(sender, text);
DispatchMessage.dispatchMsgToInterestArea(pcSender, msg, engine.Enum.DispatchChannel.SECONDARY, MBServerStatics.SHOUT_RANGE, true, true);
DispatchManager.dispatchMsgToInterestArea(pcSender, msg, mbEnums.DispatchChannel.SECONDARY, MBServerStatics.SHOUT_RANGE, true, true);
}
@@ -217,7 +216,7 @@ public enum ChatManager {
// Make the Message
ChatGlobalMsg msg = new ChatGlobalMsg(sender, text);
DispatchMessage.dispatchMsgToAll(sender, msg, true);
DispatchManager.dispatchMsgToAll(sender, msg, true);
}
@@ -284,13 +283,13 @@ public enum ChatManager {
// Send dispatch to each player
Dispatch dispatch = Dispatch.borrow(pcRecip, chatTellMsg);
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
DispatchManager.dispatchMsgDispatch(dispatch, mbEnums.DispatchChannel.SECONDARY);
}
// Also send /tell to sender
if (pcSender != null) {
Dispatch dispatch = Dispatch.borrow(pcSender, chatTellMsg);
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
DispatchManager.dispatchMsgDispatch(dispatch, mbEnums.DispatchChannel.SECONDARY);
}
} else
@@ -339,17 +338,17 @@ public enum ChatManager {
chatGuildMsg.setSourceID(sender.getObjectUUID());
chatGuildMsg.setSourceName(sender.getFirstName());
chatGuildMsg.setUnknown03(WorldServer.worldMapID); // Server ID
chatGuildMsg.setUnknown04(sender.getGuild() != null ? sender.getGuild()
.getCharter() : 0); // Charter?
Guild guild1 = sender.getGuild();
chatGuildMsg.setUnknown04(sender.getGuild() != null ? guild1.charter.ordinal() : 0); // Charter?
chatGuildMsg.setUnknown05(GuildStatusController.getTitle(sender.getGuildStatus())); // Title?
chatGuildMsg.setUnknown06(sender.race.getRaceType().getCharacterSex().equals(Enum.CharacterSex.MALE) ? 1 : 2); // isMale?, seen 1 and 2
chatGuildMsg.setUnknown06(sender.race.getRaceType().getCharacterSex().equals(mbEnums.CharacterSex.MALE) ? 1 : 2); // isMale?, seen 1 and 2
// Send dispatch to each player
for (AbstractWorldObject abstractWorldObject : distroList) {
PlayerCharacter playerCharacter = (PlayerCharacter) abstractWorldObject;
Dispatch dispatch = Dispatch.borrow(playerCharacter, chatGuildMsg);
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
DispatchManager.dispatchMsgDispatch(dispatch, mbEnums.DispatchChannel.SECONDARY);
}
}
@@ -404,7 +403,7 @@ public enum ChatManager {
for (AbstractWorldObject abstractWorldObject : distroList) {
PlayerCharacter playerCharacter = (PlayerCharacter) abstractWorldObject;
Dispatch dispatch = Dispatch.borrow(playerCharacter, chatICMsg);
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
DispatchManager.dispatchMsgDispatch(dispatch, mbEnums.DispatchChannel.SECONDARY);
}
}
@@ -463,7 +462,7 @@ public enum ChatManager {
for (AbstractWorldObject abstractWorldObject : distroList) {
PlayerCharacter playerCharacter = (PlayerCharacter) abstractWorldObject;
Dispatch dispatch = Dispatch.borrow(playerCharacter, chatGroupMsg);
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
DispatchManager.dispatchMsgDispatch(dispatch, mbEnums.DispatchChannel.SECONDARY);
}
}
@@ -490,14 +489,14 @@ public enum ChatManager {
msg.setName(sender.getFirstName());
msg.setGuildTitle(GuildStatusController.getTitle(sender.getGuildStatus()));
msg.setGuildUUID(guild.getObjectUUID());
msg.setCharter(guild.getCharter());
msg.setCharter(guild.charter.ordinal());
// Send dispatch to each player
for (AbstractWorldObject abstractWorldObject : distroList) {
PlayerCharacter playerCharacter = (PlayerCharacter) abstractWorldObject;
Dispatch dispatch = Dispatch.borrow(playerCharacter, msg);
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
DispatchManager.dispatchMsgDispatch(dispatch, mbEnums.DispatchChannel.SECONDARY);
}
}
@@ -536,7 +535,7 @@ public enum ChatManager {
if (item != null) //Steal
if (success) {
String name = "";
if (item.template.item_type.equals(Enum.ItemType.GOLD))
if (item.template.item_type.equals(mbEnums.ItemType.GOLD))
name = amount + " gold ";
else {
String vowels = "aeiou";
@@ -733,7 +732,7 @@ public enum ChatManager {
public static void chatPVP(String text) {
// Create message
ChatPvPMsg msg = new ChatPvPMsg(null, text);
DispatchMessage.dispatchMsgToAll(msg);
DispatchManager.dispatchMsgToAll(msg);
}
public static ChatSystemMsg CombatInfo(AbstractWorldObject source, AbstractWorldObject target) {
@@ -844,7 +843,7 @@ public enum ChatManager {
for (AbstractWorldObject abstractWorldObject : distroList) {
PlayerCharacter playerCharacter = (PlayerCharacter) abstractWorldObject;
Dispatch dispatch = Dispatch.borrow(playerCharacter, chatSystemMsg);
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
DispatchManager.dispatchMsgDispatch(dispatch, mbEnums.DispatchChannel.SECONDARY);
}
}
@@ -993,7 +992,7 @@ public enum ChatManager {
chatSystemMsg.setChannel(channel);
Dispatch dispatch = Dispatch.borrow(playerCharacter, chatSystemMsg);
DispatchMessage.dispatchMsgDispatch(dispatch, Enum.DispatchChannel.SECONDARY);
DispatchManager.dispatchMsgDispatch(dispatch, mbEnums.DispatchChannel.SECONDARY);
}
+515 -349
View File
@@ -1,27 +1,52 @@
// ·. · · · · .
// · ·
// · ·
//
// · · ·
// Magicbane Emulator Project © 2013 - 2022
// www.magicbane.com
package engine.gameManager;
import engine.Enum;
import engine.job.JobContainer;
import engine.job.JobScheduler;
import engine.jobs.AttackJob;
import engine.jobs.DeferredPowerJob;
import engine.net.DispatchMessage;
import engine.mbEnums;
import engine.net.client.ClientConnection;
import engine.net.client.msg.TargetedActionMsg;
import engine.net.client.msg.UpdateStateMsg;
import engine.objects.*;
import engine.powers.DamageShield;
import engine.powers.effectmodifiers.AbstractEffectModifier;
import engine.powers.effectmodifiers.WeaponProcEffectModifier;
import engine.server.MBServerStatics;
import org.pmw.tinylog.Logger;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.util.EnumSet;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ThreadLocalRandom;
import static java.lang.Math.pow;
public enum CombatManager {
// MB Dev notes:
// Class implements all combat mechanics for Magicbane.
//
// Combat initiates in "combatCycle" to determine which hands will be swung, and attack is processed based on that.
// Handles all combat for AbstractCharacter including player characters and mobiles.
// Controls toggling of combat and sit/stand for all AbstractCharacters
//
//
COMBAT_MANAGER;
public static final int COMBAT_BLOCK_ANIMATION = 298;
public static final int COMBAT_PARRY_ANIMATION = 299;
public static final int COMBAT_DODGE_ANIMATION = 300;
public static void combatCycle(AbstractCharacter attacker, AbstractWorldObject target) {
@@ -30,55 +55,83 @@ public enum CombatManager {
if (attacker == null || target == null || !attacker.isAlive() || !target.isAlive())
return;
if (attacker.getObjectType().equals(mbEnums.GameObjectType.Mob))
if (((Mob) attacker).nextAttackTime > System.currentTimeMillis())
return;
switch (target.getObjectType()) {
case Building:
if (((Building) target).isVulnerable() == false)
if (!((Building) target).isVulnerable())
return;
break;
case PlayerCharacter:
case Mob:
PlayerBonuses bonuses = ((AbstractCharacter) target).getBonuses();
if (bonuses != null && bonuses.getBool(Enum.ModType.ImmuneToAttack, Enum.SourceType.NONE))
if (bonuses != null && bonuses.getBool(mbEnums.ModType.ImmuneToAttack, mbEnums.SourceType.None))
return;
break;
case NPC:
return;
}
Item mainWeapon = attacker.charItemManager.getEquipped().get(Enum.EquipSlotType.RHELD);
Item offWeapon = attacker.charItemManager.getEquipped().get(Enum.EquipSlotType.LHELD);
Item mainWeapon = attacker.charItemManager.getEquipped().get(mbEnums.EquipSlotType.RHELD);
Item offWeapon = attacker.charItemManager.getEquipped().get(mbEnums.EquipSlotType.LHELD);
if (mainWeapon == null && offWeapon == null) {
//no weapons equipped, punch with both fists
processAttack(attacker, target, Enum.EquipSlotType.RHELD);
processAttack(attacker, target, Enum.EquipSlotType.LHELD);
} else if (mainWeapon == null && offWeapon != null && offWeapon.template.item_skill_required.containsKey("Block")) {
processAttack(attacker, target, mbEnums.EquipSlotType.RHELD);
if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter))
processAttack(attacker, target, mbEnums.EquipSlotType.LHELD);
return;
}
if (mainWeapon != null && offWeapon == null) {
//swing right hand only
processAttack(attacker, target, mbEnums.EquipSlotType.RHELD);
return;
}
if (mainWeapon == null && offWeapon != null && !offWeapon.template.item_skill_used.equals("Block")) {
//swing left hand only
processAttack(attacker, target, mbEnums.EquipSlotType.LHELD);
return;
}
if (mainWeapon == null && offWeapon != null && offWeapon.template.item_skill_used.equals("Block")) {
//no weapon equipped with a shield, punch with one hand
processAttack(attacker, target, Enum.EquipSlotType.RHELD);
} else if (mainWeapon != null && offWeapon != null && offWeapon.template.item_skill_required.containsKey("Block")) {
processAttack(attacker, target, mbEnums.EquipSlotType.RHELD);
return;
}
if (mainWeapon != null && offWeapon != null && offWeapon.template.item_skill_used.equals("Block")) {
//one weapon equipped with a shield, swing with one hand
processAttack(attacker, target, Enum.EquipSlotType.RHELD);
} else if (mainWeapon != null && offWeapon != null && offWeapon.template.item_skill_required.containsKey("Block") == false) {
processAttack(attacker, target, mbEnums.EquipSlotType.RHELD);
return;
}
if (mainWeapon != null && offWeapon != null && !offWeapon.template.item_skill_used.equals("Block")) {
//two weapons equipped, swing both hands
processAttack(attacker, target, Enum.EquipSlotType.RHELD);
processAttack(attacker, target, Enum.EquipSlotType.LHELD);
} else if (mainWeapon == null && offWeapon != null && offWeapon.template.item_skill_required.containsKey("Block") == false) {
//swing left hand only
processAttack(attacker, target, Enum.EquipSlotType.LHELD);
} else if (mainWeapon != null && offWeapon == null) {
//swing left hand only
processAttack(attacker, target, Enum.EquipSlotType.RHELD);
processAttack(attacker, target, mbEnums.EquipSlotType.RHELD);
if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter))
processAttack(attacker, target, mbEnums.EquipSlotType.LHELD);
}
}
public static void processAttack(AbstractCharacter attacker, AbstractWorldObject target, Enum.EquipSlotType slot) {
public static void processAttack(AbstractCharacter attacker, AbstractWorldObject target, mbEnums.EquipSlotType slot) {
// heck if character can even attack yet
if (attacker.getTimestamps().containsKey("Attack" + slot.name()))
if (System.currentTimeMillis() < attacker.getTimestamps().get("Attack" + slot.name()))
if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)) {
if (!attacker.isCombat())
return;
//check if this slot is on attack timer, if timer has passed clear it, else early exit
if (attacker.getTimers() != null && attacker.getTimers().containsKey("Attack" + slot.name()))
if (attacker.getTimers().get("Attack" + slot.name()).timeToExecutionLeft() <= 0)
attacker.getTimers().remove("Attack" + slot.name());
else
return;
}
// check if character is in range to attack target
PlayerBonuses bonus = attacker.getBonuses();
@@ -90,259 +143,346 @@ public enum CombatManager {
if (weapon != null) {
if (bonus != null)
rangeMod += bonus.getFloatPercentAll(Enum.ModType.WeaponRange, Enum.SourceType.NONE);
rangeMod += bonus.getFloatPercentAll(mbEnums.ModType.WeaponRange, mbEnums.SourceType.None);
attackRange = weapon.template.item_weapon_max_range * rangeMod;
attackRange += weapon.template.item_weapon_max_range * rangeMod;
}
if (attacker.getObjectType().equals(Enum.GameObjectType.Mob))
if (attacker.getObjectType().equals(mbEnums.GameObjectType.Mob))
if (((Mob) attacker).isSiege())
attackRange = 300;
float distanceSquared = attacker.loc.distanceSquared(target.loc);
if (distanceSquared > attackRange * attackRange)
return;
// take stamina away from attacker
if (weapon != null) {
float stam = weapon.template.item_wt / 3f;
stam = (stam < 1) ? 1 : stam;
attacker.modifyStamina(-(stam), attacker, true);
} else
attacker.modifyStamina(-0.5f, attacker, true);
//cancel things that are cancelled by an attack
attacker.cancelOnAttackSwing();
//declare relevant variables
int min = attacker.minDamageHandOne;
int max = attacker.maxDamageHandOne;
int atr = attacker.atrHandOne;
//get the proper stats based on which slot is attacking
if (slot == Enum.EquipSlotType.LHELD) {
min = attacker.minDamageHandTwo;
max = attacker.maxDamageHandTwo;
atr = attacker.atrHandTwo;
}
int def = 0;
if (AbstractCharacter.IsAbstractCharacter(target))
def = ((AbstractCharacter) target).defenseRating;
//calculate hit chance based off ATR and DEF
int hitChance;
if(def == 0)
def = 1;
float dif = atr / def;
if (dif <= 0.8f)
hitChance = 4;
else
hitChance = ((int) (450 * (dif - 0.8f)) + 4);
if (target.getObjectType() == Enum.GameObjectType.Building)
hitChance = 100;
int passiveAnim = getSwingAnimation(null, null, slot.equals(Enum.EquipSlotType.RHELD));
if(attacker.charItemManager.getEquipped().get(slot) != null){
passiveAnim = getSwingAnimation(attacker.charItemManager.getEquipped().get(slot).template, null, true);
}
if (ThreadLocalRandom.current().nextInt(100) > hitChance) {
TargetedActionMsg msg = new TargetedActionMsg(attacker, target, 0f, passiveAnim);
if (target.getObjectType() == Enum.GameObjectType.PlayerCharacter)
DispatchMessage.dispatchMsgToInterestArea(target, msg, Enum.DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
else
DispatchMessage.sendToAllInRange(attacker, msg);
return;
}
//calculate passive chances only if target is AbstractCharacter
if (EnumSet.of(Enum.GameObjectType.PlayerCharacter, Enum.GameObjectType.NPC, Enum.GameObjectType.Mob).contains(target.getObjectType())) {
Enum.PassiveType passiveType = Enum.PassiveType.None;
int hitRoll = ThreadLocalRandom.current().nextInt(100);
float dodgeChance = ((AbstractCharacter) target).getPassiveChance("Dodge", attacker.getLevel(), true);
float blockChance = ((AbstractCharacter) target).getPassiveChance("Block", attacker.getLevel(), true);
float parryChance = ((AbstractCharacter) target).getPassiveChance("Parry", attacker.getLevel(), true);
// Passive chance clamped at 75
dodgeChance = Math.max(0, Math.min(75, dodgeChance));
blockChance = Math.max(0, Math.min(75, blockChance));
parryChance = Math.max(0, Math.min(75, parryChance));
if (hitRoll < dodgeChance)
passiveType = Enum.PassiveType.Dodge;
else if (hitRoll < blockChance)
passiveType = Enum.PassiveType.Block;
else if (hitRoll < parryChance)
passiveType = Enum.PassiveType.Parry;
if (passiveType.equals(Enum.PassiveType.None) == false) {
TargetedActionMsg msg = new TargetedActionMsg(attacker, passiveAnim, target, passiveType.value);
if (target.getObjectType() == Enum.GameObjectType.PlayerCharacter)
DispatchMessage.dispatchMsgToInterestArea(target, msg, Enum.DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
else
DispatchMessage.sendToAllInRange(attacker, msg);
return;
}
}
//calculate the base damage
int damage = ThreadLocalRandom.current().nextInt(min, max + 1);
if (damage == 0)
return;
//get the damage type
Enum.SourceType damageType;
if (attacker.charItemManager.getEquipped().get(slot) == null) {
damageType = Enum.SourceType.CRUSHING;
if (attacker.getObjectType().equals(Enum.GameObjectType.Mob))
if (((Mob) attacker).isSiege())
damageType = Enum.SourceType.SIEGE;
} else {
damageType = (Enum.SourceType) attacker.charItemManager.getEquipped().get(slot).template.item_weapon_damage.keySet().toArray()[0];
}
//get resists
Resists resists;
if (AbstractCharacter.IsAbstractCharacter(target) == false)
resists = ((Building) target).getResists(); //this is a building
else
resists = ((AbstractCharacter) target).getResists(); //this is a character
boolean inRange = false;
if (AbstractCharacter.IsAbstractCharacter(target)) {
AbstractCharacter absTarget = (AbstractCharacter) target;
attackRange += ((AbstractCharacter) target).calcHitBox();
} else {
//check damage shields
}
PlayerBonuses bonuses = absTarget.getBonuses();
if (attackRange > 15 && attacker.isMoving()) {
//cannot shoot bow while moving;
return;
}
if (bonuses != null) {
ConcurrentHashMap<AbstractEffectModifier, DamageShield> damageShields = bonuses.getDamageShields();
float total = 0;
for (DamageShield ds : damageShields.values()) {
//get amount to damage back
float amount;
if (ds.usePercent())
amount = damage * ds.getAmount() / 100;
else
amount = ds.getAmount();
//get resisted damage for damagetype
if (resists != null)
amount = resists.getResistedDamage(absTarget, attacker, ds.getDamageType(), amount, 0);
total += amount;
switch (target.getObjectType()) {
case PlayerCharacter:
attackRange += ((PlayerCharacter) target).getCharacterHeight() * 0.5f;
if (distanceSquared <= attackRange * attackRange)
inRange = true;
break;
case Mob:
attackRange += ((AbstractCharacter) target).calcHitBox();
if (distanceSquared <= attackRange * attackRange)
inRange = true;
break;
case Building:
if (attackRange > 15) {
float rangeSquared = (attackRange + target.getBounds().getHalfExtents().x) * (attackRange + target.getBounds().getHalfExtents().x);
//float distanceSquared = attacker.loc.distanceSquared(target.loc);
if (distanceSquared < rangeSquared) {
inRange = true;
break;
}
} else {
float locX = target.loc.x - target.getBounds().getHalfExtents().x;
float locZ = target.loc.z - target.getBounds().getHalfExtents().y;
float sizeX = (target.getBounds().getHalfExtents().x + attackRange) * 2;
float sizeZ = (target.getBounds().getHalfExtents().y + attackRange) * 2;
Rectangle2D.Float rect = new Rectangle2D.Float(locX, locZ, sizeX, sizeZ);
if (rect.contains(new Point2D.Float(attacker.loc.x, attacker.loc.z)))
inRange = true;
break;
}
if (total > 0) {
//apply Damage back
attacker.modifyHealth(-total, absTarget, true);
TargetedActionMsg cmm = new TargetedActionMsg(attacker, attacker, total, 0);
DispatchMessage.sendToAllInRange(target, cmm);
}
}
if (resists != null) {
//check for damage type immunities
if (resists.immuneTo(damageType))
return;
//calculate resisted damage including fortitude
damage = (int) resists.getResistedDamage(attacker, (AbstractCharacter) target, damageType, damage, 0);
}
}
//remove damage from target health
if (damage > 0) {
if (AbstractCharacter.IsAbstractCharacter(target))
((AbstractCharacter) target).modifyHealth(-damage, attacker, true);
else
((Building) target).setCurrentHitPoints(target.getCurrentHitpoints() - damage);
int attackAnim = getSwingAnimation(null,null,slot.equals(Enum.EquipSlotType.RHELD));
if (attacker.charItemManager.getEquipped().get(slot) != null) {
attackAnim = getSwingAnimation(attacker.charItemManager.getEquipped().get(slot).template,null,slot.equals(Enum.EquipSlotType.RHELD));
}
TargetedActionMsg cmm = new TargetedActionMsg(attacker, target, (float) damage, attackAnim);
DispatchMessage.sendToAllInRange(target, cmm);
}
DeferredPowerJob dpj = null;
if (attacker.getObjectType().equals(Enum.GameObjectType.PlayerCharacter)) {
dpj = ((PlayerCharacter) attacker).getWeaponPower();
if (dpj != null) {
dpj.attack(target, attackRange);
if (dpj.getPower() != null && (dpj.getPowerToken() == -1851459567 || dpj.getPowerToken() == -1851489518))
((PlayerCharacter) attacker).setWeaponPower(dpj);
}
}
//calculate next allowed attack and update the timestamp
long delay = 20 * 100;
//get delay for the auto attack job
long delay = 5000;
if (weapon != null) {
int wepSpeed = (int) (weapon.template.item_weapon_wepspeed);
float wepSpeed = (int) (weapon.template.item_weapon_wepspeed);
if (weapon.getBonusPercent(Enum.ModType.WeaponSpeed, Enum.SourceType.NONE) != 0f) //add weapon speed bonus
wepSpeed *= (1 + weapon.getBonus(Enum.ModType.WeaponSpeed, Enum.SourceType.NONE));
if (weapon.getBonusPercent(mbEnums.ModType.WeaponSpeed, mbEnums.SourceType.None) != 0f) //add weapon speed bonus
wepSpeed *= (1 + weapon.getBonus(mbEnums.ModType.WeaponSpeed, mbEnums.SourceType.None));
if (attacker.getBonuses() != null && attacker.getBonuses().getFloatPercentAll(Enum.ModType.AttackDelay, Enum.SourceType.NONE) != 0f) //add effects speed bonus
wepSpeed *= (1 + attacker.getBonuses().getFloatPercentAll(Enum.ModType.AttackDelay, Enum.SourceType.NONE));
if (attacker.getBonuses() != null && attacker.getBonuses().getFloatPercentAll(mbEnums.ModType.AttackDelay, mbEnums.SourceType.None) != 0f) //add effects speed bonus
wepSpeed *= (1 + attacker.getBonuses().getFloatPercentAll(mbEnums.ModType.AttackDelay, mbEnums.SourceType.None));
if (wepSpeed < 10)
wepSpeed = 10; //Old was 10, but it can be reached lower with legit buffs,effects.
delay = wepSpeed * 100;
delay = (long)wepSpeed * 100L;
}
attacker.getTimestamps().put("Attack" + slot.name(), System.currentTimeMillis() + delay);
if (attacker.getObjectType().equals(mbEnums.GameObjectType.Mob))
((Mob) attacker).nextAttackTime = System.currentTimeMillis() + delay;
//handle auto attack job creation
if (inRange) {
ConcurrentHashMap<String, JobContainer> timers = attacker.getTimers();
if(attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)){
if(!attacker.getTimestamps().contains(slot.name()+"Attack")){
attacker.getTimestamps().put(slot.name()+"Attack", System.currentTimeMillis() - 1000);
} else if(System.currentTimeMillis() < attacker.getTimestamps().get(slot.name()+"Attack") + delay){
setAutoAttackJob(attacker,slot,delay);
return;
}
}
if (timers != null) {
AttackJob aj = new AttackJob(attacker, slot.ordinal(), true);
JobContainer job;
job = JobScheduler.getInstance().scheduleJob(aj, (System.currentTimeMillis() + delay)); // offset 1 millisecond so no overlap issue
timers.put("Attack" + slot, job);
} else
Logger.error("Unable to find Timers for Character " + attacker.getObjectUUID());
//handle retaliate
if (AbstractCharacter.IsAbstractCharacter(target)) {
if (((AbstractCharacter) target).combatTarget == null || !((AbstractCharacter) target).combatTarget.isAlive()) {
((AbstractCharacter) target).combatTarget = attacker;
if (target.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter) && ((AbstractCharacter) target).isCombat())
combatCycle((AbstractCharacter) target, attacker);
}
}
// take stamina away from attacker if its not a mob
if (weapon != null && !attacker.getObjectType().equals(mbEnums.GameObjectType.Mob)) {
//check if Out of Stamina
if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)) {
if (attacker.getStamina() < (weapon.template.item_wt / 3f)) {
//set auto attack job
setAutoAttackJob(attacker, slot, delay);
return;
}
}
float stam = weapon.template.item_wt / 3f;
stam = (stam < 1) ? 1 : stam;
attacker.modifyStamina(-(stam), attacker, true);
} else
attacker.modifyStamina(1, attacker, true);
//cancel things that are cancelled by an attack
attacker.cancelOnAttackSwing();
//declare relevant variables
int min = attacker.minDamageHandOne;
int max = attacker.maxDamageHandOne;
int atr = attacker.atrHandOne;
//get the proper stats based on which slot is attacking
if (slot == mbEnums.EquipSlotType.LHELD) {
min = attacker.minDamageHandTwo;
max = attacker.maxDamageHandTwo;
atr = attacker.atrHandTwo;
}
//apply weapon powers before early exit for miss or passives
DeferredPowerJob dpj = null;
if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)) {
dpj = ((PlayerCharacter) attacker).getWeaponPower();
if (dpj != null) {
dpj.attack(target, attackRange);
if (dpj.getPower() != null && (dpj.getPowerToken() == -1851459567 || dpj.getPowerToken() == -1851489518))
((PlayerCharacter) attacker).setWeaponPower(dpj);
}
}
int def = 0;
if (AbstractCharacter.IsAbstractCharacter(target))
def = ((AbstractCharacter) target).defenseRating;
//calculate hit chance based off ATR and DEF
int hitChance;
if (def == 0)
def = 1;
float dif = atr * 1f / def;
if (dif <= 0.8f)
hitChance = 4;
else
hitChance = ((int) (450 * (dif - 0.8f)) + 4);
if (target.getObjectType() == mbEnums.GameObjectType.Building)
hitChance = 100;
int passiveAnim = getPassiveAnimation(mbEnums.PassiveType.None); // checking for a miss due to ATR vs Def
if (ThreadLocalRandom.current().nextInt(100) > hitChance) {
TargetedActionMsg msg = new TargetedActionMsg(attacker, target, 0f, passiveAnim);
if (target.getObjectType() == mbEnums.GameObjectType.PlayerCharacter)
DispatchManager.dispatchMsgToInterestArea(target, msg, mbEnums.DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
else
DispatchManager.sendToAllInRange(attacker, msg);
//we need to send the animation even if the attacker misses
TargetedActionMsg cmm = new TargetedActionMsg(attacker, target, (float) 0, getSwingAnimation(weapon.template, null, slot));
DispatchManager.sendToAllInRange(target, cmm);
//set auto attack job
setAutoAttackJob(attacker, slot, delay);
return;
}
//calculate passive chances only if target is AbstractCharacter
if (EnumSet.of(mbEnums.GameObjectType.PlayerCharacter, mbEnums.GameObjectType.NPC, mbEnums.GameObjectType.Mob).contains(target.getObjectType())) {
mbEnums.PassiveType passiveType = mbEnums.PassiveType.None;
int hitRoll = ThreadLocalRandom.current().nextInt(100);
float dodgeChance = ((AbstractCharacter) target).getPassiveChance("Dodge", attacker.getLevel(), true);
float blockChance = ((AbstractCharacter) target).getPassiveChance("Block", attacker.getLevel(), true);
float parryChance = ((AbstractCharacter) target).getPassiveChance("Parry", attacker.getLevel(), true);
// Passive chance clamped at 75
dodgeChance = Math.max(0, Math.min(75, dodgeChance));
blockChance = Math.max(0, Math.min(75, blockChance));
parryChance = Math.max(0, Math.min(75, parryChance));
if (hitRoll < dodgeChance)
passiveType = mbEnums.PassiveType.Dodge;
else if (hitRoll < blockChance)
passiveType = mbEnums.PassiveType.Block;
else if (hitRoll < parryChance)
passiveType = mbEnums.PassiveType.Parry;
if (!passiveType.equals(mbEnums.PassiveType.None)) {
passiveAnim = getPassiveAnimation(passiveType);
TargetedActionMsg msg = new TargetedActionMsg(attacker, passiveAnim, target, passiveType.value);
if (target.getObjectType() == mbEnums.GameObjectType.PlayerCharacter)
DispatchManager.dispatchMsgToInterestArea(target, msg, mbEnums.DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
//we need to send the animation even if the attacker misses
TargetedActionMsg cmm = new TargetedActionMsg(attacker, target, (float) 0, getSwingAnimation(weapon.template, null, slot));
DispatchManager.sendToAllInRange(target, cmm);
//set auto attack job
setAutoAttackJob(attacker, slot, delay);
return;
}
}
//check for proccing
checkForProc(attacker,target,weapon);
//calculate the base damage
int damage = ThreadLocalRandom.current().nextInt(min, max + 1);
if (damage == 0) {
//set auto attack job
setAutoAttackJob(attacker, slot, delay);
return;
}
if (attacker.getObjectType().equals(mbEnums.GameObjectType.Mob) && ((Mob) attacker).isPet())
calculatePetDamage(attacker);
//get the damage type
mbEnums.DamageType damageType;
if (attacker.charItemManager.getEquipped().get(slot) == null) {
damageType = mbEnums.DamageType.CRUSHING;
if (attacker.getObjectType().equals(mbEnums.GameObjectType.Mob))
if (((Mob) attacker).isSiege())
damageType = mbEnums.DamageType.SIEGE;
} else {
damageType = (mbEnums.DamageType) attacker.charItemManager.getEquipped().get(slot).template.item_weapon_damage.keySet().toArray()[0];
}
//get resists
Resists resists;
if (!AbstractCharacter.IsAbstractCharacter(target))
resists = ((Building) target).getResists(); //this is a building
else
resists = ((AbstractCharacter) target).getResists(); //this is a character
if (AbstractCharacter.IsAbstractCharacter(target)) {
AbstractCharacter absTarget = (AbstractCharacter) target;
//check damage shields
PlayerBonuses bonuses = absTarget.getBonuses();
if (bonuses != null) {
ConcurrentHashMap<AbstractEffectModifier, DamageShield> damageShields = bonuses.getDamageShields();
float total = 0;
for (DamageShield ds : damageShields.values()) {
//get amount to damage back
float amount;
if (ds.usePercent())
amount = damage * ds.getAmount() / 100;
else
amount = ds.getAmount();
//get resisted damage for damagetype
if (resists != null)
amount = resists.getResistedDamage(absTarget, attacker, ds.getDamageType(), amount, 0);
total += amount;
}
if (total > 0) {
//apply Damage back
attacker.modifyHealth(-total, absTarget, true);
TargetedActionMsg cmm = new TargetedActionMsg(attacker, attacker, total, 0);
DispatchManager.sendToAllInRange(target, cmm);
}
}
if (resists != null) {
//check for damage type immunities
if (resists.immuneTo(damageType)) {
//set auto attack job
//we need to send the animation even if the attacker misses
TargetedActionMsg cmm = new TargetedActionMsg(attacker, target, (float) 0, getSwingAnimation(weapon.template, null, slot));
DispatchManager.sendToAllInRange(target, cmm);
setAutoAttackJob(attacker, slot, delay);
return;
}
//calculate resisted damage including fortitude
damage = (int) resists.getResistedDamage(attacker, (AbstractCharacter) target, damageType, damage, 0);
}
}
//remove damage from target health
if (damage > 0) {
if (AbstractCharacter.IsAbstractCharacter(target))
((AbstractCharacter) target).modifyHealth(-damage, attacker, true);
else
((Building) target).modifyHealth(-damage, attacker);
int attackAnim = getSwingAnimation(null, null, slot);
if (attacker.charItemManager.getEquipped().get(slot) != null) {
if (attacker.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter)) {
DeferredPowerJob weaponPower = ((PlayerCharacter) attacker).getWeaponPower();
attackAnim = getSwingAnimation(weapon.template, weaponPower, slot);
} else {
attackAnim = getSwingAnimation(weapon.template, null, slot);
}
}
TargetedActionMsg cmm = new TargetedActionMsg(attacker, target, (float) damage, attackAnim);
DispatchManager.sendToAllInRange(target, cmm);
}
}
//set auto attack job
setAutoAttackJob(attacker, slot, delay);
}
@@ -360,7 +500,7 @@ public enum CombatManager {
UpdateStateMsg rwss = new UpdateStateMsg();
rwss.setPlayer(playerCharacter);
DispatchMessage.dispatchMsgToInterestArea(playerCharacter, rwss, Enum.DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, false, false);
DispatchManager.dispatchMsgToInterestArea(playerCharacter, rwss, mbEnums.DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, false, false);
}
public static void toggleSit(boolean toggle, ClientConnection origin) {
@@ -373,7 +513,7 @@ public enum CombatManager {
playerCharacter.setSit(toggle);
UpdateStateMsg rwss = new UpdateStateMsg();
rwss.setPlayer(playerCharacter);
DispatchMessage.dispatchMsgToInterestArea(playerCharacter, rwss, Enum.DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
DispatchManager.dispatchMsgToInterestArea(playerCharacter, rwss, mbEnums.DispatchChannel.PRIMARY, MBServerStatics.CHARACTER_LOAD_RANGE, true, false);
}
@@ -387,7 +527,7 @@ public enum CombatManager {
if (attacker.equals(target))
return;
if (target.isMoving() && target.getObjectType().equals(Enum.GameObjectType.PlayerCharacter))
if (target.isMoving() && target.getObjectType().equals(mbEnums.GameObjectType.PlayerCharacter))
return;
if (!target.isAlive() || !attacker.isAlive())
@@ -401,118 +541,144 @@ public enum CombatManager {
target.setCombatTarget(attacker);
}
public static int getSwingAnimation(ItemTemplate wb, DeferredPowerJob dpj, boolean mainHand) {
int token = 0;
if (dpj != null)
token = (dpj.getPower() != null) ? dpj.getPower().getToken() : 0;
if (token == 563721004) //kick animation
return 79;
public static int getSwingAnimation(ItemTemplate wb, DeferredPowerJob dpj, mbEnums.EquipSlotType slot) {
//No weapon, return default animation
if (wb == null)
return 75;
ItemTemplate template = wb;
int token;
if (mainHand) {
if (template.weapon_attack_anim_right.size() > 0) {
if (dpj != null) {
int animation;
token = (dpj.getPower() != null) ? dpj.getPower().getToken() : 0;
int random = ThreadLocalRandom.current().nextInt(template.weapon_attack_anim_right.size());
try {
animation = template.weapon_attack_anim_right.get(random)[0];
return animation;
} catch (Exception e) {
Logger.error(e.getMessage());
return template.weapon_attack_anim_right.get(0)[0];
}
} else if (template.weapon_attack_anim_left.size() > 0) {
int animation;
int random = ThreadLocalRandom.current().nextInt(template.weapon_attack_anim_left.size());
try {
animation = template.weapon_attack_anim_left.get(random)[0];
return animation;
} catch (Exception e) {
Logger.error(e.getMessage());
return template.weapon_attack_anim_right.get(0)[0];
}
}
} else {
if (template.weapon_attack_anim_left.size() > 0) {
int animation;
int random = ThreadLocalRandom.current().nextInt(template.weapon_attack_anim_left.size());
try {
animation = template.weapon_attack_anim_left.get(random)[0];
return animation;
} catch (Exception e) {
Logger.error(e.getMessage());
return template.weapon_attack_anim_right.get(0)[0];
}
} else if (template.weapon_attack_anim_left.size() > 0) {
int animation;
int random = ThreadLocalRandom.current().nextInt(template.weapon_attack_anim_left.size());
try {
animation = template.weapon_attack_anim_left.get(random)[0];
return animation;
} catch (Exception e) {
Logger.error(e.getMessage());
return template.weapon_attack_anim_right.get(0)[0];
}
}
if (token == 563721004) //kick animation
return 79;
}
String required = template.item_skill_used;
String mastery = wb.item_skill_mastery_used;
if (required.equals("Unarmed Combat"))
//Item has no equipment slots and should not try to return an animation, return default instead
if (wb.item_eq_slots_or == null || wb.item_eq_slots_or.isEmpty()) {
return 75;
else if (required.equals("Sword")) {
}
if (ItemTemplate.isTwoHanded(template))
return 105;
else
return 98;
//declare variables
int anim;
int random;
} else if (required.equals("Staff") || required.equals("Pole Arm")) {
return 85;
} else if (required.equals("Spear")) {
return 92;
} else if (required.equals("Hammer") || required.equals("Axe")) {
if (ItemTemplate.isTwoHanded(template)) {
return 105;
} else if (mastery.equals("Throwing")) {
return 115;
//Item can only be equipped in one slot, return animation for that slot
if (wb.item_eq_slots_or.size() == 1) {
if (wb.item_eq_slots_or.iterator().next().equals(mbEnums.EquipSlotType.RHELD)) {
anim = wb.weapon_attack_anim_right.get(0)[0];
if (dpj != null) {
random = ThreadLocalRandom.current().nextInt(wb.weapon_attack_anim_right.size());
anim = wb.weapon_attack_anim_right.get(random)[0];
}
} else {
return 100;
anim = wb.weapon_attack_anim_left.get(0)[0];
if (dpj != null) {
random = ThreadLocalRandom.current().nextInt(wb.weapon_attack_anim_left.size());
anim = wb.weapon_attack_anim_left.get(random)[0];
}
}
} else if (required.equals("Dagger")) {
if (mastery.equals("Throwing")) {
return 117;
} else {
return 81;
return anim;
}
//Item can be equipped in either hand, and should have animation sets for each hand
if (slot.equals(mbEnums.EquipSlotType.RHELD)) {
anim = wb.weapon_attack_anim_right.get(0)[0];
if (dpj != null) {
random = ThreadLocalRandom.current().nextInt(wb.weapon_attack_anim_right.size());
anim = wb.weapon_attack_anim_right.get(random)[0];
}
} else if (required.equals("Crossbow")) {
return 110;
} else if (required.equals("Bow")) {
return 109;
} else if (ItemTemplate.isTwoHanded(template)) {
return 105;
} else {
return 100;
anim = wb.weapon_attack_anim_left.get(0)[0];
if (dpj != null) {
random = ThreadLocalRandom.current().nextInt(wb.weapon_attack_anim_left.size());
anim = wb.weapon_attack_anim_left.get(random)[0];
}
}
return anim;
}
public static int getPassiveAnimation(mbEnums.PassiveType passiveType) {
switch (passiveType) {
case Block:
return COMBAT_BLOCK_ANIMATION;
case Parry:
return COMBAT_PARRY_ANIMATION;
case Dodge:
return COMBAT_DODGE_ANIMATION;
default:
return 0;
}
}
public static void setAutoAttackJob(AbstractCharacter attacker, mbEnums.EquipSlotType slot, long delay) {
//calculate next allowed attack and update the timestamp
if (attacker.getTimestamps().containsKey("Attack" + slot.name()) && attacker.getTimestamps().get("Attack" + slot.name()) > System.currentTimeMillis())
return;
attacker.getTimestamps().put("Attack" + slot.name(), System.currentTimeMillis() + delay);
//handle auto attack job creation
ConcurrentHashMap<String, JobContainer> timers = attacker.getTimers();
if (timers != null) {
AttackJob aj = new AttackJob(attacker, slot.ordinal(), true);
JobContainer job;
job = JobScheduler.getInstance().scheduleJob(aj, (System.currentTimeMillis() + delay)); // offset 1 millisecond so no overlap issue
timers.put("Attack" + slot.name(), job);
} else
Logger.error("Unable to find Timers for Character " + attacker.getObjectUUID());
}
public static int calculatePetDamage(AbstractCharacter agent) {
//damage calc for pet
float range;
float damage;
float min = 40;
float max = 60;
float dmgMultiplier = 1 + agent.getBonuses().getFloatPercentAll(mbEnums.ModType.MeleeDamageModifier, mbEnums.SourceType.None);
double minDmg = getMinDmg(min, agent);
double maxDmg = getMaxDmg(max, agent);
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(double min, AbstractCharacter agent) {
int primary = agent.getStatStrCurrent();
int secondary = agent.getStatDexCurrent();
int focusLevel = 0;
int masteryLevel = 0;
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));
}
public static double getMaxDmg(double max, AbstractCharacter agent) {
int primary = agent.getStatStrCurrent();
int secondary = agent.getStatDexCurrent();
int focusLevel = 0;
int masteryLevel = 0;
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));
}
public static void checkForProc(AbstractCharacter attacker, AbstractWorldObject target, Item weapon){
if(weapon == null) // cant proc without a weapon
return;
for(Effect eff : weapon.effects.values()){
for(AbstractEffectModifier mod : eff.getEffectsBase().getModifiers()){
if(mod.modType.equals(mbEnums.ModType.WeaponProc))
if(ThreadLocalRandom.current().nextInt(0,101) < 6)
((WeaponProcEffectModifier)mod).applyProc(attacker,target);
}
}
}
}
+13 -11
View File
@@ -8,12 +8,7 @@
package engine.gameManager;
/* This enumeration implements Magicbane's configuration data which
is loaded from environment variables.
*/
import engine.Enum;
import engine.net.NetMsgHandler;
import engine.mbEnums;
import engine.server.login.LoginServer;
import engine.server.world.WorldServer;
import org.pmw.tinylog.Logger;
@@ -28,6 +23,14 @@ import java.util.regex.Pattern;
public enum ConfigManager {
// MB Dev notes:
// Magicbane configuration is loaded from environment variables
//
// On boot the game first looks in /mb.conf for the file magicbane.conf.
//
// If not found, a default config is loaded from /mb.data to enable bootstrap.
// This version should never be modified.
MB_BIND_ADDR,
MB_EXTERNAL_ADDR,
@@ -106,12 +109,11 @@ public enum ConfigManager {
// and determine the server type at runtime.
public static final String DEFAULT_DATA_DIR = "mb.data/";
public static Map<String, String> configMap = new HashMap(System.getenv());
public static Enum.ServerType serverType = Enum.ServerType.NONE;
public static NetMsgHandler handler;
public static final Map<String, String> configMap = new HashMap(System.getenv());
public static mbEnums.ServerType serverType = mbEnums.ServerType.NONE;
public static WorldServer worldServer;
public static LoginServer loginServer;
public static Map<ConfigManager, Pattern> regex = new HashMap<>();
public static final Map<ConfigManager, Pattern> regex = new HashMap<>();
public static String currentRepoBranch = "";
@@ -126,7 +128,7 @@ public enum ConfigManager {
Logger.info(configSetting.name() + ":" + configSetting.getValue());
else {
Logger.error("Missing Config: " + configSetting.name());
Logger.error("This codebase requires >= MagicBox v1.5.1");
Logger.error("This codebase requires >= MagicBox v1.5.2");
Logger.error("docker pull magicbane/magicbox:latest");
return false;
}
+3 -51
View File
@@ -10,9 +10,9 @@ package engine.gameManager;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import engine.Enum;
import engine.Enum.GameObjectType;
import engine.db.handlers.*;
import engine.mbEnums;
import engine.mbEnums.GameObjectType;
import engine.objects.*;
import engine.server.MBServerStatics;
import engine.util.Hasher;
@@ -22,7 +22,6 @@ import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.EnumMap;
import java.util.EnumSet;
import java.util.concurrent.ConcurrentHashMap;
public enum DbManager {
@@ -177,7 +176,7 @@ public enum DbManager {
public static boolean addToCache(AbstractGameObject gameObject) {
boolean isWorldServer = ConfigManager.serverType.equals(Enum.ServerType.WORLDSERVER);
boolean isWorldServer = ConfigManager.serverType.equals(mbEnums.ServerType.WORLDSERVER);
if (!isWorldServer) {
if (MBServerStatics.SKIP_CACHE_LOGIN)
@@ -265,53 +264,6 @@ public enum DbManager {
}
public static <E extends java.lang.Enum<E>> EnumSet<E> parseEnumSet(String mysqlSet, Class<E> enumClass) {
// Create empty output set of the passed Enum class
EnumSet<E> enumSet = EnumSet.noneOf(enumClass);
// Early exit for empty sets
if (mysqlSet.isEmpty())
return enumSet;
// Split set string and trim each element
String[] elements = mysqlSet.split(";");
for (String element : elements) {
element = element.trim();
// Parse the element into an enum; add to the output set
try {
E enumConstant = java.lang.Enum.valueOf(enumClass, element);
enumSet.add(enumConstant);
} catch (Exception e) {
Logger.error(" Parse error: " + mysqlSet);
}
}
// Return the output set
return enumSet;
}
public static void printCacheCount(PlayerCharacter pc) {
ChatManager.chatSystemInfo(pc, "Cache Lists");
for (GameObjectType gameObjectType : GameObjectType.values()) {
if (objectCache.get(gameObjectType) == null)
continue;
String ret = gameObjectType.name() + ": " + objectCache.get(gameObjectType).size();
ChatManager.chatSystemInfo(pc, ret + '\n');
}
}
/**
* @return the conn
*/
+10 -6
View File
@@ -8,9 +8,9 @@
package engine.gameManager;
import engine.Enum;
import engine.devcmd.AbstractDevCmd;
import engine.devcmd.cmds.*;
import engine.mbEnums;
import engine.objects.AbstractGameObject;
import engine.objects.Account;
import engine.objects.PlayerCharacter;
@@ -22,6 +22,13 @@ import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
public enum DevCmdManager {
// MB Dev Notes:
// Class registers "Dev Commands" where access requires
// Status = "ADMIN" be set in the obj_account table
//
// Use these at your own risk.
DEV_CMD_MANAGER;
public static ConcurrentHashMap<String, AbstractDevCmd> devCmds;
@@ -35,9 +42,6 @@ public enum DevCmdManager {
DevCmdManager.registerCommands();
}
/**
*
*/
private static void registerCommands() {
// Player
@@ -72,6 +76,7 @@ public enum DevCmdManager {
DevCmdManager.registerDevCmd(new SetLevelCmd());
DevCmdManager.registerDevCmd(new SetBaseClassCmd());
DevCmdManager.registerDevCmd(new SetPromotionClassCmd());
DevCmdManager.registerDevCmd(new SetRaceCmd());
DevCmdManager.registerDevCmd(new SetRuneCmd());
DevCmdManager.registerDevCmd(new GetOffsetCmd());
DevCmdManager.registerDevCmd(new AddGoldCmd());
@@ -91,7 +96,6 @@ public enum DevCmdManager {
DevCmdManager.registerDevCmd(new RenameCmd());
DevCmdManager.registerDevCmd(new CreateItemCmd());
DevCmdManager.registerDevCmd(new SetRankCmd());
DevCmdManager.registerDevCmd(new MakeBaneCmd());
DevCmdManager.registerDevCmd(new RemoveBaneCmd());
DevCmdManager.registerDevCmd(new SetBaneActiveCmd());
DevCmdManager.registerDevCmd(new SetAdminRuneCmd());
@@ -156,7 +160,7 @@ public enum DevCmdManager {
//kill any commands not available to everyone on production server
//only admin level can run dev commands on production
if (a.status.equals(Enum.AccountStatus.ADMIN) == false) {
if (a.status.equals(mbEnums.AccountStatus.ADMIN) == false) {
Logger.info("Account " + a.getUname() + "attempted to use dev command " + cmd);
return false;
}
@@ -7,13 +7,15 @@
// www.magicbane.com
package engine.net;
package engine.gameManager;
import engine.Enum.DispatchChannel;
import engine.Enum.GameObjectType;
import engine.InterestManagement.WorldGrid;
import engine.gameManager.SessionManager;
import engine.math.Vector3fImmutable;
import engine.mbEnums.DispatchChannel;
import engine.mbEnums.GameObjectType;
import engine.net.AbstractNetMsg;
import engine.net.Dispatch;
import engine.net.MessageDispatcher;
import engine.net.client.ClientConnection;
import engine.objects.AbstractWorldObject;
import engine.objects.Item;
@@ -26,12 +28,17 @@ import java.util.HashSet;
import static engine.net.MessageDispatcher.dispatchCount;
import static engine.net.MessageDispatcher.maxRecipients;
/*
* Dispatch Message is the main interface to Magicbane's threaded
* async message delivery system.
*/
// MB Dev Notes:
// Dispatch Manager is the main interface to the threaded async message
// delivery system used by Magicbane.
//
// A Dispatch is .borrowed() and used to wrap an outgoing protocol message.
// A distribution list is created and passed to the MessageDispatcher for
// delivery.
public class DispatchMessage {
public enum DispatchManager {
DISPATCH_MANAGER;
public static void startMessagePump() {
@@ -83,7 +90,7 @@ public class DispatchMessage {
sourcePlayer = (PlayerCharacter) sourceObject;
if (sourcePlayer.getClientConnection() != null && sendToSelf) {
Dispatch dispatch = Dispatch.borrow(sourcePlayer, msg);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
DispatchManager.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
}
@@ -151,7 +158,7 @@ public class DispatchMessage {
if (sourcePlayer.getClientConnection() != null && sendToSelf) {
Dispatch dispatch = Dispatch.borrow(sourcePlayer, msg);
DispatchMessage.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
DispatchManager.dispatchMsgDispatch(dispatch, DispatchChannel.PRIMARY);
}
@@ -280,7 +287,7 @@ public class DispatchMessage {
}
protected static void serializeDispatch(Dispatch messageDispatch) {
public static void serializeDispatch(Dispatch messageDispatch) {
ClientConnection connection;
if (messageDispatch.player == null) {
+409
View File
@@ -0,0 +1,409 @@
// ·. · · · · .
// · ·
// · ·
//
// · · ·
// Magicbane Emulator Project © 2013 - 2022
// www.magicbane.com
package engine.gameManager;
import engine.loot.ModTableEntry;
import engine.loot.ModTypeTableEntry;
import engine.loot.WorkOrder;
import engine.mbEnums;
import engine.net.client.msg.ItemProductionMsg;
import engine.objects.City;
import engine.objects.Item;
import engine.objects.ItemTemplate;
import engine.objects.NPC;
import engine.powers.EffectsBase;
import org.pmw.tinylog.Logger;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.DelayQueue;
import java.util.concurrent.ThreadLocalRandom;
import java.util.concurrent.atomic.AtomicInteger;
public enum ForgeManager implements Runnable {
// MB Dev notes:
// Class implements forge rolling mechanics for Magicbane.
//
// .submit(workOrder) may be called from any thread: (ItemProductionMsgHandler).
// Concurrency is managed by same lock used for warehouse (city.cityTransactionLock).
// WorkOrders are persisted then reconstituted at bootstrap using table dyn.workorders.
// Forge window (ManageNPCMsg) uses item.upgradeDate to serialize completion time.
//
// Replaces garbage code that looked as if written by a mental patient.
//
// @TODO Reuse same set of virtual items for the life of a workOrder.
FORGE_MANAGER;
public static final BlockingQueue<WorkOrder> forge = new DelayQueue<>();
public static final AtomicInteger workOrderCounter = new AtomicInteger(0);
public static final ConcurrentHashMap<NPC, ConcurrentHashMap.KeySetView<WorkOrder, Boolean>> vendorWorkOrderLookup = new ConcurrentHashMap<>();
public static final ConcurrentHashMap<Item, WorkOrder> itemWorkOrderLookup = new ConcurrentHashMap<>();
@Override
public void run() {
WorkOrder workOrder;
while (true) {
// The forge is a blocking priority queue using an epoc sort.
// workOrders are popped once the workOrder.completionTime has
// passed.
try {
workOrder = forge.take();
// Early exit for completed workOrders loaded from disk
// or vendors who were re-deeded with items still cooking.
if (workOrder.vendor == null || workOrder.runCompleted.get())
continue;
// This workOrder has completed production.
if (workOrder.total_produced >= workOrder.total_to_produce) {
// CONFIRM_PRODUCE to refresh the interface after we add
// the Identified flag to the item.
for (Item workOrderItem : workOrder.cooking) {
workOrderItem.flags.add(mbEnums.ItemFlags.Identified);
ItemProductionMsg outMsg = new ItemProductionMsg(workOrder.vendor.building, workOrder.vendor, workOrderItem, mbEnums.ProductionActionType.CONFIRM_PRODUCE, true);
DispatchManager.dispatchMsgToInterestArea(workOrder.vendor, outMsg, mbEnums.DispatchChannel.SECONDARY, 700, false, false);
}
// Set this workOrder to completed and update on disk
workOrder.runCompleted.set(true);
DbManager.WarehouseQueries.WRITE_WORKORDER(workOrder);
continue;
}
// PERSIST our current cooking batch of virtual
// items then add to the vendor inventory
completeWorkOrderBatch(workOrder);
// Create new set of in-memory only virtual items
forgeWorkOrderBatch(workOrder);
// enQueue this workOrder again; back into the oven
// until all items for this workOrder are completed.
forge.add(workOrder);
// Debugging: Logger.info(workOrder.toString());
} catch (Exception e) {
Logger.error(e);
}
}
}
public static void start() {
Thread forgeManager;
forgeManager = new Thread(FORGE_MANAGER);
forgeManager.setName("Forge Manager");
forgeManager.start();
}
public static int submit(WorkOrder workOrder) {
// Must have a city to roll anything
City city = workOrder.vendor.building.getCity();
if (city == null)
return 58; //58: The formula is beyond the means of this facility
// Concurrency is rightly managed by same lock as warehouse
city.transactionLock.writeLock().lock();
// Make sure vendor can roll the formulae, warehouse can
// afford this wordOrder and other related checks.
int validation_result = WorkOrder.validate(workOrder);
// The return code is used by the caller (ItemProductionMsgHandler)
// for display of a popup error message to the player.
if (validation_result != 0)
return validation_result;
// Configure this production run.
try {
workOrder.workOrderID = workOrderCounter.incrementAndGet();
workOrder.rollingDuration = NPCManager.calcRollingDuration(workOrder.vendor, workOrder.templateID);
workOrder.completionTime = System.currentTimeMillis() + workOrder.rollingDuration;
workOrder.slots_used.set(calcAvailableSlots(workOrder));
if (workOrder.slots_used.get() == 0)
return 58;
workOrder.total_produced = 0;
// Single item configuration from protocol message (ItemProductionMsg)
if (workOrder.multiple_slot_request == false && workOrder.total_to_produce == 0)
workOrder.total_to_produce = 1;
// Calculate total cost for this production run
workOrder.total_to_produce *= workOrder.slots_used.get();
workOrder.production_cost = calcProductionCost(workOrder);
workOrder.production_cost.forEach((key, value) -> workOrder.production_cost_total.put(key, value * workOrder.total_to_produce));
// Withdraw gold and resources. Availability has previously been validated.
if (!WorkOrder.withdrawWorkOrderCost(workOrder))
return 58; //58: The formula is beyond the means of this facility
// Create new batch of virtual items
forgeWorkOrderBatch(workOrder);
// Assign the new workOrder to the vendor
vendorWorkOrderLookup.get(workOrder.vendor).add(workOrder);
// Enqueue the new workOrder
forge.add(workOrder);
// PERSIST workOrder (dyn_workorders)
DbManager.WarehouseQueries.WRITE_WORKORDER(workOrder);
} catch (Exception e) {
Logger.error(e);
} finally {
city.transactionLock.writeLock().unlock();
}
Logger.info(workOrder.toString());
return validation_result;
}
public static int calcAvailableSlots(WorkOrder workOrder) {
// Slots available in a forge are based on the npc rank
int availableSlots = workOrder.vendor.getRank();
// Subtract the slots currently assigned to other workOrders for this vendor
for (WorkOrder npcWorkOrder : ForgeManager.vendorWorkOrderLookup.get(workOrder.vendor))
availableSlots = availableSlots - npcWorkOrder.cooking.size();
// Single item rolls are always a single slot
if (availableSlots > 0 && workOrder.multiple_slot_request == false)
availableSlots = 1;
return availableSlots;
}
public static HashMap<mbEnums.ResourceType, Integer> calcProductionCost(WorkOrder workOrder) {
// Calculate production cost for a single run of the workOrder
HashMap<mbEnums.ResourceType, Integer> production_cost = new HashMap<>();
ItemTemplate template = ItemTemplate.templates.get(workOrder.templateID);
// Add gold and resource costs from template
production_cost.put(mbEnums.ResourceType.GOLD, template.item_value);
production_cost.putAll(template.item_resource_cost);
// Calculate cost of prefix and suffix
if (workOrder.prefixToken != 0) {
EffectsBase prefix = PowersManager.getEffectByToken(workOrder.prefixToken);
production_cost.putAll(PowersManager._effect_costMaps.get(prefix.getIDString()));
}
if (workOrder.suffixToken != 0) {
EffectsBase suffix = PowersManager.getEffectByToken(workOrder.suffixToken);
production_cost.putAll(PowersManager._effect_costMaps.get(suffix.getIDString()));
}
return production_cost;
}
public static Item forgeItem(WorkOrder workOrder) {
// Create new virtual item from specified template
ItemTemplate template = ItemTemplate.templates.get(workOrder.templateID);
Item forgedItem = new Item(workOrder.templateID);
// forgedItem gets a negative id; a virtual item which is not persisted
forgedItem.objectUUID = ItemManager.lastNegativeID.getAndDecrement();
forgedItem.containerType = mbEnums.ItemContainerType.FORGE;
forgedItem.ownerID = workOrder.vendor.getObjectUUID();
// item.upgradeDate is serialized (ItemProductionMsg)
// for vendor forge window completion time.
forgedItem.setDateToUpgrade(workOrder.completionTime);
// Assign a prefix and suffix to this item if random rolled
if (workOrder.prefixToken == 0 && workOrder.vendor.getItemModTable().contains((template.modTable)))
forgedItem.prefixToken = calcRandomMod(workOrder.vendor, mbEnums.ItemModType.PREFIX, template.modTable);
else
forgedItem.prefixToken = workOrder.prefixToken;
if (workOrder.suffixToken == 0 && workOrder.vendor.getItemModTable().contains((template.modTable)))
forgedItem.suffixToken = calcRandomMod(workOrder.vendor, mbEnums.ItemModType.SUFFIX, template.modTable);
else
forgedItem.suffixToken = workOrder.suffixToken;
// Random rolled items are unidentified until completed
if (workOrder.prefixToken == 0 && workOrder.suffixToken == 0)
forgedItem.flags.remove(mbEnums.ItemFlags.Identified);
else
forgedItem.flags.add(mbEnums.ItemFlags.Identified);
// Add virtual item to in-memory caches
workOrder.cooking.add(forgedItem);
DbManager.addToCache(forgedItem);
itemWorkOrderLookup.put(forgedItem, workOrder);
return forgedItem;
}
public static void completeWorkOrderBatch(WorkOrder workOrder) {
ArrayList<Item> toRemove = new ArrayList<>();
for (Item virutalItem : workOrder.cooking) {
// Identify completed items
virutalItem.flags.add(mbEnums.ItemFlags.Identified);
virutalItem.containerType = mbEnums.ItemContainerType.INVENTORY;
// Persist item
Item completedItem = DbManager.ItemQueries.PERSIST(virutalItem);
// Copy Prefix and Suffix tokens from virtual item.
completedItem.prefixToken = virutalItem.prefixToken;
completedItem.suffixToken = virutalItem.suffixToken;
// Add effects for the tokens. Writes to disk using
// table dyn_item_enchantment
ItemManager.applyItemEffects(completedItem);
// Add to the vendor inventory
workOrder.vendor.charItemManager.addItemToInventory(completedItem);
ItemProductionMsg outMsg1 = new ItemProductionMsg(workOrder.vendor.building, workOrder.vendor, completedItem, mbEnums.ProductionActionType.DEPOSIT, true);
DispatchManager.dispatchMsgToInterestArea(workOrder.vendor, outMsg1, mbEnums.DispatchChannel.SECONDARY, 700, false, false);
ItemProductionMsg outMsg2 = new ItemProductionMsg(workOrder.vendor.building, workOrder.vendor, completedItem, mbEnums.ProductionActionType.CONFIRM_DEPOSIT, true);
DispatchManager.dispatchMsgToInterestArea(workOrder.vendor, outMsg2, mbEnums.DispatchChannel.SECONDARY, 700, false, false);
toRemove.add(virutalItem);
}
for (Item virtualItem : toRemove) {
// Remove virtual items from the forge window
ItemProductionMsg outMsg = new ItemProductionMsg(workOrder.vendor.building, workOrder.vendor, virtualItem, mbEnums.ProductionActionType.CONFIRM_SETPRICE, true);
DispatchManager.dispatchMsgToInterestArea(workOrder.vendor, outMsg, mbEnums.DispatchChannel.SECONDARY, 700, false, false);
// Remove virtual item from all collections
workOrder.cooking.remove(virtualItem);
itemWorkOrderLookup.remove(virtualItem);
DbManager.removeFromCache(virtualItem);
}
}
public static void forgeWorkOrderBatch(WorkOrder workOrder) {
// Completion time for this batch is in the future
workOrder.completionTime = System.currentTimeMillis() + workOrder.rollingDuration;
for (int i = 0; i < workOrder.slots_used.get(); ++i) {
Item forged_item = forgeItem(workOrder);
// Update NPC window
ItemProductionMsg outMsg = new ItemProductionMsg(workOrder.vendor.building, workOrder.vendor, forged_item, mbEnums.ProductionActionType.CONFIRM_PRODUCE, true);
DispatchManager.dispatchMsgToInterestArea(workOrder.vendor, outMsg, mbEnums.DispatchChannel.SECONDARY, 700, false, false);
workOrder.total_produced = workOrder.total_produced + 1;
}
// Write updated workOrder to disk
DbManager.WarehouseQueries.WRITE_WORKORDER(workOrder);
}
public static int calcRandomMod(NPC vendor, mbEnums.ItemModType itemModType, int modTable) {
// Random prefix or suffix token based on item.template.modtable
int modifier = 0;
ModTypeTableEntry modTypeTableEntry = null;
ModTableEntry modTableEntry;
int rollForModifier;
switch (itemModType) {
case PREFIX:
int randomPrefix = vendor.getModTypeTable().get(vendor.getItemModTable().indexOf(modTable));
modTypeTableEntry = ModTypeTableEntry.rollTable(randomPrefix, ThreadLocalRandom.current().nextInt(1, 100 + 1));
break;
case SUFFIX:
int randomSuffix = vendor.getModSuffixTable().get(vendor.getItemModTable().indexOf(modTable));
modTypeTableEntry = ModTypeTableEntry.rollTable(randomSuffix, ThreadLocalRandom.current().nextInt(1, 100 + 1));
break;
}
if (modTypeTableEntry == null)
return 0;
rollForModifier = ThreadLocalRandom.current().nextInt(1, 100 + 1);
if (rollForModifier < 80) {
int randomModifier = LootManager.TableRoll(vendor.getLevel(), false);
modTableEntry = ModTableEntry.rollTable(modTypeTableEntry.modTableID, randomModifier);
// @TODO : Figure out how a null can be returned from a defined set.
if (modTableEntry == null)
return 0;
EffectsBase effectsBase = PowersManager.getEffectByIDString(modTableEntry.action);
modifier = effectsBase.getToken();
}
return modifier;
}
}

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